Universitatea Tehnică a Moldovei

FCIM
Departamentul de Informatica si Inginerie Software

RAPORT
la lucrarea de laborator nr.7

la Programarea Calculatoarelor

Tema: Prelucrarea şirurilor caracteriale cu ajutorul funcţiilor standarde

Varianta 66

A efectuat: st. gr. Ti-181_ Ciubotaru Mihai.

A verificat: Marin Ştefan

Chişinău – 2018
 Scopul lucrării:
- Dezvoltarea procedeelor de algoritmizare şi progamare prin integrarea modulelor in program pentru
prelucrarea sirurilor de caractere, analizând soluţiile stereotipe şi cele eficiente de introducere,
afişare şi alte operatii.
- Insuşirea principiilor de perfecţionare a tehnicii de programare cu subprograme standarde si definite
pentru prelucrarea datelor şi şirurilor de caractere in TC.
- Insuşirea procedeelor de elaborare si utilizarea efectiva a programelor cu proceduri si funcţii
predefinite pentru prelucrarea şirurilor caracteriale.
- Analiza elementelor specifice ale funcţiilor predefinite prin algoritmizare si programare pentru
prelucrarea fragmentelor de texte prin comparaţia soluţiilor stereotipice cu cele eficiente pentru
diverse moduri de manipulare ale textelor.

Obiectivele temei:
1. Aprofundarea studierei principiilor prelucrării (descrierii, declarării, formării, etc.) şirurilor caracteriale
în C.
2. Studierea metodelor şi tehnicilor de bază de prelucrare a textelor ca şiruri caracteriale, utilizînd
subprograme definite şi predefinite.
3. Analizaţi construcţia prin scenarii programul pentru determinarea rezultatelor şi verificarea
corectitudinei testelor propuse.
4. Elaborarea algoritmului şi programului de soluţionare a variantei.

1. Elaborarea aplicatiilor In baza setului de proceduri si funcţii predefinite pentru prelucrarea

şirurilor caracteriale (luc. Lab.Nr.6) vom folosi principiile programării structurate pentru elaborarea
aplicatiilor.
Realizarea unei aplicatii folosind un sistem de calcul presupune parcurgerea, in principiu, a
urmatoarelor etape:
 Analiza problemei
 Proiectarea aplicatiei
 Implementarea aplicatiei
 Intretinerea aplicatiei
Analiza problemei . Elaborarea unui enunt complet si precis al problemei, tinand cont de conditiile concrete
de realizare si executie a aplicatiei. Ca obiective devin urmatoarele:
•  Stabilirea functiei aplicatiei (ce urmeaza sa realizeze aceasta)
•  Identificarea informatiei de prelucrat (datele de intrare)
•  Identificarea rezultatelor cerute (datele de iesire)
Referirea datelor se realizeaza cu ajutorul unor notatii simbolice, numite variabile.
Rezultatul etapei de analiza se numeste specificatia aplicatiei si ea trebuie sa contina:
•  Lista variabilelor de intrare
•  Modelul de prelucrare
•  Descrierea organizarii datelor pe suporturile externe de informatii
Proiectarea aplicatiei . Elaborarea algoritmului care realizeaza functiile aplicatiei. Adica, conceperea unei
liste de comenzi care descrie secventa de operatii pe care le va executa compiatorul pentru rezolvarea
problemei.
In cazul problemelor complexe, proiectarea decurge in doua etape:
•  Descompunerea problemei date in subprobleme;
•  Construirea algoritmilor de rezolvare a subproblemelor.
In aceste cazuri logica aplicatiei este reprezentata printr-o colectie de algoritmi corelati intr-o structura
ierarhica. Aplicatia obtinuta este un sistem de module, fiecare modul rezolvand una din subproblemele in
care a fost divizata logica aplicatiei.
Avantajele modularizarii aplicatiilor sunt:
•  Simplificarea procesului de codificare;
•  Simplificarea procesului de dezvoltare si verificare a algoritmilor;
•  Simplificarea procesului de testare si depanarea aplicatiei;
•  Posibilitatea refolosirii modulelor componente.

