1.

Se consideră un text cu cel mult 100 de caractere (litere mici ale

alfabetului englez şi spaţii), în care cuvintele sunt separate prin unul sau
mai multe spaţii. Înaintea primului cuvânt şi după ultimul cuvânt nu există
spaţiu. Scrieţi un program C/C++ care citeşte de la tastatură un text de
tipul menţionat mai sus şi determină transformarea acestuia în memorie prin
eliminarea unor spaţii, astfel încât între oricare două cuvinte alăturate să
rămână exact un spaţiu. Programul afişează pe ecran textul obţinut.

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[200],i;
cin.get(s,200);
for(i=1; i<strlen(s); i++)
if(s[i]==' ' && s[i-1]==' ')
{
strcpy(s+i, s+i+1);
i--;
}
cout<<s;
return 0;
}
========================================================================
=======
2.Se consideră un text cu cel mult 100 de caractere, format din cuvinte si
numere, separate prin unul sau mai multe spații. Cuvintele sunt formate
numai din litere ale alfabetului englez. Toate numerele sunt reale, pozitive
si sunt formate numai din parte întreagă sau din parte întreagă si parte
fracționară, separate prin punctul zecimal (.).
Scrieți un program C/C++ care citeste de la tastatură textul, pe care îl
transformă, eliminând din componența sa toate numerele care au parte
fracționară. Programul afisează apoi pe ecran textul obținut.

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[102],cuv[]=" ",snou[102]="";
cin.get(s,102);
char *p=strtok(s," ");
while(p)
{
if(!strchr(p,'.'))
{
strcat(snou,p);
strcat(snou," ");
}
p=strtok(NULL," ");
}
cout<<snou;
return 0;
}
======================================================================
3.Se consideră un text cu cel mult 100 de caractere (litere mici ale
alfabetului englez si spații), în care cuvintele sunt separate prin unul sau
mai multe spații. Scrieți un program C/C++ care citeste de la tastatură un
text de tipul menționat mai sus si determină transformarea acestuia în
memorie prin eliminarea unor vocale, astfel încât în niciun cuvânt din text
să nu existe două vocale pe poziții alăturate. Programul afisează pe ecran
textul obținut. Se consideră vocale literele a, e, i, o, u.

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[200],voc[]="aeiou";
int i;
cin.get(s,200);
for(i=1; s[i]; i++)
if(strchr(voc, s[i]) && strchr(voc,s[i-1]))
{
strcpy(s+i, s+i+1);
i--;
}
cout<<s<<endl;
return 0;
}
========================================================================
===========
4.Se consideră un text cu cel mult 100 de caractere (litere mici ale
alfabetului englez şi spaţii), care conţine cel puţin o vocală.
Scrieţi un program C/C++ care citeşte de la tastatură un text de tipul
menţionat mai sus şi determină transformarea acestuia în memorie prin
duplicarea tuturor vocalelor din text, ca în exemplu. Programul afişează pe
ecran textul obţinut. Se consideră vocale literele a, e, i, o, u.

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[200],voc[ ]="aeiou";
int i;
cin.get(s,200);
for(i=0; i<strlen(s); i++)
if(strchr(voc, s[i]))
cout<<s[i]<<s[i];
else
cout<<s[i];
return 0;
}
========================================================================
========
5.Două fraze se numesc anagrame dacă literele lor sunt identice, dispuse
eventual în altă ordine.
Scrieţi un program C/C++ care citeşte de la tastatură două fraze, separate
prin Enter, fiecare fiind formată din cel mult 100 de caractere. Cuvintele
din fiecare frază conțin numai litere mici ale alfabetului englez și sunt
separate prin câte un spațiu. Programul afişează pe ecran mesajul DA, dacă
cele două fraze sunt anagrame, sau mesajul NU, în caz contrar.

#include <bits/stdc++.h>

using namespace std;

char a[101], b[101];
int ok, i, frecv[27];

