Algoritmi de bază (clasa a IX-a)

1️⃣ Suma cifrelor unui număr

Enunț:
Se dă un număr natural n. Să se calculeze suma tuturor cifrelor sale.
De exemplu:
- n = 4729 → suma cifrelor = 4 + 7 + 2 + 9 = 22
- n = 123 → suma cifrelor = 1 + 2 + 3 = 6

Explicație detaliată:
1. Inițializăm o variabilă suma cu valoarea 0 pentru a stoca suma cifrelor.
2. Luăm ultima cifră a lui n folosind cifra = n % 10.
3. Adunăm această cifră la suma: suma = suma + cifra.
4. Eliminăm ultima cifră din n prin împărțire întreagă: n = [n/10].
5. Repetăm pașii 2–4 până când n devine 0.
6. La final, suma va conține suma tuturor cifrelor lui n.

Exemplu pas cu pas:
- n = 4729, suma = 0
1) cifra = 4729 % 10 = 9 → suma = 0 + 9 = 9 → n = [4729/10] = 472
2) cifra = 472 % 10 = 2 → suma = 9 + 2 = 11 → n = [472/10] = 47
3) cifra = 47 % 10 = 7 → suma = 11 + 7 = 18 → n = [47/10] = 4
4) cifra = 4 % 10 = 4 → suma = 18 + 4 = 22 → n = [4/10] = 0
- Rezultat final: suma = 22

Observații:
- Algoritmul funcționează pentru orice număr natural.
- Operația n mod 10 obține cifra cea mai din dreapta.
- Împărțirea întreagă [n/10] elimină ultima cifră.
- Complexitatea algoritmului este proporțională cu numărul de cifre al lui n.

Pseudocod:

citeste n
suma ← 0
cat timp n > 0 executa
    cifra ← n % 10
    suma ← suma + cifra
    n ← [n / 10]
sfarsit cat timp
scrie suma

C++:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int suma = 0;
    while (n > 0) {
        int cifra = n % 10;
        suma += cifra;
        n = n / 10;
    }
    cout << suma;
    return 0;
}

2️⃣ Verificare număr prim

Enunț:
Se dă un număr natural n. Să se verifice dacă este prim.
Număr prim: un număr natural mai mare decât 1 care are exact doi divizori: 1 și el însuși.
Exemple:
- n = 7 → divizori: 1,7 → prim
- n = 10 → divizori: 1,2,5,10 → nu e prim
- n = 1 → nu e prim

Explicație detaliată:
1. Dacă n ≤ 1, atunci n nu este prim.
2. Presupunem inițial că n este prim (prim = adevărat adica prim = 1 ).
3. Verificăm fiecare divizor d de la 2 până la [n/2]:
  - Dacă n mod d = 0, atunci n nu este prim → setăm prim = fals adica prim = 0 .
4. După verificarea tuturor divizorilor, dacă prim = adevărat adica prim = 1 și n > 1, numărul este prim.
5. În caz contrar, nu este prim.

Exemplu pas cu pas:
- n = 29
Divizori verificați: d = 2 → 29 % 2 ≠ 0, d = 3 → 29 % 3 ≠ 0, d = 4 → 29 % 4 ≠ 0, d = 5 → 29 % 5 ≠ 0
Nu s-a găsit niciun divizor → 29 este prim.

- n = 20
Divizori verificați: d = 2 → 20 % 2 = 0 → 20 nu este prim

Observații:
- Verificarea până la [n/2] este suficientă pentru clasa a IX-a.
- Numerele 0 și 1 nu sunt prime.
- Complexitatea algoritmului este proporțională cu n/2, adică O(n).

Pseudocod:

citeste n
prim ← 1; d ← 2  
cat timp d <= [n/2] executa
    daca n % d = 0 atunci
        prim ← 0
    sfarsit daca
    d ← d + 1
sfarsit cat timp
daca prim = 1 si n > 1 atunci
    scrie "Numarul este prim"
altfel
    scrie "Numarul NU este prim"
sfarsit daca

C++:

#include <iostream>
using namespace std;

