Instrucțiuni de bază în C/C++

Instrucțiunile sunt blocurile fundamentale care alcătuiesc orice program în C/C++. Cel mai simplu tip este instrucțiunea expresie - o operație care se evaluează și se termină cu punct și virgulă:

i++;         // incrementează valoarea variabilei i
p = 2*r;     // înmulțește cu 2 valoarea variabilei r

Să nu uiți că orice instrucțiune în C/C++ se termină cu ; - e o greșeală frecventă să îl omiți!

Când avem nevoie să executăm mai multe instrucțiuni ca un bloc, folosim instrucțiunea compusă - un grup de instrucțiuni între acolade {}. Aceasta este extrem de utilă în structurile de control.

💡 Orice expresie poate fi o instrucțiune validă, chiar dacă nu produce niciun efect (de exemplu 2+5;). Acest lucru îți permite să scrii cod care e sintactic corect, dar asigură-te că are și un scop!

Pentru a controla fluxul programului, folosim instrucțiunea if:

if (a > 0) 
    cout << "a este pozitiv";
else 
    cout << "a este negativ sau zero";

Poți calcula simplu maximul dintre două numere astfel:

if (a > b) max = a;
else max = b;

Instrucțiunea while este folosită pentru a executa repetat un bloc de cod cât timp o condiție este adevărată:

while (n) {
    r = r*10 + n%10;  // adăugăm ultima cifră la răsturnat
    n /= 10;          // eliminăm ultima cifră din n
}

Acest exemplu calculează răsturnatul unui număr - o operație frecventă în problemele de informatică.

Instrucțiuni repetitive și decizionale

Instrucțiunea do-while este similară cu while, dar garantează că blocul de cod se execută cel puțin o dată:

do {
    n = n/10;   // elimină ultima cifră din n
    k++;        // număr cifre
} while (n != 0);

Această structură este ideală când ai nevoie să execuți codul cel puțin o dată, înainte de a verifica condiția.

Instrucțiunea for este o structură compactă pentru repetiții, care combină inițializarea, testul și incrementarea într-o singură linie:

for (i=1; i<=n; i++) 
    fact = fact * i;

💡 Pentru calculul factorialului, instrucțiunea for este mult mai elegantă decât while, deoarece toate operațiile necesare sunt în antet!

Orice expresie din for poate fi vidă, dar separatorii ; trebuie păstrați. De exemplu:

for (;;) {
    cin >> x;
    if (x > 0) break;
}

Acest cod citește numere până când întâlnește unul pozitiv.

Instrucțiunea break termină execuția celei mai apropiate structuri repetitive în care se află. Este utilă pentru a ieși dintr-un ciclu când întâlnești o anumită condiție.

Calcul numeric: Poți rezolva probleme simple dar importante cu aceste instrucțiuni. De exemplu, pentru calculul modulului unui număr:

if (x >= 0)
    m = x;
else
    m = -x;

Pentru a verifica paritatea unui număr:

if (x % 2 == 0)
    printf("%d este par\n", x);
else
    printf("%d este impar\n", x);

Exemple de algoritmi

Să analizăm un algoritm simplu care calculează puterea unui număr:

#include <stdio.h>
int main(void) {
    int n, x;
    scanf("%d", &n);
    x = 1;
    for (i = 1; i <= n; i++)
        x = x * 2;
    printf("%d", x);
    return 0;
}

Acest program calculează 2^n (2 la puterea n). Urmărind execuția pentru n = 3, observăm cum x începe de la 1 și se dublează la fiecare iterație: 1 → 2 → 4 → 8.

Iată și un program care numără câte numere pare se află între a și b:

#include <stdio.h>
int main(void) {
    int a, b, nr, i;
    scanf("%d%d", &a, &b);
    nr = 0;
    for (i = a; i <= b; i++)
        if (i % 2 == 0) nr++;
    printf("%d", nr);
    return 0;
}

💡 În loc să verifici fiecare număr, poți calcula direct numărul de pare din interval folosind o formulă matematică, făcând programul mult mai eficient!

Aceste exemple demonstrează cum poți folosi instrucțiunile de bază pentru a rezolva probleme complexe prin pași simpli și bine definiți.

O abordare sistematică este să urmărești execuția algoritmului pas cu pas, pentru valori de test, notând valorile variabilelor la fiecare etapă. Această tehnică te ajută să înțelegi exact cum funcționează codul și să identifici eventuale erori.

Aplicații practice

Să explorăm câteva exemple concrete care demonstrează puterea instrucțiunilor C/C++ în rezolvarea problemelor reale:

Afișarea codurilor ASCII

Un exemplu interesant este afișarea codurilor ASCII și a caracterelor corespunzătoare:

#include <iostream>
int main() {
    for(int cod=0; cod<=255; cod++) {
        switch(cod) {
            case 7: cout<<"\a"; break;
            case 10: cout<<"\n"; break;
            // alte cazuri speciale
            default: cout<<(unsigned char)cod;
        }
        cout<<" ";
    }
    return 0;
}

💡 Unele coduri ASCII au efecte speciale (sunet, salt la linie nouă) și trebuie tratate diferit când le afișezi!

Generarea unei secvențe simetrice

O problemă clasică este generarea unei secvențe simetrice de numere:

n=7:  1 2 3 4 3 2 1
n=8:  1 2 3 4 4 3 2 1

Această problemă testează înțelegerea ta despre instrucțiunile repetitive și logica de control al fluxului. O poți rezolva folosind două bucle - una pentru prima jumătate a secvenței și alta pentru a doua jumătate.

Modele de afișare

Instrucțiunile repetitive îți permit să creezi modele interesante, cum ar fi triunghiuri de numere:

for (i=0; i<n; i++) {
    for (j=0; j<=i; j++) {
        cout<<j;
    }
    cout<<endl;
}

Acest cod generează un triunghi de numere:

0
01
012
0123
...

Exercițiile de acest gen dezvoltă gândirea algoritmică și îți oferă experiență practică în utilizarea structurilor de control pentru a rezolva probleme de programare variate.

Algoritmi numerici fundamentali

Limbajul C/C++ excelează în implementarea algoritmilor numerici. Să explorăm câteva exemple esențiale:

Calculul CMMDC (cel mai mare divizor comun)

Un algoritm clasic este cel al lui Euclid pentru calculul CMMDC:

while (b) {
    r = a%b;
    a = b;
    b = r;
}
// CMMDC este în variabila a

Acest algoritm simplu dar elegant funcționează prin înlocuiri succesive până când b devine 0.

Calculul termenilor Fibonacci

Șirul Fibonacci (1, 1, 2, 3, 5, 8, 13, 21...) este fundamental în informatică și matematică:

f0 = 1; f1 = 1;
for (i=2; i<=n; i++) {
    f2 = f0 + f1;  // calculez termenul curent
    f0 = f1; f1 = f2;
}

💡 Observă cum folosim doar trei variabile pentru a calcula termeni oricât de mari din șirul Fibonacci, economisind astfel memoria!

Verificarea existenței unui multiplu

Un alt exemplu practic este verificarea dacă într-un șir de n valori există un multiplu al lui p:

existență = 0;
for (i=1; i<=n; i++) {
    scanf("%d", &d);
    if (d % p == 0) existență = 1;
}

Această abordare folosește o variabilă boolean (care poate fi 0 sau 1) pentru a marca descoperirea unui multiplu.

Determinarea factorilor primi

Descompunerea în factori primi este un algoritm fundamental:

d = 2;
while (x > 1) {
    while (x % d == 0) {
        x /= d;
        nr++;  // numărăm divizorii primi
    }
    d++;
}

Aceste algoritmi numerici sunt esențiali nu doar pentru rezolvarea problemelor școlare, ci și în aplicații reale de criptografie, compresie de date sau inteligență artificială.

Probleme complexe și soluții elegante

Să analizăm câteva probleme mai avansate și abordările lor:

Calcularea radicalului

Un exemplu interesant este calcularea radicalului de ordin 3 folosind o relație de recurență:

do {
    xnp1 = (2.0/3.0)*xn + (1.0/3.0)*x/(xn*xn);
    if (fabs(xnp1-xn) < EPS) break;
    xn = xnp1;
} while(1);

💡 Această metodă iterativă $Newton-Raphson$ converge rapid spre soluție, fiind mult mai precisă decât pow$x,1.0/3.0$ în multe cazuri!

Numărarea vocalelor într-un text

O problemă clasică de prelucrare a textelor:

do {
    c = getchar();  // citim succesiv caracterele
    if (c=='a' || c=='e' || c=='i' || c=='o' || c=='u')
        nr++;
} while(c!='.');

Această abordare simplă scanează fiecare caracter și numără vocalele până la întâlnirea punctului.

Calculul unei expresii matematice complexe

Poți implementa și calcule matematice avansate, cum ar fi serii:

S = 1; p = 1;  // S = suma, p = factorial curent
for (i=1; i<=n; i++) {
    p *= i;  // actualizăm factorialul
    S += pow(x,i) / p;
}

Acest cod calculează expresia $E_n(x) = 1 + \frac{x}{1!} + \frac{x^2}{2!} + ... + \frac{x^n}{n!}$, care aproximează $e^x$.

Verificarea ipotezei Goldbach

O problemă interesantă este verificarea ipotezei că orice număr natural par mai mare decât 2 poate fi scris ca suma a două numere prime:

for (a=2; a<=n/2; a++) {
    if (este_prim(a) && este_prim(n-a)) {
        exista = 1;
        break;
    }
}

Aceste exemple mai avansate demonstrează cum poți combina instrucțiunile de bază pentru a rezolva probleme complexe în mod eficient.

Exerciții și probleme pentru aprofundare

Pentru a-ți consolida cunoștințele despre instrucțiunile C/C++, iată câteva exerciții practice pe care le poți încerca:

Funcții matematice personalizate

Scrie un program care să calculeze valoarea unei funcții definite pe cazuri:

f(x) = { 5xy         dacă x>0, y>0
        { min(x,y)    dacă x≤0 sau y≤0
        { 1+1/(x+y)   altfel

Analiza secvențelor de instrucțiuni

Ce efect are următoarea secvență?

int a=9, b=9;
if (a>b) cout<<1; else if (a==b) cout<<2; else cout<<3;
for (int i=0; i<5; i++) {
    a++;
    b--;
    cout<<a<<" ";
}

Probleme geometrice

Scrie un program care verifică dacă trei numere reale pozitive pot forma laturile unui triunghi dreptunghic, și în caz afirmativ, calculează aria triunghiului.

💡 Amintește-ți teorema lui Pitagora: într-un triunghi dreptunghic, suma pătratelor catetelor este egală cu pătratul ipotenuzei!

Probleme cu șiruri de caractere

Scrie un program care citește trei caractere și determină câte caractere distincte s-au citit.

Ecuații și sisteme de ecuații

Implementează un program care rezolvă un sistem de două ecuații liniare cu două necunoscute:

$$\begin{cases} ax + by = c \ dx + ey = f \end{cases}$$

Aceste exerciții te vor ajuta să te familiarizezi cu diverse tipuri de probleme și să-ți dezvolți abilitățile de programare. Încearcă să rezolvi fiecare problemă pe cont propriu înainte de a căuta soluții, deoarece procesul de gândire este la fel de important ca rezultatul final.