int main()
{
cin.getline(a, 100);
cin.getline(b, 100);
for (i = 0; i < strlen(a); i++)
{
if (a[i] != ' ')
frecv[int (a[i]) - int ('a')]++;
}
for (i = 0; i < strlen(b); i++)
{
if (b[i] != ' ')
frecv[int (b[i]) - int ('a')]--;
}
for (i = 0; i <= 25; i++)
{
if (frecv[i] != 0)
ok++;
}
if (ok == 0)
cout << "DA";
else
cout << "NU";

return 0;
}
========================================================================
=====
7.Se consideră un cuvânt format din cel puțin două și cel mult 100 de
caractere, numai litere mici ale alfabetului englez.
Scrieţi un program C/C++ care citeşte de la tastatură un cuvânt de tipul
precizat și afișează pe ecran mesajul DA în cazul în care cuvântul conține
doar consoane şi, eventual, vocala i, sau mesajul NU în caz contrar.

#include <bits/stdc++.h>
using namespace std;

int main()
{
char s[100];
 cin>>s;
int i,ok=1,k=0;
for(i=0;i<strlen(s);i++)
{
if(s[i]=='i')
k++;
if(strchr("aeou",s[i]))
{
ok=0;
break;
}
}
if(ok && k!=strlen(s))
cout<<"DA";
else
cout<<"NU";

return 0;
}

========================================================================
8.Se consideră un text cu cel mult 100 de caractere, în care cuvintele sunt
formate numai din litere mari și mici ale alfabetului englez și sunt
separate prin câte un spațiu. Textul reprezintă numele unei instituţii sau
al unei organizaţii. Scrieţi un program C/C++ care citeşte de la tastatură
un text de tipul precizat şi construieşte în memorie, apoi afişează pe
ecran, un şir de caractere ce reprezintă acronimul corespunzător numelui
citit. Acronimul este format din primul caracter al fiecărui cuvânt al
numelui care începe cu majusculă.

#include <bits/stdc++.h>
using namespace std;

int main()
{
char s[1001];
cin.getline(s , 1001);
int i = 1;
if(s[0]>= 'A' && s[0]<='Z')
cout << s[0];
while(s[i]!='\0')
 {
if(s[i-1]==' ' && s[i]>= 'A' && s[i]<='Z')
cout << s[i];
i++;
}
return 0;
}
============================================================
9.Se consideră un cuvânt format din cel puțin două și cel mult 100 de
caractere, numai litere mici ale alfabetului englez. Scrieți un program
C/C++ care citeste de la tastatură un cuvânt de tipul precizat și îl
transformă în memorie, eliminând un număr minim de litere, astfel încât el
să conțină doar vocale si, eventual, consoana m. Programul afișează pe ecran
cuvântul obținut, sau mesajul nu exista dacă nu se poate obține un astfel de
cuvânt.
Exemplu: pentru cuvintele amnistie, amintire sau amiie se afișează amiie
pentru cuvântul ploaie se afisează oaie
iar pentru cuvântul mrrr se afisează mesajul nu exista

#include <iostream>
#include <string.h>
using namespace std;

int main()
{
char s[100];
cin>>s;
int i,ok=1,k=0;
for(i=0;i<strlen(s);i++)
{
if(strchr("aeiou",s[i]))
ok=1;
else
if(s[i]=='m')
k++;
else
{
strcpy(s+i, s+i+1);
i--;
}
}
 if(ok && k!=strlen(s))
cout<<s;
else
cout<<"nu exista";
return 0;
}
========================================================================
11.Scrieţi un program C/C++ care citeşte de la tastatură două cuvinte
distincte, fiecare fiind format din cel mult 30 de caractere, numai litere
mici ale alfabetului englez. După primul cuvânt se tastează Enter. Programul
verifică dacă prin eliminarea unor litere din cel de al doilea cuvânt se
poate obţine primul cuvânt. În caz afirmativ programul afişează pe ecran
mesajul DA, altfel mesajul NU.
Exemple: dacă se citesc, în această ordine, cuvintele:
calut
bacalaureat
pe ecran se afişează mesajul DA
iar dacă se citesc, în această ordine, cuvintele:
calut
lacatus
pe ecran se afişează mesajul NU.

#include <bits/stdc++.h>

using namespace std;