int main() {
    int n , d ;
    cin >> n;
    bool prim = true;
    d = 2 ;
    while (d <= n/2) {
        if (n % d == 0) 
           prim = false;
        d = d + 1 ; 
                     }
    if (prim && n > 1) cout << "Numarul este prim";
    else cout << "Numarul NU este prim";
    return 0;
}

3️⃣ Număr palindrom

Enunț:
Se dă un număr natural n. Să se verifice dacă n este palindrom.
Un număr este palindrom dacă se citește la fel de la stânga la dreapta și de la dreapta la stânga.
De exemplu:
- 121 → palindrom (citit invers tot 121)
- 12321 → palindrom (citit invers tot 12321)
- 1234 → nu este palindrom (citit invers 4321)

Explicație detaliată:
1. Salvăm valoarea inițială a lui n într-o variabilă original, pentru a o compara la final.
2. Construim numărul invers invers pas cu pas:
   - Luăm ultima cifră a lui n cu cifra = n % 10.
   - Adăugăm această cifră la invers după formula invers = invers * 10 + cifra.
   - Eliminăm ultima cifră din n prin n = [n/10].
3. Repetăm pasul 2 până când n devine 0. La final, invers conține numărul citit invers.
4. Comparăm invers cu original:
   - Dacă sunt egale → numărul este palindrom.
   - Dacă nu sunt egale → numărul nu este palindrom.
5. Exemple de calcul:
   - n = 1221
      Pas 1: cifra = 1221 % 10 = 1 → invers = 0*10 + 1 = 1, n = 122
      Pas 2: cifra = 122 % 10 = 2 → invers = 1*10 + 2 = 12, n = 12
      Pas 3: cifra = 12 % 10 = 2 → invers = 12*10 + 2 = 122, n = 1
      Pas 4: cifra = 1 % 10 = 1 → invers = 122*10 + 1 = 1221, n = 0
   Comparăm invers (1221) cu original (1221) → palindrom.
   - n = 1234
      Construim invers = 4321
   Comparăm invers (4321) cu original (1234) → nu este palindrom.

Pseudocod:

citeste n
original ← n
invers ← 0
cat timp n != 0 executa
    cifra ← n % 10
    invers ← invers * 10 + cifra
    n ← [n / 10]
sfarsit cat timp
daca invers = original atunci
    scrie "Numarul este palindrom"
altfel
    scrie "Numarul NU este palindrom"
sfarsit daca

C++:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int original = n, invers = 0;
    while (n != 0) {
        int cifra = n % 10;
        invers = invers * 10 + cifra;
        n = n / 10;
    }
    if (invers == original) cout << "Numarul este palindrom";
    else cout << "Numarul NU este palindrom";
    return 0;
}

4️⃣ Număr perfect

Enunț:
Se dă un număr natural n. Să se verifice dacă este perfect.
Număr perfect: un număr natural pentru care suma tuturor divizorilor săi proprii (adică divizorii mai mici decât el) + 1 este egală cu n.
Exemple:
- n = 6 → 1 + divizori proprii: 2, 3 → suma = 6 → perfect
- n = 28 → 1 + divizori proprii: 2, 4, 7, 14 → suma = 28 → perfect
- n = 12 → 1 + divizori proprii: 2, 3, 4, 6 → suma = 16 → nu e perfect

Explicație detaliată:
1. Dacă n ≤ 1, numărul nu este perfect.
2. Presupunem că suma = 1 deoarece 1 este divizor pentru orice n > 1.
3. Parcurgem divizorii d de la 2 până la [n/2]:
  - Dacă n % d = 0, adăugăm d la suma divizorilor.
4. După adunarea tuturor divizorilor, dacă suma = n, atunci numărul este perfect.
5. În caz contrar, numărul nu este perfect.

Exemplu pas cu pas:
- n = 28
Divizori proprii verificați: 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
Divizorii (cei proprii si 1) care împart 28 exact: 1, 2, 4, 7, 14 → suma = 28 → 28 este număr perfect.

- n = 12
1 + Divizorii proprii: 2, 3, 4, 6 → suma = 16 → 12 nu este număr perfect