Deci ca obiective devin urmatoarele: Realizarea algoritmilo modulelor si integrarea in programul care sa
rezolve problema propusa.
Implementarea aplicatiei. Codificarea algoritmilor (programarea) si punerea la punct a aplicatiei.
Obtinerea algoritmilor necesari intocmirii programului care rezolva problema propusa, testarea rezultatelor
obtinute si corectarea eventualelor erori de programare.
 Intretinerea aplicatiei: Efectuarea modificarilor necesare in scopul corectarii unor erori
identificate in cursul exploatarii ei sau pentru a o adapta la noile cerinte aparute.

In mod probabil, cel mai comun tip de tablouri in limbajul C este

tabloul de caractere. Pentru a ilustra folosirea tablourilor de caractere
si a functiilor care le manipuleaza, vom scrie un program care citeste un
set de linii si o tipareste pe cea mai lunga. Schita lui este
destul de simpla:
while (mai exista o alta linie)
if (este mai lunga decit linia anterioara) salveaza-o pe ea si lungimea ei tipareste linia cea mai
lunga
Aceasta schita ne arata clar ca programul se imparte in bucati. O bucata citeste o linie noua, o alta bucata o
testeaza, o alta o salveaza iar restul controleaza procesul. Deoarece lucrurile se impart aşa de frumos, ar fi
mai bine sa le scriem la fel. Pentru aceeasta, vom scrie la inceput o functie getline care va citi urmatoarea
linie de la intrare; ea este generalizare a functiei getchar. Pentru a face functia utila si in alte contexte, vom
incerca sa o scriem cit mai flexibil. In mod minim, getline va trebui sa returneze un semnal despre posibilul
sfirsit de fisier; proiectind-o mai general,ea va trebui sa returneze lungimea liniei sau zero daca se intilneste
sfirsitul de fisier. Zero nu este niciodata o lungime valida de linie, deoarece orice linie are cel putin un
caracter, chiar si o linie ce contine numai caracterul "linie noua" are lungimea 1.
Cind gasim o linie care este mai lunga decit linia cea mai lunga gasita anterior, trebuie sa o salvam undeva.
ceasta sugereaza o a doua functie, copy, pentru a salva noua linie intr-un loc sigur. In final, avem nevoie de
un program principal care sa controleze functiile getline si copy. Iata rezulatul:
#define MAXLINE 1000 /* lungimea maxima a liniei */
main() /* gaseste linia cea mai lunga */
{ int len; /* lungimea liniei curente */ int max; /* lungimea maxima gasita pina acum */
char line[MAXLINE]; /* linia curenta introdusa */ char save[MAXLINE]; /* cea mai lunga linie
salvata */
max = 0; while ((len = getline(line, MAXLINE)) > 0) if (len > max) {max = len; copy(line, save);
}
if (max > 0) /* s-a citit cel putin o linie */ printf("%s", save);
}
getline (s, lim) /* citeste linia in s, returneaza lungimea */
char s[]; int lim;
{ int c, i; for(i = 0; i < lim - 1 && (c=getchar())!=EOF && c!='\n';++i) s[i] = c;
if (c == '\n') { s[i] = c; ++i; } s[i] = '\0'; return(i); }
copy(s1, s2) /* copiaza pe s1 in s2; s2 suficient de mare */
char s1[], s2[];
{ int i; i = 0; while ((s2[i] = s1[i]) != '\0') ++i; }
main si getline comunica intre ele printr-o pereche de argumente si o valoare returnata. In getline,
argumumentele sint declarate prin liniile:
char s[];
int lim;
care spun ca primul argument este un tablou iar al doilea un intreg. Lungimea tabloului s nu este specificata
in getline deoarece ea este determinata in main. "getline" foloseste instructiunea return pentru a trimite o
valoare inapoi apelantului, la fel cum facea si functia power. Unele functii returneaza o valoare utila; altele,
de exemplu copy, sint folosite numai pentru efectul lor si nu returneaza nici o valoare.
getline pune caracterul \0 (caracterul nul, a carui valoare este zero) la sfirsitul tabloului pe care il creaza,
pentru a marca sfirsitul sirului de caractere. Aceasta conventie este folosita de asemenea si de catre
compilatorul C; cind o constanta sir de tipul "hello\n" este scrisa intr-un program C, compilatorul isi
creaza un tablou de caractere continind carcterele sirului si terminat cu \0, astfel incit o functie, de exemplu
printf, poate sa-i determine sfirsitul.
-------------------------------
| h | e | l | l | o | \n | \0 |
-------------------------------
Specificatorul de format %s din printf se asteapta la un sir reprezentat tocmai in aceasta forma. Daca
examinati functia copy, veti descoperi ca si ea se bizuie de fapt pe terminarea argumentului sau de intrare s1
cu un \0 si ea copiaza acest caracter in argumentul de iesire s2. (Toate acestea presupun ca \0 nu este parte a
unui text normal).
Este demn de mentionat in trecere ca, un program, chiar si atit de mic ca acesta, prezinta unele
probleme delicate de proiectare. De exemplu, ce ar face main daca ar intilni o linie mai mare decit limita sa?
getline lucreaza bine, adica se va opri atunci cind tabloul este plin chiar daca nu a intilnit nici un caracter
"linie noua". Testind lungimea si ultimul caracter returnat, main poate determina cind a fost linia prea lunga
si apoi sa actioneze cum vrea. Pentru a scurta programul, am ignorat acest aspect.
Nu exista vre-o cale pentru utilizatorul lui getchar de a sti inainte cit va fi de lunga o linie de intrare,
aşa ca getline verifica daca nu s-a produs o depasire. Pe de alta parte, utilizatorul lui copy stie intodeauna
(sau poate descoperi) cit este de mare sirul, aşa ca nu trebuie sa adaugam la functie o verificare de erori.