int main()
{int i,nr=0;
char *p,c1[30],c2[30];
cin>>c1;
cin>>c2;
for(i=0; c1[i];i++)
{
p=strchr(c2,c1[i]);
if(p)
{
strcpy(c2,p+1);
nr++;
}}
if(nr==strlen(c1))
cout<<"DA";
else cout<<"NU";
 return 0;
}

=================================================

12.Scrieţi un program C/C++ care citeşte de la tastatură două şiruri, fiecare fiind format din cel
mult 30 de caractere. După primul şir se tastează Enter. Primul şir este format numai din litere
mici ale alfabetului englez, iar cel de-al doilea şir este format numai din litere mici ale alfabetului
englez şi caractere *. Programul verifică dacă, înlocuind în cel de-al doilea şir toate caracterele *
cu litere mici, şirul obţinut este un subşir al primului şir. În caz afirmativ, programul afişează pe
ecran şirul obţinut, altfel afişează mesajul imposibil. Dacă se pot obţine mai multe astfel de
şiruri, se afişează doar unul dintre ele. Exemplu: dacă se citesc, în ordine, şirurile: albastrui
a**r* atunci pe ecran se afişează astru

#include <bits/stdc++.h>
using namespace std;

int main() {
char s1[101],s2[101];
int i,j,k,ok=0;
cin>>s1;
cin>>s2;
if(strlen(s1)<strlen(s2))
cout<<"imposibil";
else
for(i=0; i<strlen(s1) && ok!=1; i++)
{
for(j=0; j<strlen(s2); j++)
if(s1[i+j]!=s2[j] && s2[j]!='*')
break;
if(j==strlen(s2))
{
ok=1;
for(k=0; k<j; k++)
cout<<s1[i+k];
}
}
if(ok==0)
cout<<"imposibil";
return 0;
}

======================================
13.Scrieți un program C/C++ care citeste de la tastatură un număr natural n (2≤n≤20) si apoi n cuvinte
distincte, fiecare fiind format din cel mult 20 de caractere, numai litere mici ale alfabetului englez. La
introducerea datelor, după fiecare cuvânt se tastează Enter. Programul afisează pe ecran numărul de
cuvinte dintre ultimele n-1 citite, care încep cu primul cuvânt citit. Exemplu: dacă n=5 si cuvintele citite
sunt: bun buncar bunici abundent bunavoie pe ecran se afisează 3 (deoarece numai cuvintele buncar,
bunici si bunavoie încep cu bun).

#include <bits/stdc++.h>
using namespace std;

int main() {
char c1[101],cuv[101],*p;
int n,i,nr=0;
cin>>n;
cin>>c1;
for(i=2; i<=n; i++)
{
cin>>cuv;
p=strstr(cuv,c1);
if(strcmp(p,cuv)==0)
nr++;
}
cout<<nr;

return 0;
}

=====================================================================================

14.Se consideră două şiruri de caractere a, de lungime na şi b, de lungime nb. Şirul a este numit prefix al
şirului b dacă na≤nb şi subşirul lui b determinat de primele sale na caractere coincide cu a. Şirul a este
numit sufix al şirului b dacă na≤nb şi subşirul lui b determinat de ultimele sale na caractere coincide cu a.
Scrieţi un program C/C++ care citeşte de la tastatură două cuvinte, fiecare fiind format din cel mult 30 de
caractere, numai litere mici ale alfabetului englez. După primul cuvânt se tastează Enter. Programul
afişează pe ecran, separate prin câte un spaţiu, toate sufixele primului cuvânt care sunt prefixe ale celui
de al doilea cuvânt, ca în exemplu. Dacă nu există astfel de subşiruri, se afişează pe ecran mesajul NU
EXISTA. Exemple: dacă se citesc, în ordine, cuvintele rebele elegant se afişează (nu neapărat în această
ordine) subşirurile: e ele iar dacă se citesc, în ordine, cuvintele strai rai se afişează subşirul rai

#include <bits/stdc++.h>

using namespace std;

int main()
{

char s1[30],s2[30],*p;
 int i;
cin>>s1;
cin>>s2;
i=strlen(s1)-1;
while(i>=0)
{
p=strstr(s2,s1+i);
if(strcmp(p,s2)==0)
cout<<s1+i<<" ";
i--;
}
return 0;
}