Observații:
- Pentru numere mari, se poate optimiza verificarea până la √n, dar pentru clasa a IX-a verificarea până la [n/2] este suficientă.
- Numerele 1 și 0 nu sunt considerate perfecte.
- Algoritmul presupune să adunăm doar 1 si divizorii proprii, fără n însuși.

Pseudocod:

citeste n
daca n <= 1 atunci
    scrie "Nu este perfect"
altfel
    suma ← 1
    d ← 2 
    cat timp d <= [n/2] executa
        daca n % d = 0 atunci
            suma ← suma + d
        sfarsit daca
        d ← d + 1 
    sfarsit cat timp
    daca suma = n atunci
        scrie "Numarul este perfect"
    altfel
        scrie "Numarul NU este perfect"
    sfarsit daca
sfarsit daca

C++:

#include <iostream>
using namespace std;

int main() {
    int n , d;
    cin >> n;
    if (n <= 1) cout << "Nu este perfect";
    else {
        int suma = 1;
        d = 2;
        while ( d <= n/2) 
        {
            if (n % d == 0) 
                suma = suma + d;
            d = d + 1;
        }
        if (suma == n) cout << "Numarul este perfect";
        else cout << "Numarul NU este perfect";
    }
    return 0;
}

5️⃣ Descompunerea în factori primi

Enunț:
Se dă un număr natural n > 1. Să se afișeze descompunerea în factori primi:
n = p1^a1 * p2^a2 * ..., unde:

• p1, p2, ... sunt factorii primi ai lui n;
• a1, a2, ... sunt exponenții corespunzători fiecărui factor prim.

Ce este un factor prim?
Un număr prim este un număr >1 care are exact doi divizori: 1 și el însuși. Factorii primi ai unui număr sunt numerele prime care, înmulțite între ele, dau numărul respectiv.

Explicație detaliată pas cu pas:

1. Pornim cu cel mai mic divizor d = 2.
2. Verificăm dacă d divide exact numărul n folosind n % d == 0.
3. Dacă d divide n:
   • Numărăm de câte ori divide (incrementăm exponentul).
   • Împărțim n = n / d pentru a elimina acest factor.
4. Când d nu mai divide n, afișăm d cu exponentul găsit (dacă exponent > 1) și trecem la d = d + 1.
5. Continuăm până când n = 1. Dacă la final n > 1, atunci n este prim și se afișează cu exponentul 1.

Exemplu detaliat:
Să descompunem n = 180 în factori primi, pas cu pas:

• d = 2: 180 % 2 = 0 → n devine 90, contor = 1
• 90 % 2 = 0 → n devine 45, contor = 2 → am găsit 2^2
• d = 3: 45 % 3 = 0 → n devine 15, contor = 1
• 15 % 3 = 0 → n devine 5, contor = 2 → am găsit 3^2
• d = 4: 5 % 4 ≠ 0 → nu e factor
• d = 5: 5 % 5 = 0 → n devine 1, contor = 1 → am găsit 5

Rezultat final: 180 = 2^2 * 3^2 * 5

Observații importante:

• Dacă exponentul este 1, de obicei nu se scrie.
• Algoritmul este simplu și potrivit pentru numere moderate.
• Nu folosește vectori sau biblioteci suplimentare.

Pseudocod:

citește n
cn ← n
d ← 2
prima ← 1
scrie cn, "="

cât timp n > 1 execută
    putere ← 0
    cât timp n % d = 0 execută
        putere ← putere + 1
        n ← [n / d]
    sfârșit cât timp

    dacă putere > 0 atunci
        dacă prima = 1 atunci
            scrie " * "
        sfârșit dacă
        scrie d
        dacă putere > 1 atunci
            scrie "^", putere
        sfârșit dacă
        prima ← 0
    sfârșit dacă

    d ← d + 1
sfârșit cât timp

C++:

#include <iostream>
using namespace std;

int main() {
    long long n, cn;
    cin >> n;
    cn = n;

    cout << cn << " = ";

    int putere, prima = 1;
    long long d = 2;

    while (n > 1) {
        putere = 0;
        while (n % d == 0) {
            putere++;
            n /= d;
        }
        if (putere > 0) {
            if (prima==0) cout << " * ";
            cout << d;
            if (putere > 1) cout << "^" << putere;
            prima = 0;
        }
        d++;
    }

    cout << "\\n";
    return 0;
}

