Info e drogul meu

Siruri de Caractere

codurile ASCII ale literelor mari (sau mici) sunt în ordine: 'A' are codul 65, 'B' are
codul 66, .. , 'Z' are codul 90. Două caractere consecutive în alfabet au coduri ASCII
consecutive! De asemenea, litera 'a' are codul 97, etc.
codurile ASCII ale literelor mici sunt mai mari decât codurile ASCII ale literelor
mari ('a' > 'Z') și diferență între codurile ASCII a două litere (mică – mare) este 32.
cifrele au coduri consecutive: caracterul '0' are codul 48, caracterul '1' are codul
49, etc. *Observăm că caracterul '0' nu are codul ASCII 0, ci 48.
caracterul spațiu este un caracter imprimabil. Spațiul are codul ASCII 32

cin >> s;

În acest mod, datorită specificului operatorului >> nu se pot citi șiruri care conțin spații – se
vor citi caracterele până la primul spațiu, fără acesta.

istream& getline (char* s, streamsize n );

Am putea spune că getline si get citesc toată linia.

std::size_t strlen( const char* str );

Returnează lungimea șirului str, adică numărul de caractere din șirul al cărui prim caracter
se află la adresa memorată în str. Caracterul nul nu se numără.

char *strncpy( char *dest, const char *src, std::size_t count );

Copiază cel mult count caractere din șirul aflat la adresa src, în șirul al cărui prim element
se află la adresa din dest.

char s[100]="abcdefghjkl";
strncpy(s, "poveste", 3);
cout << s; // povdefghjkl
Pointeri

#include <iostream>

using namespace std;

int main(){
char * p , s[]="pbinfo";
cout << s << endl; // pbinfo
p = s;
cout << p << endl; // pbinfo
p ++;
cout << p << endl; // binfo
return 0;
}

char *strchr( char * str, char ch );

Caută caracterul ch în șirul al cărui prim caracter se află în memorie la adresa din str.
Funcția returnează adresa NULL, dacă caracterul ch nu apare în șirul str, respectiva adresa
primei apariții al lui ch în str, dacă ch apare în str.

char s[21]="pbinfo";
char * p = strchr(s , 'i');
cout << p; // info

char *strstr( char * s, char * t );

Caută șirul t în șirul al cărui prim caracter se află în memorie la adresa din s. Funcția
returnează adresa NULL, dacă șirul t nu apare în șirul s, respectiva adresa primei apariții al
lui t în s, dacă t apare în s.

char s[21]="pbinfo";
char * p = strstr(s , "inf");
cout << p; // info
int strcmp( char * s, char * t );

Compară lexicografic cele două șiruri de caractere:

 dacă șirul s este lexicografi mai mic decât t funcția va returna o valoare negativă

 dacă șirul s este lexicografi mai mare decât t funcția va returna o valoare pozitivă
 dacă cele două șiruri sunt identice funcția va returna valoarea 0

Standardul C/C++ stabilește doar semnul rezultatului, nu și valoarea acestuia. Valorile

returnate pot fi, dar nu trebuie să fie, -1 0 1.

char s[21]="abur", t[21]="abecedar";

if(strcmp(s , t) < 0)
cout << "Da"
else
cout << "Nu";
// se va afisa Nu; cuvantul "abur" este lexicografic dupa "abecedar"

char *strtok( char *str, const char *sep );

char sep[]=" .,";

char * p = strtok(s , sep);
while(p != NULL)
{
cout << p << endl;
p = strtok(NULL , sep);
}
char s[256], t[256];
int x;
// ...
//eliminarea
strcpy(t , s + x + 1);
strcpy(s + x , t);

char s[256], t[256];

int x;
// ...
//inserarea
strcpy(t , s + x);
strcpy(s + x + 1 , t);
s[x] = 'A'; // echivalent, *(s+x) = 'A';
 Sortare