===============================================================

15.Scrieți un program C/C++ care citeste de la tastatură un număr natural n (2≤n≤20) si apoi n cuvinte
distincte, fiecare fiind format din cel mult 20 de caractere, numai litere mici ale alfabetului englez. La
introducerea datelor, după fiecare cuvânt se tastează Enter. Programul afisează pe ecran numărul de
cuvinte dintre ultimele n-1 citite, care se încheie cu primul cuvânt citit. Exemplu: dacă n=5 si cuvintele
citite sunt: oare soarele stropitoare oarecare cicoare pe ecran se afisează 2 (deoarece cuvintele
stropitoare si cicoare se încheie cu oare).

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s1[101], s2[101], *p, s[101];
int n, i, nr=0;
cin>>n;
cin>>s1;
for(i=2; i<=n; i++)
{
cin>>s2;
p=strstr(s2, s1);
while(p)
{
strcpy(s,p);
p=strstr(p+1, s1);
}
if(strlen(s)==strlen(s1))
nr++;
}
cout<<nr;
return 0;
}
================================================================

16.Se consideră un text cu cel mult 100 de caractere (litere mici ale alfabetului englez si spații), în care
cuvintele sunt separate prin câte un spațiu. Înaintea primului cuvânt si după ultimul cuvânt nu există
spații. Scrieți un program C/C++ care citeste de la tastatură un text de tipul menționat mai sus si
determină transformarea acestuia în memorie prin înlocuirea fiecărui cuvânt format din trei litere cu
simbolul *. Programul afisează pe ecran textul obținut. Exemplu: pentru textul bun este izvorul ce are apa
rece se afisează * este izvorul ce * * rece

#include <bits/stdc++.h>

using namespace std;

int main() {

char s[101],*p;
cin.getline(s,101);
p=strtok(s," ");
while(p)
{
if(strlen(p)==3)
cout<<'*'<<" ";
else
cout<<p<<" ";
p=strtok(NULL," ");

return 0;
}
================================================================

19.O pereche de cuvinte, unul cu număr par de litere, iar celălalt cu număr
impar de litere, se numește descentrată dacă se poate obține cuvântul cu
număr par de litere din celălalt, prin duplicarea caracterului din mijlocul
acestuia. Exemplu: perechile crezi și creezi, respectiv a și aa sunt
descentrate.
Un text are cel mult 100 de caractere, iar cuvintele sale sunt formate din
litere mici ale alfabetului englez şi sunt separate prin câte un spațiu.
Scrieţi un program C/C++ care citeşte de la tastatură un text de tipul
precizat mai sus şi afișează pe ecran mesajul DA, dacă acesta conține cel
puțin o pereche descentrată, sau mesajul NU în caz contrar.
Exemplu: dacă textul citit este crezi ca poti sa creezi ceva original
se afișează pe ecran mesajul DA
#include <bits/stdc++.h>

using namespace std;

int main()
{
//dublare o litera
char s[50],*p;
int n;
cin>>s;
n=strlen(s);
strcpy(s+n/2+1, s+n/2);
cout<<s;
return 0;
}

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[102],snou[102],*p;
int gasit=0, n;
cin.getline(s, 102);
strcpy(snou,s);
p=strtok(snou," ");
while(p && !gasit)
{
n=strlen(p);
if(n%2==1)
{
strcpy(p+n/2+1, p+n/2);
if(strstr(s,p))
gasit=1;
}
p=strtok(NULL, " ");
}
if(gasit==1)
cout<<"DA";
else
cout<<"NU";
return 0;
}
=====================================================================================

20.Fiind dat un cuvânt s, format numai din litere, și un cod c, de aceeași

lungime cu s, format numai din cifre, numim codificare a lui s pe baza
codului c operația de construire a unui nou șir, în care inițial se copiază
prima literă din s, apoi, parcurgând de la stânga la dreapta restul șirului
s, se adaugă litera curentă la începutul noului șir, dacă cifra
corespunzătoare de pe aceeași poziție în c este pară, sau la finalul noului
șir, în caz contrar.
Exemplu: dacă șirul s este etalon, iar codul este 025843 se obține cuvântul