2. Structura unui program în C:

Orice program in C conţine:

#include <biblioteca.h> //bibliotecile ce vor fi folosite în programul curent

tip nume(…) // declararea funcţiilor suplimentare ce vor fi utilizate în program

tip main(...) //funcţia de bază care se execută în primul rînd

{
// calculele efectuate în funcţia de bază
}

tip nume(…) //implementarea funcţiilor suplimentare

{
// calculele efectuate în funcţiile suplimentare
}

3.Sarcina: Condiţia problemei:

Este dat un şir de caractere, care conţine de la 2 pînă la 20 de cuvinte. Cuvintele sunt separate prin spaţiu; după ultimul
cuvînt urmează punct. Transformaţi şi afişaţi fiecare cuvînt al şirului după regulile următoare:
 deplasaţi prima literă a cuvîntului la sfîrşitul lui ;
 deplasaţi ultima literă la începutul cuvîntului;
 înlăturaţi ultima literă a cuvîntului;
 înlăturaţi literele precedente ale fiecărei litere care se repetă într-un cuvînt;
 dacă lungimea cuvîntului este un număr impar, atunci înlăturaţi litera din mijloc.
Scheme-logice a subprogramelor programului:
Schema-logica a programului principal main:
5.Analiza corectudinii algoritmului prin simulare numerica:
Start:
Sirul: sunt la laboratorul de programare.
Variant 1
suns ll laboratorul dd programarp //prima litera s-a dus la capat

Variant 2
tunt aa laboratorul ee erogramare //ultima litera s-a dus la inceput

Varianta3
sun l laboratoru d programar //s-a omis ultima litera

variant 4
sunt la l b atoru de p og mare //s-a sters literele care s-au repetat in cuvant

variant 5
sunt la labor torul de programare //s-a sters litera din mijlocul cuvantului

Stop.

6.Listing-ul programului:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char input[1000],*p,* cuv[500],r[2],input2[1000];

int j=0,var,pr,x,i,q,k=0;

