Ce vei învăța astăzi?
Aceasta este lecția de evaluare finală sumativă (testul final care verifică toate competențele clasei a IX-a): analizăm structura testului final, baremul de notare (grija de notare, punctele acordate pe componente) și strategiile de rezolvare, apoi rezolvăm o problemă integrată model, exact de tipul celor din evaluare.
Structura testului final
Definiție: Evaluarea finală sumativă verifică toate competențele dobândite în clasa a IX-a. Testul are două subiecte: Subiectul I - teorie (5 întrebări, 30 de puncte) și Subiectul II - programare (3 probleme Python, 70 de puncte). Totalul de 100 de puncte se transformă în nota finală împărțind la 10.
| Subiect | Conținut | Punctaj |
|---|---|---|
| Subiectul I | Teorie: subprograme, funcții predefinite, fișiere, liste | 30p (5 întrebări × 6p) |
| Subiectul II - P1 | Funcție proprie + aplicare pe o listă | 20p |
| Subiectul II - P2 | Funcții cu liste: medie, min, max, prelucrări | 25p |
| Subiectul II - P3 | Problemă integrată cu fișiere text | 25p |
Reține: testul este susținut în scris, cu penarul pe bancă, fără materiale ajutătoare. Enunțurile cer întotdeauna programe complete: citire, prelucrare, afișare sau salvare.
Baremul de notare
Baremul acordă punctaje pe componente ale programului, nu doar pentru rezultatul final. Un program corect, dar scris liniar, primește puncte pentru logica corectă; un program modular (cu funcții) primește punctajul complet.
- Funcția corectă: antetul cu def, parametrii, corpul și return-ul - cea mai mare parte a punctajului.
- Citirea datelor: int(input()), map(int, input().split()), fișierele deschise corect.
- Parcurgerea și prelucrarea: bucle for/while, condiții, contoare (variabile care numără) și acumulatori (variabile care adună valori).
- Afișarea sau salvarea: print cu formatul cerut sau write în fișier urmat de close().
- Modularizarea: despărțirea logicii în funcții aduce punctaj suplimentar la toate problemele.
Sfaturi: citește enunțul integral, subliniază datele de intrare și de ieșire, scrie întâi funcțiile, apoi programul principal, testează pe exemplul dat și verifică fișierele închise cu close().
Problema integrată model - palindroame în fișier
Problema model combină funcții proprii (oglindit și palindrom), liste (parcurgerea valorilor) și fișiere text (salvarea palindroamelor). Este structura tipică a ultimei probleme din Subiectul II.
def oglindit(n):
rezultat = 0
while n > 0:
rezultat = rezultat * 10 + n % 10
n = n // 10
return rezultat
def palindrom(n):
return n == oglindit(n)
n = int(input())
v = list(map(int, input().split()))
f = open("palindroame.txt", "w")
contor = 0
for x in v:
if palindrom(x):
contor = contor + 1
f.write(str(x) + "\n")
f.close()
print(contor)
Observă: fiecare componentă este punctată separat: funcția oglindit (descompunerea cu while, % și //), funcția palindrom (compararea), parcurgerea listei, scrierea în fișier și afișarea contorului.
Aprofundare
Tabelul de urmărire în timpul testului: pentru o funcție cu descompunere în cifre, notează valorile pas cu pas pe o foaie de lucru: pentru n = 123, oglinditul devine 3, apoi 32, apoi 321. Tabelul dezvăluie imediat erorile de logică și demonstrează profesorului că înțelegi mecanismul.
- Cazuri limită obligatorii: n = 0 (bucla while nu se execută, oglinditul rămâne 0), n = 1 (palindrom), 1001 (palindrom cu zerouri în interior), 1230 (nu este palindrom).
- Repartizarea efortului: în cadrul timpului de lucru, începe cu întrebările de teorie (sunt rapide), continuă cu problemele simple și lasă problema integrată la final, când ai deja încredere în programele tale.
- Greșelile recurente la evaluare: lipsa int(input()), print în loc de return, modul "w" în loc de "r" (șterge datele), uitarea lui close(), contoare neinițializate, condiții inversate la min/max.
- Verificarea finală: rulează programul pe exemplul din enunț, apoi pe o valoare extremă; verifică fișierul de ieșire în editor; asigură-te că rezultatul afișat respectă formatul cerut.
- Caz particular: la problema integrată, punctajul pentru fișier se acordă doar dacă fișierul este închis cu close() și conține exact datele cerute în enunț.
Exercițiu de completare
Completează enunțul cu cuvintele potrivite:
Testul final are două subiecte: Subiectul I - ______ (30 de puncte) și Subiectul II - ______ (70 de puncte). Totalul de 100 de puncte se transformă în notă împărțind la ______. Pentru a trimite o valoare înapoi dintr-o funcție folosim ______.
Bancă de cuvinte:
Exercițiu de completare
Completează enunțul cu cuvintele potrivite:
În Subiectul II, cea mai mare parte a punctajului se acordă pentru funcția ______. Datele se citesc cu ______(input()), iar la o problemă cu fișiere, rezultatele se scriu cu ______() și fișierul se închide cu ______().
Bancă de cuvinte:
Test de înțelegere
Test rapid - evaluarea finală:
1. Din câte puncte este format Subiectul II (programare)?
2. Ce face funcția oglindit(123)?
3. Cum se transformă cele 100 de puncte ale testului în notă?
PbInfo - Simulare: oglinditul numerelor prime
Enunț:
Cerință: Se citește o listă de numere. Folosind funcțiile prim(n) și oglindit(n), să se afișeze pentru fiecare număr prim din listă oglinditul său și câte astfel de numere există.
Date de intrare:
Programul citește de la tastatură elementele listei, pe o singură linie.
Date de ieșire:
Programul va afișa pe linii separate oglinditul fiecărui număr prim, iar pe ultima linie numărul de numere prime.
Restricții și precizări:
Valorile citite sunt numere naturale cu cel mult 4 cifre.
Exemplu:
Intrare:
12 7 23 4
Ieșire:
7 32 2
Cum gândim soluția:
- Definim funcția prim(n) și funcția oglindit(n)
- Parcurgem lista și verificăm primalitatea fiecărui element
- Pentru numerele prime afișăm oglinditul și numărăm
- Afișăm contorul pe ultima linie
Scrie soluția în Python:
Soluție corectă:
def prim(n):
if n < 2:
return False
for i in range(2, n):
if n % i == 0:
return False
return True
def oglindit(n):
rezultat = 0
while n > 0:
rezultat = rezultat * 10 + n % 10
n = n // 10
return rezultat
v = list(map(int, input().split()))
contor = 0
for x in v:
if prim(x):
print(oglindit(x))
contor = contor + 1
print(contor)
Ce învățăm: două funcții proprii colaborând cu o parcurgere de listă reproduc exact modelul cerut la Subiectul II.
PbInfo - Simulare: raportul în fișier
Enunț:
Cerință: Se citește o listă de numere. Să se calculeze media aritmetică a elementelor și să se scrie în fișierul "raport.txt" câte elemente sunt mai mari decât media și câte sunt mai mici sau egale cu media.
Date de intrare:
Programul citește de la tastatură elementele listei, pe o singură linie.
Date de ieșire:
Programul va crea fișierul "raport.txt" cu două linii: numărul elementelor peste medie și numărul elementelor cel mult egale cu media.
Restricții și precizări:
Valorile citite sunt numere naturale cu cel mult 4 cifre, iar lista are cel puțin un element.
Exemplu:
Intrare:
5 9 3 7
Ieșire:
2 2
Cum gândim soluția:
- Calculăm media cu sum / len
- Parcurgem lista și comparăm fiecare element cu media
- Numărăm elementele peste medie și pe celelalte
- Scriem cele două contoare în fișier cu write și închidem cu close()
Scrie soluția în Python:
Soluție corectă:
v = list(map(int, input().split()))
media = sum(v) / len(v)
peste = 0
cel_mult = 0
for x in v:
if x > media:
peste = peste + 1
else:
cel_mult = cel_mult + 1
f = open("raport.txt", "w")
f.write(str(peste) + "\n")
f.write(str(cel_mult) + "\n")
f.close()
Ce învățăm: comparația fiecărui element cu media și salvarea rezultatelor în fișier verifică integrarea listelor cu fișierele text.
Exercițiul Practic: Simularea evaluării finale
Sarcini de lucru
Rezolvă cele două probleme de tipul Subiectului II, respectând baremul: funcții, liste, fișiere
Sarcina 1 (simulare Subiectul II - P1): Numărul de cifre
Cerință: Scrie o funcție numar_cifre(n) care întoarce numărul de cifre ale lui n (fără a folosi conversia în șir), apoi un program care citește o listă și afișează câte elemente au un număr par de cifre.
Soluție:
def numar_cifre(n):
contor = 0
while n > 0:
contor = contor + 1
n = n // 10
return contor
v = list(map(int, input().split()))
rezultat = 0
for x in v:
if numar_cifre(x) % 2 == 0:
rezultat = rezultat + 1
print(rezultat)
Verifică: descompunerea cu while și // numără cifrele fără conversii, iar programul filtrează elementele cu număr par de cifre.
Sarcina 2 (simulare Subiectul II - P3): Extremele în fișier
Cerință: Scrie un program complet care citește o listă de numere, determină minimul și maximul cu funcții proprii și le scrie în fișierul "extreme.txt", câte unul pe linie, apoi afișează diferența dintre ele.
Soluție:
def minim(v):
m = v[0]
for x in v:
if x < m:
m = x
return m
def maxim(v):
m = v[0]
for x in v:
if x > m:
m = x
return m
v = list(map(int, input().split()))
f = open("extreme.txt", "w")
f.write(str(minim(v)) + "\n")
f.write(str(maxim(v)) + "\n")
f.close()
print(maxim(v) - minim(v))
Verifică: cele două funcții parcurg lista cu comparații, iar rezultatele ajung atât în fișier, cât și pe ecran, exact ca la barem.