oltean (inițial șirul conține litera e, apoi se adaugă, în ordinea

parcurgerii lui s, literele t, l și o la început, iar restul literelor la
final). Scrieţi un program C/C++ care citeşte de la tastatură două cuvinte,
notate cu s și c, fiecare având cel mult 102 caractere, s fiind format doar
din litere mici ale alfabetului englez, iar c fiind format doar din cifre.
După primul cuvânt se tastează Enter. Programul construiește în memorie și
afișează pe ecran cuvântul obținut prin codificarea lui s pe baza lui c,
dacă cele două cuvinte au aceeași lungime, sau mesajul cod incorect, în caz
contrar.
Exemplu: dacă se citesc cuvintele alăturate, se afişează pe ecran cuvântul
Oltean
etalon
025843

#include <bits/stdc++.h>

using namespace std;

int main()
{
char n[102],cod[102],sirc[102];
cin>>n>>cod;
if(strlen(n)!=strlen(cod))
cout<<"COD INCORECT";
else
{
sirc[0]=n[0];
sirc[1]='\0';
for(int i=1; i<strlen(n); i++)
if(cod[i]%2==0)
{
 char aux[102];
strcpy(aux,sirc);
sirc[0]=n[i];
strcpy(sirc+1,aux);
}
else
{
sirc[strlen(sirc)]=n[i];
sirc[strlen(sirc)+1]='\0';
}
cout<<sirc;

}
return 0;
}

===

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[101],c[101],s1[101],s2[101];
int i,p=0,q=0;
cin>>s>>c;
if(strlen(s)!=strlen(c))
cout<<"cod incorect";
else
{
s1[p++]=s[0];
for(i= 1; i<strlen(s); i++)
if(c[i]%2==0)
s1[p++]=s[i];
else
s2[q++]=s[i];
s1[p]='\0';
s2[q]='\0';
strrev(s1);
strcat(s1,s2);
cout<<s1;
}
return 0;
}

=====================================================================================
21.Un text are cel mult 100 de caractere și este format din cuvinte, numere
naturale şi spaţii. Cuvintele sunt formate numai din litere mici ale
alfabetului englez. Cuvintele şi numerele sunt separate prin câte un spaţiu,
ca în exemplu. Scrieţi un program C/C++ care citeşte de la tastatură un text
de tipul menţionat mai sus şi afişează pe ecran numărul din text care începe
cu cea mai mare cifră, ca în exemplu. Dacă există mai multe astfel de
numere, se afișează doar unul dintre acestea, iar dacă textul nu conține
niciun număr, se afișează pe ecran mesajul nu exista.
Exemplu: pentru textul am 190 de nuci si 70 de castane
se afişează 70

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[101], *p, nr[20]="";
int gasit=0;
cin.getline(s,101);
p=strtok(s," ");
while(p)
{
if(p[0]>='0' && p[0]<='9')
if(strcmp(p,nr)>0)
{
gasit=1;
strcpy(nr,p);
}
p=strtok(NULL," ");
}
if(gasit==0)
cout<<"Nu exista";
else
cout<<nr;
return 0;
}

=====================================================================================
22.Într-un text cu cel mult 100 de caractere, cuvintele sunt formate numai din
litere mici ale alfabetului englez și sunt separate prin unul sau mai multe
spații.
Scrieți un program C/C++ care citește de la tastatură un astfel de text, cu
cel puțin trei cuvinte, și construiește în memorie un șir de caractere
format din prima consoană a primului cuvânt, urmată de prima vocală a celui
de al doilea cuvânt, respectiv de ultima literă a ultimului cuvânt, în
ordinea în care acestea apar în text. Șirul obținut se afișează pe ecran,
iar dacă nu se poate obține un astfel de
șir, se afișează pe ecran mesajul nu exista. Se consideră vocale literele a,
e, i, o, u.
Exemplu: pentru textul el prefera sa mearga la schi
se afișează pe ecran șirul lei
iar pentru textul ei prefera sa mearga la schi
se afișează pe ecran mesajul nu exista

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[101],voc[]="aeiou",*p, snou[4];
int i;
cin.getline(s,101);
snou[2]=s[strlen(s)-1];
p=strtok(s," ");
i=0;
while(i<strlen(p) && strchr(voc,p[i]))
i++;
if(i<strlen(p))
{
snou[0]=p[i];
p=strtok(NULL, " ");
i=0;
while(i<strlen(p) && !strchr(voc,p[i]))
i++;
if(i<strlen(p))
{
snou[1]=p[i];
snou[3]='\0';
cout<<snou;
}
else
cout<<"NU EXISTA";
}
else
cout<<"NU EXISTA";