6️⃣ Construirea unui număr cifră cu cifră (algoritmul cu p)

Enunț:
Se dă un număr natural n. Să reconstruim numărul pornind de la cifrele sale, parcurse de la sfârșit la început.
Obiectiv: să obținem numărul original folosind doar operații aritmetice, fără a folosi șiruri de caractere sau vectori.

Explicație detaliată:

1. Inițializăm două variabile:
   • p = 1 → reprezintă puterea curentă a lui 10 (unități, zeci, sute…)
   • rez = 0 → va conține numărul reconstruit pe măsură ce procesăm cifrele
2. Luăm cifra cea mai din dreapta a lui n folosind restul împărțirii la 10: cifra = n % 10.
3. Adăugăm această cifră la rezultat multiplicată cu puterea curentă a lui 10: rez = rez + cifra * p.
4. Creștem puterea pentru poziția următoarei cifre: p = p * 10. Aceasta asigură că fiecare cifră ajunge pe poziția corectă (unități, zeci, sute...).
5. Eliminăm cifra procesată din n împărțind numărul la 10 și păstrând partea întreagă: n = [n / 10].
6. Repetăm pașii 2–5 până când n = 0. La final, rez va fi numărul complet reconstruit.

Exemplu pas cu pas:
Să reconstruim numărul n = 12345:

Rezultat final: rez = 12345

Observații suplimentare:

• Fiecare cifră este procesată de la coadă la capătul numărului.
• Variabila p asigură poziționarea corectă a cifrei în numărul final.
• Algoritmul poate fi extins pentru a modifica sau înlocui cifrele înainte de a le adăuga la rez.
• Acest mod de lucru evită utilizarea șirurilor de caractere și vectorilor, fiind pur aritmetic.

Pseudocod:

citeste n
p ← 1
rez ← 0
cat timp n != 0 executa
    cifra ← n % 10
    rez ← rez + cifra * p
    p ← p * 10
    n ← [n / 10]
sfarsit cat timp
scrie rez

C++:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int p = 1, rez = 0;
    while (n != 0) {
        int cifra = n % 10;
        rez += cifra * p;
        p *= 10;
        n = n / 10;
    }
    cout << rez;
    return 0;
}

7️⃣ Înlocuirea unei cifre c1 cu c2 într-un număr (o singură buclă)

Enunț:
Se dau un număr natural n și două cifre c1 și c2. Să se înlocuiască toate aparițiile cifrei c1 din n cu c2, folosind o singură buclă cat timp, obținând numărul final rez.

Explicație detaliată:

1. Inițializăm:
   • rez = 0 → numărul final
   • p = 1 → factorul de poziție (unități, zeci, sute…)
2. Cat timp n != 0:
   • Luăm cifra cea mai din dreapta: cifra = n % 10
   • Dacă cifra = c1, atunci cifra ← c2
   • Adăugăm cifra la rez folosind: rez = rez + p * cifra
   • Creștem factorul de poziție: p = p * 10
   • Eliminăm cifra procesată: n = n / 10

Exemplu pas cu pas:
Să înlocuim toate aparițiile cifrei 2 cu 9 în numărul n = 1234257:

Rezultat final: rez = 1934957

Pseudocod:

citeste n, c1, c2
rez ← 0
p ← 1
cat timp n != 0 executa
    cifra ← n % 10
    daca cifra = c1 atunci 
              cifra ← c2
 sfarsit daca 
    rez ← rez + p * cifra
    p ← p * 10
    n ← n div 10
sfarsit cat timp
scrie rez

C++:

#include <iostream>
using namespace std;

int main() {
    int n, c1, c2;
    cin >> n >> c1 >> c2;
    int rez = 0, p = 1;
    while (n != 0) {
        int cifra = n % 10;
        if (cifra == c1) cifra = c2;
        rez = rez + p * cifra;
        p = p * 10;
        n = n / 10;
    }
    cout << rez;
    return 0;
}

