Sinteza Modulului 1 - Clasa IX | Școala Româno-Britanică

DEFINIȚIILE CHEIE ALE MODULULUI

Gândirea computațională și algoritmul

Gândirea computațională - modul de a gândi care descompune probleme complexe în pași mici, clari și logici: descompunere, recunoașterea tiparelor, abstracție, algoritmi.

Algoritmul - secvență finită de pași, bine definită și ordonată, care transformă datele de intrare în date de ieșire.

Proprietățile algoritmului - finitudine (număr finit de pași), claritate (pași neambigui), determinism (același rezultat pentru aceleași intrări), generalitate (rezolvă o clasă de probleme), eficiență (puține resurse).

Date de intrare - informațiile primite de program; date de ieșire - rezultatele produse; date de manevră - valorile intermediare.

Etapele elaborării unui program

1. Analiza - identificăm datele de intrare, de ieșire și de manevră.

2. Proiectarea - scriem algoritmul în pseudocod sau organigramă.

3. Implementarea - transformăm algoritmul în instrucțiuni Python.

4. Testarea - rulăm programul cu date de test (valide, invalide, cazuri limită).

5. Depanarea - găsim și corectăm erorile descoperite.

Reprezentarea algoritmilor

Pseudocodul - reprezentarea algoritmului cu cuvinte cheie: citește, scrie, dacă, pentru, cât timp.

Organigrama - reprezentarea cu blocuri grafice: paralelogram (citire/afișare), dreptunghi (prelucrare), romb (decizie).

Limbaje - de nivel înalt (Python, C++ - apropiate de om) și de nivel scăzut (aproape de procesor).

Interpretor - execută programul linie cu linie; compilator - produce un fișier executabil.

Elementele de bază în Python

Variabila - etichetă care reține o valoare; atribuirea cu =.

Tipuri de date - int, float, str, bool; conversii cu int(), float(), str().

input() - citirea de la tastatură; print() - afișarea pe ecran.

Operatori - + - * /, // (câtul întreg), % (restul), comparații < > == != <= >=.

IDE - mediu integrat de dezvoltare (IDLE, Thonny) care reunește editor, rulare și rezultate.

Exemplu complet: citire, prelucrare, afișare

nume = input()          # str
varsta = int(input())   # conversie la int
print("Te numești", nume, "și ai", varsta, "de ani")

Observă: input() întoarce text (str), deci int() transformă în număr înainte de orice calcul. print() poate primi mai multe valori, separate prin virgulă.

Structurile de decizie și repetitive

Decizia - if / elif / else alege o cale de execuție după o condiție; operatorii logici and, or, not.

Bucla for - repetă de un număr cunoscut de ori: for i in range(1, n + 1):.

Bucla while - repetă cât timp condiția este adevărată: while n > 0:.

Acumulatorul - adună valori (inițializat cu 0); numărătorul - numără apariții (inițializat cu 0).

Bucla infinită - condiția while nu devine niciodată falsă (lipsa instrucțiunii de modificare).