int delimitare_cuvinte(int p)
{
p = strtok(input, " "); //selectarea cuvintelor din sir

while(p){
printf("%s\n", p);
cuv[i]=p;
i++;
if(p){
p = strtok(NULL, " .");

}
}

deplasare_lit_sfarsit()
{
for(k=0;k<i;k++){

pr=strlen(cuv[k]); //determinarea lungimii cuvantului

cuv[k][pr-1]=cuv[k][0]; //ultima litera a cuvantului se inlocuieste cu prima

printf("%s \n",cuv[k]); //afisarea cuvantului modificat
}
 }

deplasare_lit_inceput()
{
for(k=0;k<i;k++){

pr=strlen(cuv[k]); //determinarea lungimii cuvantului

cuv[k][0]=cuv[k][pr-1]; //prima litera a cuvantului se inlocuieste cu ultima

printf("%s \n",cuv[k]); //afisarea cuvantului modificat

}
}

inlaturare_ult_litera()
{
for(k=0;k<i;k++){

pr=strlen(cuv[k]); //determinarea lungimii cuvantului

cuv[k][pr-1]=NULL; //ultimei litere a cuvantului i se atribuie character null

printf("%s \n",cuv[k]); //afisarea cuvantului modificat
}
}

inlaturare_lit_precedente()
{
for(k=0;k<i;k++){ //se parcurge fiecare cuvant din sir

pr=strlen(cuv[k]); //determinarea lungimii cuvantului

x=0;
for (j=0;j<pr;j++){ //se parcurge fiecare litera din cuvant

for (q=x;q<pr;q++){ //se compara litera de pe pozitia x cu fiecare litera din cuvant
if(cuv[k][x]==cuv[k][q+1]){ //se verificadaca caracterul de pe pozitia x este urmat de acelasi
element
cuv[k][x]=' '; //daca conditia e valida,caracterul precedent din cuvant se inlocuieste cu
spatiu

}
}
x++;
}

printf("%s \n",cuv[k]); //se afiseaza cuvintele sirului modificat

}
}

inlaturare_lit_mijloc()
{
for(k=0;k<i;k++){
pr=strlen(cuv[k]); //determinarea lungimii cuvantului
if (pr%2!=0){ //se cerceteaza daca cuvantul este impar
cuv[k][pr-((pr/2)+1)]=' '; } //pentru cuvintele impare se determina mijlocul cuvantului si se
inlocuieste cu spatiu
 printf("%s \n",cuv[k]); //se afiseaza cuvintele sirului modificat
}
}
int main()
{
puts("Dati sirul de caractere de la 2 la 20 de cuvinte");gets(&input); //se citeste sirul
strcat(input2,input);
printf("\n Cuvintele sirului sunt:\n");
delimitare_cuvinte(p); //se apeleaza functia de delimitare a cuvintelor din sir
printf("\n");

et: //eticheta
printf(" <<< Variantele de executare >>>\n");
printf(" [1] Deplasarea primei litere a cuvintului la sfirsitul lui\n");
printf(" [2] Deplasarea ultimei litere la inceputul cuvintului\n");
printf(" [3] Inlaturarea ultimei litere a cuvintului\n");
printf(" [4] Inlaturarea literelor precedente ale fiecarei litere care se repeta intr-un cuvint\n");
printf(" [5] Inlaturarea literei din mijloc, daca lungimea cuvintului este un numar impar\n");
printf("\n Care varianta doriti sa se execute?: ");
scanf("%d",&var); //citesc o variabila care sa corespunda cu nr variantei dorite sa se execute
switch(var){
case 1:{
printf("\n Cuvintele sirului modificat sunt:\n");
deplasare_lit_sfarsit();

};break;
case 2:{
printf("\n Cuvintele sirului modificat sunt:\n");
deplasare_lit_inceput();

};break;
case 3:{
printf("\n Cuvintele sirului modificat sunt:\n");
inlaturare_ult_litera();

};break;
case 4:{
printf("\n Cuvintele sirului modificat sunt:\n");
inlaturare_lit_precedente();

};break;
case 5:{
printf("\n Cuvintele sirului modificat sunt:\n");
inlaturare_lit_mijloc();

};break;
default: printf("Nu exista asa varianta");break; //variabila citita anterior nu satisfice nici o
conditie a switch-ului

}
printf("\n\n Doriti sa continuati executarea? (da/nu) : ");scanf("%s",r);
if(!strcmp(r,"da")){ //se verifica daca sirul de character coincide cu variabila citita
system("@cls||clear");
printf(" Sirul de caractere este:\n");
puts(input2);
printf("\n");
goto et; //daca conditia if-ului e adevarata se face salt la eticheta si programul continua
}else{
 system("exit"); //daca se raspunde cu nu ,atunci programul sfarseste
}
}

7 După execuţia programului am obţinut următorul rezultat pe ecran

8. Analiza rezultatului:
1. Verificarea ne arata ca rezultatele obtinute sunt corecte si programul lucreaza corect.
 2. Efectuarea programelor cu ajutorul subprogramelor este eficienta deoarece subprogramul
poate fi apelat de mai multe ori in programul principal, ceea ce optimizeaza programul si
totodata usureaza procesul de lucru.
3. Utilizarea procedurilor este comoda ,mai ales in cazul cand subprogramul trebuie sa
returneze mai multe valori,ceea ce nu putem obtine cand utilizam o functie,deoarece aceasta
returneaza in programul principal doar o singura valoare.

9.Concluzii:
In urma efectuarii acestei lucrari de laborator am acumulat cunostinte si deprinderi de efectuare
a programelor in limbajul C cu structura ciclica,folosind concomitent subprograme.
Pentru efectuarea programului am folosit instructiunea switch ,care este o instructiune de
ramificare.Ea permite executarea programului prin selectarea anumitor parti ale programului cu
ajutorul comenzii case.
Pentru executarea variantelor propuse am folosit anumite functii predefinite a tipului de tade char
precum: strlen(...) pentru determinarea lungimii sirului de caractere; strtok(...) pentru despartirea
sirului in cuvinte; strcmp(...) pentru a compara 2 siruri de caractere,etc.
Programul respectiv l-am executat prin intermediul compilatorului Code::Blocks. Compilatorul
Code::Blocks are butonul “Build & Run” care da in executie programul elaborat. In partea de jos
avem bara care ne arata pe ce linie avem eroare in cod. Eroarea ne este comunicata intre ghilimele.
Dupa lichidarea acesteia este necesar de apasat butonul “Build & Run” pentru executia programului.
Programul se salveaza intr-un fisier cu extensia “.c”.
De asemenea, butonul “projects” ne ofera posibilitatea de a adauga sau cauta proiecte deja
effectuate si care se afla in PC. Ca si in alte compilatoare,in Code::Blocks putem gasi in bara de
meniuri butonul “Help”,unde ne este afisata informatie in functie de problema care ne intereseaza in
legatura cu aplicatia data
Am ales acest compilator deoarece este usor de utilizat si anume usureaza procesul de vizualizare
a rezultatului programului.

10.Bibliografia
Indicatii metodice nr. 1
Indicatii metodice nr. 2
Indicatii metodice nr. 3
Indicatii metodice nr. 4
Indicatii metodice nr. 5
Indicatii metodice nr. 6
Indicatii metodice nr. 7

 Teste propuse spre implementare

1. Test: Determinarea celui mai lung cuvant si cuvintele ce incep cu o vocala:
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <ctype.h>
#define LUNG 80

#define NR 15

char tab_cuv[NR][LUNG];
int nr_cuv=0;  /* numarul cuvintelor introduse */

void citire_cuv(void){
 printf("*** Se introduc maxim %d cuvinte, terminate cu
CTRL/Z:\n",NR);   while(nr_cuv<NR && gets(tab_cuv[nr_cuv]))nr_cuv++; 
       /* la CTRL/Z gets returneaza NULL (= 0) */
  /* citirea se poate face si cu scanf:
  while(nr_cuv<NR && scanf("%s",tab_cuv[nr_cuv])!=EOF)nr_cuv++; */
   /* daca terminarea se face cu un cuvant vid:
  while(nr_cuv<NR && strcmp("",gets(tab_cuv[nr_cuv])))nr_cuv++; */
}

void constr_cuv(void){
  char c,cuv[NR+1]; /* lungimea maxima este egala cu numarul maxim de
cuvinte + 1 pentru terminator */
  int i,j; /* i parcurge cuvintele din tab_cuv, j pozitiile din cuv */
  for(i=j=0;i<nr_cuv;i++)
    if(isalpha(c=tolower(tab_cuv[i][strlen(tab_cuv[i])-1])))
      cuv[j++]=c;
  cuv[j]='\0';
  printf("*** Cuvantul construit:|%s|\n",cuv);
}

void cuv_max(void){
  int i,lung_crt,lung_max=0; 
  char * p_max; /* pointerul spre cuvantul maxim */
    /* se poate memora indicele cuvantului maxim: int i_max;
       sau memora cuvantul maxim intr-un sir: char c_max[LUNG]; */
  for(i=0;i<nr_cuv;i++)
    if((lung_crt=strlen(tab_cuv[i]))>lung_max){
      p_max=tab_cuv[i];
      lung_max=lung_crt;
    }
  printf("*** Cuvantul de lungime maxima %d este:|
%s|\n",lung_max,p_max);
}

void cuv_vocale(void){
  int i;
  puts("*** Cuvintele ce incep cu vocale:");
  for(i=0;i<nr_cuv;i++)
    switch(toupper(tab_cuv[i][0])){
     case 'A': case'E': case 'I': case 'O': case 'U':puts(tab_cuv[i]);
   }  /* in loc de switch se putea folosi
  char c; if(c=toupper(tab_cuv[i][0]),c=='A' ||
     c=='E' || ...)puts(tab_cuv[i]); */
}

void main(void){

  citire_cuv();
  cuv_max();
  constr_cuv();
  cuv_vocale();
  getch();
} 
 2. Test: Concatenarea a 2 siruri de caractere.
#include <stdio.h>
#include <string.h>
#define LUNGS 80

void main(void){
  char s1[LUNGS],s2[LUNGS],s3[LUNGS],rezultat[LUNGS];
  char *s1ptr=s1,*s2pos, *rezptr=rezultat;

  puts("*** sirul s1:"); gets(s1);

  puts("*** subsirul s2:"); gets(s2);
  puts("*** s3:"); gets(s3);

  while(s2pos=strstr(s1ptr,s2)){ 
    while(s1ptr<s2pos)*rezptr++=*s1ptr++;
    strcpy(rezptr,s3);
    rezptr+=strlen(s3);
    s1ptr+=strlen(s2);
  }
  strcpy(rezptr,s1ptr);
  puts("*** sirul rezultat:"); puts(rezultat);
  getch();
} 

3. Test: Deplasarea primei litere la sfarsitul cuvintelor;

Inlaturarea penultimei litere a cuvintelor; Inlaturarea literei din
mijloc a cuvintelor de lungime impara.
#include<conio.h>
#include<stdio.h>
#include<string.h>
#define NMAX 500

char s[NMAX],cv[NMAX],cuv[NMAX][25],*p,c;
int ncuv=0,l,i,j;
void generare2(int i)
{
strcpy(cv,cuv[i]);
l=strlen(cv);
if(l%2) { for(j=l/2;j<l-1;j++) cv[j]=cv[j+1]; cv[l-1]='\0';
}
printf("%s ",cv);
if (i<ncuv) { i++; generare2(i);
}
}

void generare1(int i)
{
strcpy(cv,cuv[i]); l=strlen(cv);
if(l>1) { cv[l-2]=cv[l-1]; cv[l-1]='\0'; } printf("%s ",cv);
if (i<ncuv) { i++; generare1(i); }
}

void generare(int i)
{
strcpy(cv,cuv[i]); l=strlen(cv); c=cv[0];
for(j=0;j<l-1;j++) cv[j]=cv[j+1]; cv[l-1]=c; printf("%s ",cv);
if (i<ncuv)
{ i++; generare(i); }
 }

void main() {
printf("Introduceti şirul de caractere:\n"); gets(s);

// Extragerea cuvintelor din şir

p=strtok(s," ");
while(p) { strcpy(cuv[ncuv++],p); p=strtok(NULL," "); }

// Stergerea punctului din ultimul cuvant

l=strlen(cuv[ncuv-1]); if(cuv[ncuv-1][l-1]=='.') cuv[ncuv-1][l-1]='\0';

// a)
printf("\n a) Deplasarea primei litere la sfarsitul cuvintelor:\n"); generare(0); printf("\b.\n\n");

// b)
printf("b) Inlaturarea penultimei litere a cuvintelor:\n"); generare1(0); printf("\b.\n\n");

// c)
printf("c) Inlaturarea literei din mijloc a cuvintelor de lungime impara:\n"); generare2(0); printf("\b.\n\n");

getch();
}

4.Test: Calcularea nr. de cuvinte intr-un sir

#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
char s[50],s1[20],sr[50],c;
int t=1,i=0,k=0,q=0,h,con=0,j;
gets(s);
for(j=0;j<strlen(s);j++) if(s[j]==' ') con++;

while(s[i]!='\0'&&c!='\0')
{ if (t%2==0)
{
while (s[i]!=' '&&s[i]!='\0')
{
s1[k]=s[i];
k++;
i++;
}
k--;
for (h=k;h>=0;h--,q++)
sr[q]=s1[h];
sr[q]=' ';
q++;
k=0;
}
c='1';
while(c!=' '&&c!='\0')
 {
c=s[i];
i++;
}
t++;
}
sr[q-1]='\0';
//puts(sr);
printf("\n%d",con+1);
/*i=0;
while (sr[i]!='\0'){printf("%c",sr[i]);i++; } */
getch();
}

5.Test: Este dat un şir de caractere care conţine de la 5 până la 25 cuvinte si cuvintele sunt separate prin
spaţiu; iar dupa ultimul cuvint urmeaza punct.
 deplasarea primei litere la sfârşitul cuvintului;
 inlaturarea penultimei litere a cuvintului;
 verificarea daca lungimea cuvintului este impara şi se înlătură litera din mijlocul lui.

Varianta 1. Listingul programului :

#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
printf("\n\t\t\t------------------------------------");
printf("\n\t\t\t---------- ___________________ј");
printf("\n __________________________________________________");
char s[100],cv[100][100],sc; int i,j,n,k,l;
printf("Introduceti propozitia dorita formata cel putin din 5 cuvinte si maximum din 25 sa fie sfirşita
de punct.\nIntroduceti:");
gets(s);
k=0;l=0;i=0;
while(s[i]!='.')
{
if(s[i]==' ') { cv[k][l]='\0'; k++; l=0; i++; }
cv[k][l]=s[i];
l++; i++;
if(s[i]=='.') { cv[k][l]='\0'; k++; }
}
for(i=0;i<k;i++)
{
cv[i][strlen(cv[i])-1]='\0';
}
for(i=0;i<k;i++)
{
j=0; sc=cv[i][j];
for(j=0;j<strlen(cv[i]);j++)
{
if((j+1)==(strlen(cv[i]))) cv[i][j]=sc;
else cv[i][j]=cv[i][j+1];
 }
}
for(i=0;i<k;i++)
{
if(strlen(cv[i])%2!=0)
{
for(j=strlen(cv[i])/2;j<strlen(cv[i]);j++)
{
cv[i][j]=cv[i][j+1];
if((j+1)==(strlen(cv[i]))) {cv[i][j]='\0'; break;}
}
}
}
for(i=0;i<k;i++)
{
//printf(" ");
for(j=0;j<strlen(cv[i]);j++)
printf("%c",cv[i][j]);
printf(" ");
}
getch();
}

Varianta 2. Listingul programului:

#include<conio.h>
#include<stdio.h>
#include<string.h>
#define NMAX 500
void main() {
char s[NMAX],cv[NMAX],cuv[NMAX][25],*p,c;
int ncuv=0,l,i,j;

printf("Introduceti şirul de caractere:\n");

gets(s);

// Extragerea cuvintelor din şir

p=strtok(s," ");
while(p) {
strcpy(cuv[ncuv++],p);
p=strtok(NULL," ");
}

// Stergerea punctului din ultimul cuvant

l=strlen(cuv[ncuv-1]);
if(cuv[ncuv-1][l-1]=='.') cuv[ncuv-1][l-1]='\0';

// a)
printf("\n a) Deplasarea primei litere la sfarsitul cuvintelor:\n");
for(i=0;i<ncuv;i++) {
strcpy(cv,cuv[i]);
l=strlen(cv);
c=cv[0];
for(j=0;j<l-1;j++)
 cv[j]=cv[j+1];
cv[l-1]=c;
printf("%s ",cv);
}
printf("\b.\n\n");

// b)
printf("b) Inlaturarea penultimei litere a cuvintelor:\n");
for(i=0;i<ncuv;i++) {
strcpy(cv,cuv[i]);
l=strlen(cv);
if(l>1) {
cv[l-2]=cv[l-1];
cv[l-1]='\0';
}
printf("%s ",cv);
}
printf("\b.\n\n");

// c)
printf("c) Inlaturarea literei din mijloc a cuvintelor de lungime impara:\n");
for(i=0;i<ncuv;i++) {
strcpy(cv,cuv[i]);
l=strlen(cv);
if(l%2) {
for(j=l/2;j<l-1;j++) cv[j]=cv[j+1];
cv[l-1]='\0';
}
printf("%s ",cv);
}
printf("\b.\n\n");

getch();
}