8️⃣ Citirea a n numere și operații uzuale

Enunț:
Se citesc n numere întregi: x1, x2, ..., xn. Să se calculeze:

• sumă = suma tuturor numerelor
• medie = suma împărțită la n
• minim = cel mai mic număr
• maxim = cel mai mare număr
• countPoz = numărul de valori pozitive

Explicație detaliată:

1. Inițializăm variabilele:
   • suma = 0 → va reține suma numerelor citite
   • minim = +∞ → cel mai mic număr, inițial mare
   • maxim = -∞ → cel mai mare număr, inițial mic
   • countPoz = 0 → contor pentru numerele pozitive
2. Parcurgem fiecare număr xi (i=1..n):
   • Adăugăm la sumă: suma = suma + xi
   • Dacă xi < minim, actualizăm minim = xi
   • Dacă xi > maxim, actualizăm maxim = xi
   • Dacă xi > 0, incrementăm countPoz = countPoz + 1
3. După ce am parcurs toate numerele, calculăm media: media = suma / n (poate fi parte întreagă sau cu zecimale).
4. Rezultatul final este suma, media, minim, maxim și countPoz.

Exemplu pas cu pas:
Să citim n = 5 numere: 3, -1, 4, 3, 0

Calcul media: media = suma / n = 9 / 5 = 1.8

Rezultat final: suma = 9, media = 1.8, minim = -1, maxim = 4, countPoz = 3

Observații suplimentare:

• Algoritmul funcționează parcurgând fiecare element o singură dată, ceea ce îl face eficient.
• Inițializarea variabilelor minim și maxim cu valori extreme (+∞, -∞) garantează corectitudinea pentru orice set de numere.
• Numerele pozitive se numără printr-un simplu contor incrementat când xi > 0.
• Media poate fi calculată ca parte întreagă folosind [suma / n] sau cu zecimale prin conversie la tip double.

Pseudocod:

citeste n
c ← 1
suma ← 0
minim ← +∞
maxim ← -∞
countPoz ← 0
cat timp c ≤ n executa
    citeste x
    suma ← suma + x
    daca x < minim atunci minim ← x
    daca x > maxim atunci maxim ← x
    daca x > 0 atunci countPoz ← countPoz + 1
    c ← c + 1
sfarsit cat timp
media ← [suma / n]
scrie suma, media, minim, maxim, countPoz

C++:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int suma = 0, minim = 1e9, maxim = -1e9, countPoz = 0;
    for (int c = 1; c <= n; c++) {
        int x;
        cin >> x;
        suma += x;
        if (x < minim) minim = x;
        if (x > maxim) maxim = x;
        if (x > 0) countPoz++;
    }
    double media = (double)suma / n;
    cout << suma << " " << media << " " << minim << " " << maxim << " " << countPoz;
    return 0;
}

9️⃣ Șirul lui Fibonacci

Enunț:
Se dă un număr natural n. Să se afișeze primii n termeni ai șirului Fibonacci: 0, 1, 1, 2, 3, 5, 8, …

Explicație detaliată:

1. Definiția șirului Fibonacci:
   • F0 = 0
   • F1 = 1
   • Fiecare termen următor se obține prin Fn = F(n-1) + F(n-2), pentru n ≥ 2.
2. Inițializăm două variabile:
   • a = 0 → primul termen
   • b = 1 → al doilea termen
3. Procedura:
   • Dacă n >= 1, afișăm a
   • Dacă n >= 2, afișăm b
   • Pentru i = 3..n:
     • Calculăm următorul termen: c = a + b
     • Afișăm c
     • Actualizăm variabilele: a = b, b = c

Exemplu pas cu pas:
Să afișăm primii n = 10 termeni ai șirului Fibonacci.

Rezultat final: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Observații suplimentare:

• Fiecare termen se calculează doar din ultimele două valori, astfel algoritmul este eficient și nu necesită memorarea întregului șir.
• Se poate folosi și o soluție recursivă, dar pentru n mare poate fi ineficientă.
• Algoritmul poate fi adaptat pentru a verifica dacă un anumit număr m aparține șirului Fibonacci prin generarea termenilor până la m sau până îl depășim.