Când folosim fiecare: for când știm de câte ori repetăm (de exemplu de la 1 la n), while când repetarea depinde de o condiție care se schimbă în timp (de exemplu „citește până la 0").

Proiectarea modulară, erorile și testarea

Proiectarea modulară - descompunerea problemei în subprobleme cu o singură sarcină fiecare.

Erori - de sintaxă (scriere greșită), de logică (rezultat greșit), de executare (apar în condiții particulare).

Tratarea erorilor - try: ... except: prinde erorile de executare.

Testarea - date valide (funcționare normală), date invalide (reacția la greșeli), cazuri limită (valori extreme).

Tabelul de urmărire a variabilelor - notăm valoarea fiecărei variabile la fiecare pas, pentru a găsi erorile de logică.

Eficiența algoritmilor și notația O

Eficiența - timpul de executare (numărul de operații) și spațiul de memorie folosit.

O(1) - număr constant de operații, independent de n (o formulă).

O(log n) - crește foarte lent (căutarea binară).

O(n) - proporțional cu n (o parcurgere).

O(n^2) - proporțional cu n^2 (două bucle imbricate).

ALGORITMII PRINCIPALI - PSEUDOCOD ȘI PYTHON

1. Suma a două numere

Algoritmul SumaDouaNumere: citește a, b s = a + b scrie s

Python

a = int(input())
b = int(input())

s = a + b

print(s)

2. Media aritmetică a trei numere

Algoritmul MediaTreiNumere: citește n1, n2, n3 s = n1 + n2 + n3 media = s / 3 scrie media

Python

n1 = int(input())
n2 = int(input())
n3 = int(input())

s = n1 + n2 + n3
media = s / 3

print(media)

3. Maximul a două și a trei numere

Algoritmul MaximTreiNumere: citește a, b, c maxim = a dacă b > maxim atunci maxim = b dacă c > maxim atunci maxim = c scrie maxim

Python

a = int(input())
b = int(input())
c = int(input())

maxim = a
if b > maxim:
    maxim = b
if c > maxim:
    maxim = c

print(maxim)

4. Suma 1 + 2 + ... + n

Algoritmul SumaPrimeleN: citește n s = 0 pentru i de la 1 la n execută s = s + i scrie s

Python (O(n))

n = int(input())

s = 0
for i in range(1, n + 1):
    s += i

print(s)

Python cu formulă (O(1))

n = int(input())

s = n * (n + 1) // 2

print(s)

5. Suma cifrelor lui n

Algoritmul SumaCifrelor: citește n s = 0 cât timp n > 0 execută s = s + n % 10 n = n // 10 scrie s

Python

n = int(input())

s = 0
while n > 0:
    s += n % 10
    n //= 10

print(s)

6. Numărul de cifre ale lui n

Algoritmul NumarCifre: citește n cnt = 0 cât timp n > 0 execută cnt = cnt + 1 n = n // 10 scrie cnt

Python

n = int(input())

cnt = 0
while n > 0:
    cnt += 1
    n //= 10

print(cnt)

7. Căutarea unui element într-o listă

Algoritmul CautareSecventiala: citește v, x gasit = fals pentru fiecare element din v execută dacă element = x atunci gasit = adevărat dacă gasit atunci scrie "DA" altfel scrie "NU"

Python (O(n))

v = list(map(int, input().split()))
x = int(input())

gasit = False
for element in v:
    if element == x:
        gasit = True

if gasit:
    print("DA")
else:
    print("NU")

8. Paritatea unui număr

Algoritmul Paritate: citește n dacă n % 2 = 0 atunci scrie "par" altfel scrie "impar"

Python

n = int(input())

if n % 2 == 0:
    print("par")
else:
    print("impar")

TABELE RECAPITULATIVE ȘI REGULI FUNDAMENTALE

Corespondența pseudocod - Python

Pseudocod	Python	Rol
`citește a`	`a = int(input())`	Citirea de la tastatură
`scrie x`	`print(x)`	Afișarea pe ecran
`x ← valoare`	`x = valoare`	Atribuirea
`dacă c atunci ... altfel ...`	`if c: ... else: ...`	Decizia
`pentru i de la 1 la n`	`for i in range(1, n + 1):`	Repetarea cu număr cunoscut
`cât timp c`	`while c:`	Repetarea cu condiție

Complexitățile și numărul de operații

Complexitate	Exemplu de algoritm	Operații pentru n = 1000
`O(1)`	Formula sumei 1 + 2 + ... + n	1
`O(log n)`	Căutarea binară	aproximativ 10
`O(n)`	Căutarea secvențială, o parcurgere	1000
`O(n^2)`	Două bucle imbricate	1.000.000

Regulile fundamentale ale modulului

Orice problemă începe cu analiza: identifică datele de intrare, de ieșire și de manevră.
Scrie algoritmul în pseudocod înainte de a scrie cod Python.
Atribuirea folosește =, comparația folosește ==.
Structurile Python se termină cu : și au corpul indentat.
Acumulatorii și numărătorii se inițializează cu 0 înainte de buclă.
range(1, n + 1) generează 1, 2, ..., n - al doilea argument este exclusiv.
n % 10 dă ultima cifră, n // 10 o elimină.
La while, condiția trebuie modificată în interiorul buclei, altfel bucla nu se termină.
Testează cu date valide, date invalide și cazuri limită.
Dacă există o formulă matematică, preferă-o: este mai eficientă decât bucla.

Greșelile frecvente și cum le evităm

if n = 5 în loc de if n == 5 - comparația are nevoie de două semne de egal.
Uitarea celor două puncte după if/for/while - fără : structura nu funcționează.
Indentare greșită - liniile din interiorul structurilor trebuie împinse la dreapta.
Acumulator neinițializat - s trebuie pornit cu 0 înainte de buclă.
Buclă infinită - lipsa instrucțiunii care modifică variabila din condiția while.
range(1, n) când vrem 1 ... n - scriem range(1, n + 1).
input() fără conversie - la citirea numerelor folosim int() sau float().
Un singur test - programul se testează cu mai multe categorii de date.

COMPARAȚII CARE TE AJUTĂ SĂ NU CONFUZI CONCEPTELE

for vs while - când folosim fiecare

Ambele repetă un bloc de cod, dar răspund la întrebări diferite:

Criteriu	for	while
Știm câte repetări facem?	Da, dinainte (range)	Nu, depinde de o condiție
Cine controlează oprirea	range() generează valorile	O variabilă pe care o modifici în buclă
Risc de buclă infinită	Mic - se oprește singur	Mare, dacă uiți modificarea
Exemplu tipic	Suma 1 + 2 + ... + n	Citirea notelor până la 0

Aceeași sarcină - suma de la 1 la n - în ambele variante:

for (număr cunoscut de pași)

s = 0
for i in range(1, n + 1):
    s += i
print(s)

while (repetă cât timp condiția e adevărată)

s = 0
i = 1
while i <= n:
    s += i
    i += 1
print(s)

Regulă practică: dacă știi câte repetări faci, alege for; dacă nu știi când te oprești, alege while.

Pseudocod vs Python - același algoritm

Algoritmul „numără câte cifre are n", scris în ambele forme. Observă corespondența aproape 1 la 1:

Algoritmul NumarCifre: citește n cnt = 0 cât timp n > 0 execută cnt = cnt + 1 n = n // 10 scrie cnt

Python

n = int(input())
cnt = 0
while n > 0:
    cnt += 1
    n //= 10
print(cnt)

Observă: fiecare linie de pseudocod are exact o linie Python. De aceea pseudocodul este planul ideal înainte de cod: corectezi algoritmul pe hârtie, nu în program.

= vs == și / vs // vs %

Simbol	Rol	Exemplu
`=`	Atribuirea: pune o valoare într-o variabilă	`x = 5`
`==`	Comparația: verifică egalitatea	`if x == 5:`
`/`	Împărțire reală (rezultat cu virgulă)	`7 / 2` → `3.5`
`//`	Câtul întreg al împărțirii	`7 // 2` → `3`
`%`	Restul împărțirii	`7 % 2` → `1`

Cum te ajută la algoritmi

n % 2 verifică paritatea (restul la împărțirea cu 2);
n % 10 dă ultima cifră a lui n;
n // 10 „taie" ultima cifră și pregătește următoarea;
împreună, n % 10 și n // 10 descompun un număr în cifre.

CE TREBUIE SĂ ȘTII PENTRU TEST

Checklist de pregătire

Bifează fiecare item pe care îl poți explica și rezolva fără să te uiți în lecții:

definesc algoritmul și proprietățile sale: finitudine, claritate, determinism, generalitate, eficiență;
identific datele de intrare, de ieșire și de manevră pentru orice problemă;
enunț cele cinci etape ale elaborării unui program, în ordine;
transform pseudocod în Python și invers: citește, scrie, dacă, pentru, cât timp;
declar variabile și aplic corect tipurile int, float, str, bool și conversiile;
scriu if/elif/else cu condiții corecte (==, nu =) și indentare;
aleg for sau while în funcție de problemă și evit bucla infinită;
calculez suma 1+...+n, suma cifrelor, numărul de cifre, maximul și paritatea;
folosesc funcții pentru modularizare și try/except pentru erori;
estimez complexitatea O(1), O(n), O(n^2) și aleg varianta eficientă;
construiesc tabelul de urmărire a variabilelor și testez cu date valide, invalide și cazuri limită.

EXERCIȚII DE RECAPITULARE CU REZOLVARE

Exercițiul 1: suma numerelor pare

Cerință: se citește n, apoi n numere. Scrie un program care afișează suma numerelor pare citite. Testează și cu un caz în care nu există numere pare.

Rezolvare (Python)

n = int(input())
s = 0
for i in range(n):
    x = int(input())
    if x % 2 == 0:
        s += x
print(s)

De reținut: acumulatorul s se inițializează cu 0 înainte de buclă, iar x % 2 == 0 verifică paritatea. Dacă nu există numere pare, programul afișează corect 0.

Exercițiul 2: câte cifre are n?

Cerință: se citește un număr natural n. Afișează numărul de cifre al lui n. Testează cu cazurile limită 0, 9 și 1000.

Rezolvare (Python)

n = int(input())
if n == 0:
    print(1)
else:
    cnt = 0
    while n > 0:
        cnt += 1
        n //= 10
    print(cnt)

De reținut: n = 0 este un caz limită: bucla while nu se execută deloc, deci trebuie tratat separat, altfel răspunsul ar fi greșit (0 în loc de 1).

Exercițiul 3: medie cu funcție și validare

Cerință: scrie o funcție Python media(lista) care întoarce media notelor dintr-o listă și o funcție valideaza(nota) care verifică dacă o notă este între 1 și 10. Apelează-le pe exemple.

Rezolvare (Python)

def valideaza(nota):
    return 1 <= nota <= 10

def media(lista):
    return sum(lista) / len(lista)

note = [8, 9, 10]
print("Media:", media(note))
print("Nota 11 validă?", valideaza(11))

De reținut: fiecare funcție are o singură sarcină (validare vs calcul), iar 1 <= nota <= 10 este o comparație în lanț, corectă în Python.

GREȘELI FRECVENTE LA TEST

Cum pierzi puncte și cum eviți

Începi direct cu codul, fără pseudocod. La test se punctează și algoritmul: scrie întâi pașii, apoi codul. Un plan corect salvează puncte chiar dacă o linie greșește.
Nu respecți exact formatul cerut. Dacă cerința spune „pe o linie", afișează pe o linie; verifică majusculele, spațiile și semnele din mesaj.
Testezi doar exemplul din cerință. Adaugă cel puțin un caz limită (0, 1, valoare maximă) și un caz „greșit" (dată invalidă) ca să prinzi erorile ascunse.
Nu citești mesajul de eroare. Ultima linie a erorii indică aproape întotdeauna linia de corectat - folosește-o.
Confuzia dintre = și ==, sau range(1, n) în loc de range(1, n + 1). Sunt cele mai frecvente puncte pierdute; verifică-le conștient.
Predai primul rezultat care „merge". Rulează o a doua variantă de date înainte să consideri soluția gata.

Sinteza Modulului 1: Introducere în programare și elaborarea algoritmilor

Gândirea computațională și algoritmul

Etapele elaborării unui program

Reprezentarea algoritmilor

Elementele de bază în Python

Structurile de decizie și repetitive

Proiectarea modulară, erorile și testarea

Eficiența algoritmilor și notația O

1. Suma a două numere

2. Media aritmetică a trei numere

3. Maximul a două și a trei numere

4. Suma 1 + 2 + ... + n

5. Suma cifrelor lui n

6. Numărul de cifre ale lui n

7. Căutarea unui element într-o listă

8. Paritatea unui număr

Corespondența pseudocod - Python

Complexitățile și numărul de operații

Regulile fundamentale ale modulului

Greșelile frecvente și cum le evităm

for vs while - când folosim fiecare

Pseudocod vs Python - același algoritm

= vs == și / vs // vs %

Cum te ajută la algoritmi

Checklist de pregătire

Exercițiul 1: suma numerelor pare

Exercițiul 2: câte cifre are n?

Exercițiul 3: medie cu funcție și validare

Cum pierzi puncte și cum eviți