return 0;
}

=============================================================================
23.Să se scrie un program C/C++ care citeşte de la tastatură un cuvânt format
din cel mult 20 de caractere, doar litere mici ale alfabetului englez.
Programul determină transformarea cuvântului citit prin înlocuirea fiecărei
vocale a cuvântului, cu un şir format din două caractere şi anume vocala
respectivă urmată de litera mare corespunzătoare, restul literelor
nemodificându-se, ca în exemplu. Programul afişează pe ecran cuvântul
obţinut, pe o singură linie. Se consideră vocale literele din mulţimea
{a,e,i,o,u}.
Exemplu: pentru cuvântul bacalaureat se va afişa pe ecran: baAcaAlaAuUreEaAt

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[101],voc[]="aeiou";
int i;
cin.getline(s,101);
for(i=0; i<=strlen(s)-1; i++)
{
cout<<s[i];
if(strchr(voc,s[i]))
cout<<char (toupper(s[i]));
}
return 0;
}

24.Se consideră un text cu maximum 255 de caractere în care cuvintele sunt

separate prin unul sau mai multe spaţii. Primul caracter din textul citit
este o literă, iar cuvintele sunt formate numai din litere mici ale
alfabetului englez. Scrieţi un program C/C++ care citeşte de la tastatură
textul şi îl transformă, înlocuind prima literă a fiecărui cuvânt cu litera
mare corespunzătoare, restul caracterelor rămânând nemodificate. Textul
astfel transformat va fi afişat pe ecran.
Exemplu: dacă de la tastatură se introduce textul: mare frig rosu se va
afişa pe ecran: Mare Frig Rosu

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[101];
int i;
cin.getline(s,101);
s[0]=s[0]-32;
 for(i=1; i<=strlen(s); i++)

if(s[i-1]==' ')
s[i]=s[i]-32;
cout<<s;
return 0;
}

===================================================================
25.Se consideră un text cu maximum 255 de caractere, format din litere mici ale
alfabetului englez şi spaţii. Textul conţine cel puţin o consoană. Scrieţi
un program C/C++ care citeşte de la tastatură textul şi apoi determină
transformarea acestuia, eliminând numai ultima consoană care apare în text,
ca în exemplu. Programul va afişa pe ecran textul obţinut.

Exemplu: dacă de la tastatură se introduce textul: mare frig saci pe ecran

se va afişa: mare frig sai

#include <bits/stdc++.h>
using namespace std;

int main()
{
int i,ok=0;
char s[260];
cin.getline(s, 260);
for(i=strlen(s)-1; i>=0; i--)
if(strchr("aeiou",s[i])==NULL && s[i]!=' ')
{
strcpy(s+i, s+i+1);
break;
}
cout<<s;
return 0;
}

==================================================================

26.Se consideră un text alcătuit din cel mult 250 de caractere, în care
cuvintele sunt formate doar din litere mici ale alfabetului englez şi sunt
separate prin unul sau mai multe caractere *. Scrieţi un program C/C++ care
citeşte de la tastatură textul şi afişează pe ecran, pe câte o linie, toate
secvenţele formate din câte două litere identice, ca în exemplu.
Exemplu: dacă textul citit este: se afişează perechile
următoare
ii ii oo
#include <bits/stdc++.h>

using namespace std;