Pseudocod:

citeste n
daca n >= 1 atunci
    a ← 0
    scrie a
sfarsit daca
daca n >= 2 atunci
    b ← 1
    scrie b
sfarsit daca
i ← 3
cat timp i <= n executa
    c ← a + b
    scrie c
    a ← b
    b ← c 
    i ← i + 1 
sfarsit cat timp

C++:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int a = 0, b = 1;
    if (n >= 1) cout << a << " ";
    if (n >= 2) cout << b << " ";
    i = 3;
    while ( i <= n ) 
    {
        int c = a + b;
        cout << c << " ";
        a = b;
        b = c;
        i = i + 1;
    }
    return 0;
}

🔟 Generarea unui șir AP și GP

Enunț:
Se dau:

• AP (progresie aritmetică): a_k = a1 + (k-1) * d
• GP (progresie geometrică): a_k = a1 * q^(k-1)

Explicație detaliată:

Progresie aritmetică (AP)

O progresie aritmetică este un șir de numere în care fiecare termen (începând cu al doilea) se obține prin adunarea unei valori fixe, numită rație (d), la termenul precedent.

Algoritmul pentru generarea primilor n termeni:

1. Se stabilește primul termen a1 și rația d.
2. Primul termen se afișează direct.
3. Al doilea termen se obține prin a2 = a1 + d.
4. Al treilea termen se obține prin a3 = a2 + d, și tot așa până la an.

Exemple AP:

Progresie geometrică (GP)

O progresie geometrică este un șir de numere în care fiecare termen (începând cu al doilea) se obține prin înmulțirea termenului precedent cu o valoare fixă, numită rație (q).

Algoritmul pentru generarea primilor n termeni:

1. Se stabilește primul termen a1 și rația q.
2. Primul termen se afișează direct.
3. Al doilea termen se obține prin a2 = a1 * q.
4. Al treilea termen se obține prin a3 = a2 * q, și tot așa până la an.

Exemple GP:

Observații suplimentare:

• AP se generează prin adunarea unei valori fixe la termenul precedent.
• GP se generează prin înmulțirea termenului precedent cu o valoare fixă.
• Algoritmul este eficient, deoarece fiecare termen se calculează doar din ultimul termen generat, fără a necesita memorarea întregului șir.

Pseudocod AP:

citeste a1, d, n
pentru k ← 1 pana la n executa
    a ← a1 + (k-1) * d
    scrie a
sfarsit pentru

C++ AP:

#include <iostream>
using namespace std;

int main() {
    int a1, d, n;
    cin >> a1 >> d >> n;
    for (int k = 1; k <= n; k++) {
        int a = a1 + (k-1)*d;
        cout << a << " ";
    }
    return 0;
}

Pseudocod GP:

citeste a1, q, n
term ← a1
pentru k ← 1 pana la n executa
    scrie term
    term ← term * q
sfarsit pentru

C++ GP:

#include <iostream>
using namespace std;

int main() {
    int a1, q, n;
    cin >> a1 >> q >> n;
    int term = a1;
    for (int k = 1; k <= n; k++) {
        cout << term << " ";
        term = term * q;
    }
    return 0;
}

1️⃣ Probleme cu secvențe

Enunț:
Se citesc n numere întregi. Trebuie să determinăm:

• lungimea celei mai lungi secvențe strict crescătoare
• lungimea celei mai scurte secvențe strict crescătoare
• lungimea maximă a secvențelor de elemente egale

Exemple numerice:

Exemplul 1:

Șirul: 3, 5, 7, 2, 4, 6, 6, 6, 1

• Secvențe strict crescătoare:
  • 3 → 5 → 7 : lungime 3
  • 2 → 4 → 6 : lungime 3
  Lungimea maximă: 3
  Lungimea minimă: 3
• Secvențe de elemente egale:
  • 6 → 6 → 6 : lungime 3
  Lungimea maximă: 3

Exemplul 2:

Șirul: 5, 6, 7, 1, 2, 3, 4, 0, 1, 2, 2, 2

