|
|
| Line 1: |
Line 1: |
| = Lectie =
| |
| = Sirurile de caractere =
| |
| *[http://algopedia.ro/wiki/index.php/Clasa_a_IX-a_lec%C8%9Bia_14 Recapitulare tipul char]
| |
|
| |
|
| '''Definitie:'''
| |
| Un sir de caractere este o structură de date formată dintr-o succesiune de caractere care se termină cu caracterul '''NULL''' (’ \0’).
| |
|
| |
| '''Implementare'''
| |
| Sirurile de caractere se reprezinta sub forma unui tablou unidimensional (vector) ale cărui elemente sunt de tip caracter, fiecare caracter fiind reprezentat prin codul său ASCII. Sirul de caractere se deosebeste de vectorii cu alte tipuri de elemente prin marcatorul logic utilizat la sfârsitul sirului - NULL (care are codul ASCII 0).
| |
|
| |
| '''Declarare'''
| |
|
| |
| <syntaxhighlight>
| |
| char x[5]; // am declarat sirul x care va putea contine maxim 5 caractere
| |
| cin >> x;
| |
| </syntaxhighlight>
| |
|
| |
| '''Initializare'''
| |
|
| |
| <syntaxhighlight>
| |
| char x[5] = "mama"; // am reervat explicit 5 octeti, pentru cele 4 caractere cat si pt caracterul null
| |
| char x[] = "mama"; // numarul de octeti rezervati este nr de caractere din constanta sir + 1
| |
| char x[20] = "mama";// am rezervat 20 de locatii din care am utilizat 5
| |
| </syntaxhighlight>
| |
|
| |
| Dimensiunea vectorului de caractere trebuie declarată cu un caracter mai mult decât cel mai mare sir de caractere pe care îl poate contine, pentru a exista loc si pentru terminatorul sirului (caracterul ‘\0’).
| |
| O constantă sir de caractere este o succesiune de caractere delimitată de ghilimele.
| |
| ex: char sir[256] = ”Buna ziua”;
| |
|
| |
| '''Citirea în limbajul C++'''
| |
| - se poate utiliza operatorul >> :
| |
| <syntaxhighlight>
| |
| cin >> s; ( doar dacă s este un cuvânt )</syntaxhighlight>
| |
| sau una din functiile get sau getline:
| |
| <syntaxhighlight>
| |
| char c, sir[201];
| |
| fin >> c;
| |
| fin.getline(sir, 200); //sau fin.get(sir,200);fin.get();
| |
| </syntaxhighlight>
| |
| Prototipurile functiilor get si getline:
| |
|
| |
| '''getline(char *s, int n, char c=’\n’);
| |
| get(char *s, int n, char c=’\n’);'''
| |
| Diferenta dintre functiile get si getline este faptul că functia getline preia din stream-ul de intrare si delimitatorul, în timp ce functia get nu-l extrage.
| |
| Scrierea în limbajul C++
| |
| <syntaxhighlight>
| |
| fout << c << ’ ’ << s;
| |
| </syntaxhighlight>
| |
| '''Obs.'''
| |
| 1. Citirea sirurilor de caractere la care se utilizează operatorul >> se opreste la întâlnirea primului caracter alb.
| |
| 2.Dacă delimitatorul este altul decât ‘\n’, acesta trebuie precizat pe pozitia corespunzătoarelui în functia getline.
| |
| ‘m’ ‘a’ ‘m’ ‘a’ ‘\0’
| |
|
| |
| Aplicatii
| |
|
| |
| 1. Se citeste de la tastatura un sir de caractere folosind functiile de citire studiate. Sa se afiseze acest sir.
| |
| a) Citire cu cin.get si afisare cu cout
| |
| b) Citire cu cin.getline si afisare cu cout
| |
| 2. Se citesc de la tastatura 2 siruri de caractere. Sa se afiseze aceste siruri fiecare pe cate o linie.
| |
| a) Citire cu cin.get si afisare cu cout
| |
| b) Citire cu cin.getline si afisare cu cout
| |
|
| |
| == Prelucrari secventiale de siruri de caractere ==
| |
| === [https://www.pbinfo.ro/?pagina=probleme&id=11 #11 Vocale] ===
| |
| Să se scrie un program care citeşte un şir de caractere format din litere mici ale alfabetului englez şi înlocuieşte fiecare vocală cu litera mare corespunzătoare.
| |
|
| |
|
| |
| {| class="wikitable"
| |
| |-
| |
| ! C prelucrare caracter cu caracter !! C++ prelucrare caracter cu caracter
| |
| |-
| |
| | <syntaxhighlight>
| |
| #include <stdio.h>
| |
| int e_vocala ( char c ) {
| |
| if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
| |
| return 1;
| |
| return 0;
| |
| }
| |
| int main() {
| |
| char c;
| |
| c = fgetc(stdin);
| |
| while( c != '\n' && c != EOF ) {
| |
| if(e_vocala(c))
| |
| fputc( c+'A'-'a', stdout);
| |
| else
| |
| fputc( c, stdout );
| |
| c = fgetc(stdin);
| |
| }
| |
| return 0;
| |
| }
| |
| </syntaxhighlight>
| |
| || <syntaxhighlight>
| |
| #include <iostream>
| |
| using namespace std;
| |
| int e_vocala ( char c ) {
| |
| if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
| |
| return 1;
| |
| return 0;
| |
| }
| |
| int main() {
| |
| char c;
| |
| cin.get(c);
| |
| while(c!='\n' && !cin.eof()) {
| |
| if(e_vocala(c))
| |
| cout<<(char)(c+'A'-'a');
| |
| else
| |
| cout<<c;
| |
| cin.get(c);
| |
| }
| |
| return 0;
| |
| }</syntaxhighlight>
| |
| |}
| |
|
| |
| {| class="wikitable"
| |
| |-
| |
| ! C !! C++
| |
| |-
| |
| | <syntaxhighlight>
| |
| // Citim un sir de caractere,
| |
| //il prelucram pe parcursul citirii si afisam caracterele rezultate
| |
| #include <iostream>
| |
| using namespace std;
| |
| int e_vocala ( char c ) {
| |
| if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
| |
| return 1;
| |
| return 0;
| |
| }
| |
| int main() {
| |
| char s[100]; // char *s;
| |
| cin >> s; // daca nu e era doar un cuvant : cin.get( s, 200 );
| |
| int i = 0;
| |
| while( s[i] ) {
| |
| if( e_vocala(s[i]) )
| |
| cout<<(char)( s[i]+'A'-'a');
| |
| else
| |
| cout << s[i];
| |
| i++;
| |
| }
| |
| return 0;
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| || <syntaxhighlight>
| |
| // Citim un sir de caractere,
| |
| //modificam elementele sirului si la final afisam sirul modificat
| |
| #include <iostream>
| |
| using namespace std;
| |
| int e_vocala ( char c ) {
| |
| if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
| |
| return 1;
| |
| return 0;
| |
| }
| |
| int main() {
| |
| char s[100]; // char *s;
| |
| cin >> s; // daca nu e era doar un cuvant : cin.get( s, 200 );
| |
| int i = 0;
| |
| while( s[i] ) { // s[i] != '\0' , nu am ajuns la sfarsitul sirului
| |
| if( e_vocala(s[i]) )
| |
| s[i] = s[i]+'A'-'a';
| |
| i++;
| |
| }
| |
| cout << s;
| |
| return 0;
| |
| }
| |
| </syntaxhighlight>
| |
| |}
| |
|
| |
| === [https://www.pbinfo.ro/?pagina=probleme&id=972 #972 Pozitii] ===
| |
| * Se da un sir de caractere. Sa se determine câte vocale din sir sunt cuprinse intre doua consoane.
| |
| <syntaxhighlight>
| |
| #include <iostream>
| |
| using namespace std;
| |
| char evoc ( char c ) {
| |
| if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
| |
| return 1;
| |
| return 0;
| |
| }
| |
|
| |
| char econs ( char c ) {
| |
| if ( c >= 'a' && c <= 'z' )
| |
| if ( !evoc(c))
| |
| return 1;
| |
| return 0;
| |
| }
| |
|
| |
| int main(){
| |
| char s[256];
| |
| int contor, i;
| |
| cin.get( s, 255 );
| |
| contor = 0; // cate vocale sunt intre 2 consoane
| |
| i = 1;
| |
| while( s[i+1] != '\0' ) {
| |
| if ( econs(s[i-1]) && econs(s[i+1]) && evoc(s[i]) )
| |
| contor ++;
| |
| i++;
| |
| }
| |
| cout << contor;
| |
| return 0;
| |
| }
| |
| </syntaxhighlight>
| |
|
| |
|
| |
| {| class="wikitable"
| |
| |-
| |
| ! C !! C++
| |
| |-
| |
| | <syntaxhighlight>
| |
| #include <stdio.h>
| |
|
| |
| char evoc ( char c ) {
| |
| if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
| |
| return 1;
| |
| return 0;
| |
| }
| |
| char econs ( char c ) {
| |
| if ( c >= 'a' && c <= 'z' )
| |
| if ( !evoc(c))
| |
| return 1;
| |
| return 0;
| |
| }
| |
| int main(){
| |
| char c1, c2, c3;
| |
| int contor, i;
| |
| c3 = getc(stdin);
| |
| contor = 0;
| |
| while( c3 != '\n' && c3 != EOF ){
| |
| i++;
| |
| if( i > 2 )
| |
| if ( econs(c1) && econs(c3) && evoc(c2) )
| |
| contor ++;
| |
| c1 = c2;
| |
| c2 = c3;
| |
| c3 = getc(stdin);
| |
| }
| |
| printf( "%d", contor );
| |
| return 0;
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| || <syntaxhighlight>
| |
| #include <iostream>
| |
| using namespace std;
| |
| char evoc ( char c ) {
| |
| if ( c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' )
| |
| return 1;
| |
| return 0;
| |
| }
| |
| char econs ( char c ) {
| |
| if ( c >= 'a' && c <= 'z' )
| |
| if ( !evoc(c))
| |
| return 1;
| |
| return 0;
| |
| }
| |
| int main(){
| |
| char c1, c2, c3;
| |
| int contor, i;
| |
| cin.get(c3);
| |
| contor = 0;
| |
| while( c3 != '\n' && c3 != EOF ){
| |
| i++;
| |
| if( i > 2 )
| |
| if ( econs(c1) && econs(c3) && evoc(c2) )
| |
| contor ++;
| |
| c1 = c2;
| |
| c2 = c3;
| |
| cin.get(c3);
| |
| }
| |
| cout << contor;
| |
| return 0;
| |
| }
| |
| </syntaxhighlight>
| |
| |}
| |
|
| |
| ===[https://www.pbinfo.ro/?pagina=probleme&id=12 #12 Initiale] ===
| |
| Să se scrie un program care citeşte de la tastatură o propoziţie formată din mai multe cuvinte separate prin spaţii şi transformă prima şi ultima literă a fiecărui cuvânt în literă mare.
| |
| {| class="wikitable"
| |
| |-
| |
| ! C - Folosind 3 variabile
| |
| !! C - Folosind 2 variabile
| |
| |-
| |
| | <syntaxhighlight>
| |
| #include <stdio.h>
| |
|
| |
| int main(){
| |
| int n, i;
| |
| char c1, c2, c3;
| |
| c1 = ' ';
| |
| c2 = fgetc( stdin );
| |
| c3 = fgetc( stdin );
| |
| while ( c3 != '\n' && c3 != EOF ) {
| |
| if ( c2 >= 'a' && c2 <= 'z' && (c1 == ' ' || c3 == ' ' ) ) // c2 e prima litera din cuv
| |
| c2 = c2 - 32;
| |
| fputc( c2, stdout );
| |
| c1 = c2;
| |
| c2 = c3;
| |
| c3 = fgetc( stdin );
| |
| }
| |
| if ( c2 >= 'a' && c2 <= 'z')
| |
| fputc( c2 - 32, stdout );
| |
| return 0;
| |
| }</syntaxhighlight>
| |
| || <syntaxhighlight>
| |
| #include <stdio.h>
| |
|
| |
| int main(){
| |
| int n, i;
| |
| char c1, c2;
| |
| c1 = fgetc( stdin );
| |
| if ( c1 >= 'a' && c1 <= 'z' ) // daca primul caracter e litera
| |
| c1 = c1 - 32;
| |
| c2 = fgetc( stdin );
| |
| while ( c2 != '\n' && c2 != EOF ) {
| |
| if ( c2 >= 'a' && c2 <= 'z' && c1 == ' ' ) // c2 e prima litera din cuv
| |
| c2 = c2 - 32;
| |
| if ( c1 >= 'a' && c1 <= 'z' && c2 == ' ' ) // c1 e sf de cuvant
| |
| c1 = c1 - 32;
| |
| fputc( c1, stdout );
| |
| c1 = c2;
| |
| c2 = fgetc( stdin );
| |
| }
| |
| if ( c1 >= 'a' && c1 <= 'z' )
| |
| c1 = c1 - 32;
| |
| fputc( c1, stdout );
| |
| return 0;
| |
| }</syntaxhighlight>
| |
| |}
| |
|
| |
| Putem de asemenea sa citim caracter cu caracter si sa formam cate un cuvand, modificam cuvantul si il afisam.
| |
| <syntaxhighlight>
| |
|
| |
| #include <iostream>
| |
| #include <string.h>
| |
| using namespace std;
| |
|
| |
| char* uppcuv( char *s, int lung ){
| |
| if( s[0] >= 'a' && s[0] <= 'z' )
| |
| s[0] = s[0] - 'a' + 'A';
| |
| if( s[lung-1] >= 'a' && s[lung-1] <= 'z' )
| |
| s[lung-1] = s[lung-1] - 'a' + 'A';
| |
| return s;
| |
| }
| |
|
| |
| int main(){
| |
| char c;
| |
| char cuv[200];
| |
| int incuv, lung;
| |
| cin.get( c );
| |
| incuv = 0; lung = 0;
| |
| while( c != '\n' && !cin.eof() ){
| |
| if( c != ' ' ) // daca am litera
| |
| if( incuv == 1){ // si sunt cuvant
| |
| cuv[lung++] = c; // adaug litera la cuvant
| |
| }
| |
| else{ // am litera si inainte a fost spatiu
| |
| incuv = 1; // declar ca sunt in cuvant
| |
| lung = 0; // rezetez contorul de litere din cuvant
| |
| cuv[lung++] = c; // pun prima litera in cuvant
| |
| }
| |
| else { // daca am spatiu
| |
| if( incuv == 1){ // si inainte era cuvant
| |
| cuv[lung] = 0;
| |
| cout << uppcuv(cuv,lung); // tiparesc cuvantul modificat
| |
| incuv = 0;
| |
| }
| |
| cout<<c;
| |
| }
| |
| cin.get( c ); // citesc un nou caracter
| |
| }
| |
| if (incuv ){
| |
| cuv[lung] = 0;
| |
| cout << uppcuv(cuv,lung);
| |
| }
| |
|
| |
| return 0;
| |
| }
| |
| </syntaxhighlight>
| |
|
| |
| ==LungSortDesc ==
| |
| Se dă un șir de caractere în care cuvintele sunt formate din litere mici și mari ale alfabetului englez și sunt separate prin spații.
| |
| Să se afișeze cuvintele pe ecran, fiecare cuvânt pe câte o linie, în ordinea descrescătoare a numărului de litere. Dacă două cuvinte au același număr de litere atunci ele se vor afișa în ordine lexicografică.
| |
|
| |
| == Tema ==
| |
| === [https://www.pbinfo.ro/probleme/1866/prosir prosir] ===
| |
| Să se înlocuiasca cu cifra 5 ultima literă a fiecărui cuvânt din textul conținut de fișierul prosir.in.
| |
|
| |
| === #1456Cuvant ===
| |
| 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 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.
| |
|
| |
| === #890 NrVocale ===
| |
| Se dă o propoziție formată din litere mari și mici ale alfabetului englez, cifre, spații și semne de punctuație, în care literele mari și mici se consideră identice. Determinați vocala din șir cu număr maxim de apariții.
| |
|
| |
| === #13 Prefixe ===
| |
| Să se scrie un program care să afişeze prefixele şi sufixele unui cuvânt citit.
| |
|
| |
| Avand in vedere ca vom avea nevoie sa memoram sirul de caractere, putem sa citim tot sirul utilizand o functie de citire sir.
| |
| <syntaxhighlight>
| |
|
| |
| === #84 InterschimbareLitere ===
| |
| Să se scrie un program care citește un cuvânt și îl afișează după interschimbarea primei vocale cu ultima consoană.
| |
|
| |
| === #85 InserareAsterisc ===
| |
| Să se scrie un program care citește un text și inserează după fiecare vocală caracterul *.
| |
| <syntaxhighlight></syntaxhighlight>
| |