int main()
{
char s[101];
int i;
cin.getline(s,101);
for(i=0; i<strlen(s)-1; i++)
if(s[i]==s[i+1] && s[i]!='*')
cout<<s[i]<<s[i]<<endl;

return 0;
}
==============================================================
27.Scrieţi un program C/C++ care citeşte de la tastatură două şiruri de
caractere formate din maximum 100 litere mici ale alfabetului englez şi
afişează pe ecran cel mai lung sufix comun al celor două şiruri de
caractere. Dacă cele două şiruri nu au niciun sufix comun, atunci programul
va afişa pe ecran mesajul NU EXISTĂ.
Exemplu: pentru şirurile marina şi elena se va afişa na

#include <bits/stdc++.h>

using namespace std;

int main()
{
char s1[101], s2[101];
int n,m;
cin>>s1;
cin>>s2;
n=strlen(s1)-1;
m=strlen(s2)-1;
while(s1[n]==s2[m] && n>=0 && m>=0)
{
n--;
m--;
}
cout<<s1+n+1;

return 0;
}
=================================================================

28.Şirul de caractere s2 este “clona” şirului de caractere s1 dacă se poate

obţine din s1 prin eliminarea tuturor apariţiilor unei singure vocale. Se
consideră vocală orice literă din mulţimea {a,e,i,o,u}. Scrieţi programul
C/C++ care citeşte de la tastatură un cuvânt format din cel mult 20 litere
mici ale alfabetului englez şi afişează pe ecran (dacă există), toate
“clonele” acestui cuvânt, fiecare pe câte o linie a ecranului.
Exemplu: pentru cuvântul informatica se afişează, nu neapărat în această
ordine, “clonele” scrise alăturat.
nformatca
infrmatica
informtic

#include <bits/stdc++.h>

using namespace std;

int main()
{
char c[102], cop[102], voc[]="aeiou";
int i,j;
cin>>c;
for(i=0; i<5; i++)
{
int ok=0;
strcpy(cop, c);
for(j=0; j<strlen(c); j++)
if(cop[j]==voc[i])
{
ok=1;
strcpy(cop+j, cop+j+1);
}
if(ok==1)
cout<<cop<<endl;
}

return 0;
}

=================================================================================

29.Scrieţi un program C/C++ care citeşte de la tastatură două caractere c1 şi

c2 (litere distincte ale alfabetului englez), şi un text având cel mult 250
caractere (doar spaţii şi litere ale alfabetului englez), pe care îl
modifică înlocuind toate apariţiile caracterului memorat în c1 cu cel
memorat în c2 şi toate apariţiile caracterului memorat în c2 cu cel memorat
în c1.
Programul afişează pe linii separate ale ecranului atât textul iniţial cât
şi textul obţinut după efectuarea înlocuirilor.
Exemplu: dacă pentru c1 se citeşte a, pentru c2 se citeşte o iar textul
citit este: hocus pocus preparatus se va afişa :
hocus pocus preparatus
hacus pacus preporotus

#include <bits/stdc++.h>

using namespace std;

int main()
{
char c1,c2,n[101];
cin>>c1>>c2;
cin.get();
cin.getline(n, sizeof(n));
for(int i=0; i<strlen(n); i++)
if(n[i]==c1)
n[i]=c2;
else
if(n[i]==c2)
n[i]=c1;
cout<<n;

return 0;
}

=====================================

31.Un şir cu maximum 255 de caractere conţine cuvinte separate prin câte un
spaţiu. Cuvintele sunt formate numai din litere mici ale alfabetului englez.
Scrieţi un program C/C++ care citeşte de la tastatură un astfel de şir şi îl
afişează pe ecran modificat, inversând prin oglindire doar cuvintele care
încep cu vocală, ca în exemplu. Se consideră ca fiind vocale următoarele
litere: a, e, i, o, u.
Exemplu: pentru şirul: maine este proba la informatica se va afişa:
maine etse proba la acitamrofni

#include <bits/stdc++.h>
using namespace std;

int main()
{
char s[101], snou[101]="",*p,voc[]="aeiou";
int i;
cin.getline(s,101);
p=strtok(p, " ");
while(p)
{
if(strchr(voc,p[0]))
strrev(p);
strcat(snou,p);
strcat(snou," ");
p=strtok(NULL," ");
cout<<snou;
}

return 0;
}