• Secvențe strict crescătoare:
  • 5 → 6 → 7 : lungime 3
  • 1 → 2 → 3 → 4 : lungime 4
  • 0 → 1 → 2 : lungime 3
  Lungimea maximă: 4 (1→2→3→4)
  Lungimea minimă: 3 (5→6→7 și 0→1→2)
• Secvențe de elemente egale:
  • 2 → 2 → 2 : lungime 3
  Lungimea maximă: 3

Exemplul 3:

Șirul: 3, 4, 5, 6, 1, 2, 3, 1, 1, 2, 3, 4, 5, 0

• Secvențe strict crescătoare:
  • 3 → 4 → 5 → 6 : lungime 4
  • 1 → 2 → 3 : lungime 3
  • 1 → 2 → 3 → 4 → 5 : lungime 5
  • 0 : lungime 1
  Lungimea maximă: 5 (1→2→3→4→5)
  Lungimea minimă: 1 (0)
• Secvențe de elemente egale:
  • 1 → 1 : lungime 2
  • 2 → 2 : lungime 2
  Lungimea maximă: 2

Explicație detaliată:

1. Secvențe strict crescătoare:
   • Comparăm fiecare număr cu precedentul.
   • Dacă numărul curent > precedent → secvența continuă: incrementăm curMax și curMin.
   • Dacă nu → secvența se întrerupe: actualizăm maxLen și minLen, resetăm curMax = 1 și curMin = 1.
   • La final, comparăm ultima secvență cu maxLen și minLen și actualizăm dacă e cazul.
2. Secvențe de elemente egale:
   • Comparăm fiecare număr cu precedentul.
   • Dacă numărul curent = precedent → secvența continuă, incrementăm curLen.
   • Dacă nu → secvența se întrerupe, actualizăm maxLen, resetăm curLen = 1.
   • La final, comparăm ultima secvență cu maxLen și actualizăm dacă e cazul.

Pseudocod secvență crescătoare:

citeste n
citeste x1
curMax ← 1
curMin ← 1
maxLen ← 1
minLen ← n
prev ← x1
pentru i ← 2 pana la n executa
    citeste xi
    daca xi > prev atunci
        curMax ← curMax + 1
        curMin ← curMin + 1
    altfel
        daca curMax > maxLen atunci maxLen ← curMax
        daca curMin < minLen atunci minLen ← curMin
        curMax ← 1
        curMin ← 1
    sfarsit daca
    prev ← xi
sfarsit pentru
daca curMax > maxLen atunci maxLen ← curMax
daca curMin < minLen atunci minLen ← curMin
scrie maxLen, minLen
        

Pseudocod secvențe egale:

citeste n
citeste x1
curLen ← 1
maxLen ← 1
prev ← x1
pentru i ← 2 pana la n executa
    citeste xi
    daca xi = prev atunci
        curLen ← curLen + 1
    altfel
        daca curLen > maxLen atunci maxLen ← curLen
        curLen ← 1
    sfarsit daca
    prev ← xi
sfarsit pentru
daca curLen > maxLen atunci maxLen ← curLen
scrie maxLen
        

C++ secvență crescătoare:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int x, prev;
    cin >> prev;
    int curMax = 1, curMin = 1, maxLen = 1, minLen = n;
    for (int i = 2; i <= n; i++) {
        cin >> x;
        if (x > prev) {
            curMax++;
            curMin++;
        } else {
            if (curMax > maxLen) maxLen = curMax;
            if (curMin < minLen) minLen = curMin;
            curMax = 1;
            curMin = 1;
        }
        prev = x;
    }
    if (curMax > maxLen) maxLen = curMax;
    if (curMin < minLen) minLen = curMin;
    cout << maxLen << " " << minLen;
    return 0;
}
        

C++ secvențe egale:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int x, prev;
    cin >> prev;
    int curLen = 1, maxLen = 1;
    for (int i = 2; i <= n; i++) {
        cin >> x;
        if (x == prev) curLen++;
        else {
            if (curLen > maxLen) maxLen = curLen;
            curLen = 1;
        }
        prev = x;
    }
    if (curLen > maxLen) maxLen = curLen;
    cout << maxLen;
    return 0;
}