Sortarea prin selecție (Selection Sort) se bazează pe următoarea idee:

 fie un vector X[] cu n elemente;
 plasăm în X[0] cea mai mică valoare din vector;
 plasăm în X[1] cea mai mică valoare rămasă;
 etc.

O descriere a algoritmului este:

 parcurgem vectorul cu indicele i

o parcurgem cu indicele j elementele din dreapta lui X[i]

dacă elementele X[i] și X[j] nu sunt în ordinea dorită, le interschimbămint n, X[100];

//citire X[] cu n elemente
for(int i = 0 ; i < n - 1 ; i ++)
for(int j = i + 1 ; j < n ; j ++)
if(X[i] > X[j])
{
int aux = X[i];
X[i] = X[j];
X[j] = aux;
}
Sortarea prin bule

Cunoscută și sub numele BubbleSort, metoda bulelor se bazează pe următoare idee:

 fie un vector X[] cu n elemente
 parcurgem vectorul și pentru oricare două elemente învecinate care nu sunt în
ordinea dorită, le interschimbăm valorile
 după o singură parcurgere, vectorul nu se va sorta, dar putem repeta parcurgerea
 dacă la o parcurgere nu se face nicio interschimbare, vectorul este sortat

O reprezentare a algoritmului este:

 cat timp vectorul nu este sortat

o presupunem că vectorul este sortat
o parcurgem vectorul
 dacă două elemente învecinate nu sunt în ordinea dorită
 le interschimbăm

 schimbăm presupunerea inițială

int n, v[100];
//citire v[] cu n elemente
bool sortat;
do
{
sortat = true;
for(int i = 0 ; i < n - 1 ; i ++)
if(v[i] > v[i+1])
{
int aux = v[i];
v[i] = v[i+1];
v[i+1] = aux;
sortat = false;
}
}
while(!sortat);

Sortarea prin inserție (Insertion Sort) se bazează pe următoarea idee:

 fie un vector X[] cu n elemente;
 dacă secvența cu indici 0, 1, …, i-1 este ordonată, atunci putem insera
elementul X[i] în această secvență astfel încât să fie ordonată secvența cu
indici 0, 1, …, i-1, i.
 luăm pe rând fiecare element X[i] și îl inserăm în secvența din stânga sa
 la final întreg vectorul va fi ordonat

int n, X[100];
//citire X[] cu n elemente
for(int i = 1 ; i < n ; i ++)
{
int x = a[i];
int p = i - 1;
while(p >= 0 && a[p] > x)
a[p + 1] = a[p], p --;
a[p + 1] = x;
}
Sortarea prin numarare

Se parcurge vectorul v și se rețin frecvențele elementelor sale în vectorul de frecvență frq.

Apoi, se parcurge vectorul frq de la 0 la MAX−1 dacă vrem să realizăm o sortare
crescătoare, sau de la MAX−1 la 0 în caz contrar. Considerăm k noua lungime a vectorului,
și o inițializăm cu 0. Pentru fiecare element frq[i], adăugăm valoarea i la finalul vectorului
(pe poziția k, ce mai întâi este incrementată) de frq[i] ori, pentru că de atâtea ori apare
aceasta în v. Ordinea în care este parcurs vectorul de frecvență ne garantează că
elementele vor fi reintroduse în vector gata sortate.

for

(int i = 1; i <= n; i++)

frq[v[i]]++;

int k = 0;
for (int i = 0; i < MAX; i++)
while (frq[i]--)
v[++k] = i;
 Cautare Binara

st=1; dr=n; ok=0;

while(st<=dr&&ok==0)
{
m=(st+dr)/2;
if(v[m]==x)
ok=1;
else if(v[m]>x)
dr=m-1;
else
st=m+1;
}

Backtracking

void afisare()
{...}
int valid(int k)
{...
return 0;
return 1;}
void BK(int k)
{int i;
for (i=1; i<=n; i++)
{v[k]=i;
if (valid(k)==1)
{if (k==n)
afisare();
else
BK(k+1);
}}}
int main()