Numele de variabile greșite (care trebuie bifate) sunt: b (conține operatorul +), d (începe cu o cifră) și f (conține spațiu).
Numele corecte sunt: a, c și e.
Răspuns corect: 15. (Expresia extrage și adună ultimele trei cifre ale numărului.)
Expresia are valoarea True (adevărat).
Justificare: (5≤7)=True and (7<8)=True dă True, iar True or (8%2=1)=False rămâne True.
Expresia are valoarea False (fals).
Justificare: (5%2=0)=False and (10%2=0)=True dă False; (5%2=1)=True and (10%2=1)=False dă False; False or False = False. Expresia are valoarea True dacă și numai dacă variabilele a și b au aceeași paritate.
Valorile lui a și b se interschimbă. Pentru valorile inițiale a=3, b=7 se obține la final a=7, b=3.
Algoritmul interschimbă valorile prin sumă și diferență. Valorile finale: a = 23, b = 7.
Pentru valoarea citită 1234 (b←a%100=34; a←[a/100]=12; c←b*100+a=34*100+12), valoarea afișată este 3412 (ultimele două cifre mutate în față).
Pentru a←3, b←7, b←a+b/2 (=3+3.5=6.5), a←a-b/2*a (=3-6.5/2*3=3-9.75=-6.75).
Valoarea finală a lui a este -6.75.
Instrucțiunea corectă care atribuie lui d media aritmetică a valorilor a, b, c este: d ← a/3 + b/3 + c/3 (echivalentă matematic cu (a+b+c)/3).
Răspuns corect: c. Variantele a, b, d sunt greșite.
Ordinea corectă a atribuirilor pentru a maximiza suma x+y+z este: I, III, II.
Pentru x=1, y=2, z=3 se obțin valorile x=0, y=3, z=5, cu suma 8 (maximul posibil).
Pentru a=3, b=5, c=7, structura alternativă imbricată dă x = 3. (dacă a-[b/2]<0: 3-2=1, fals; altfel dacă a+b-[c/2]<b: 3+5-3=5<5 fals; altfel dacă a%b+c>b: 3+7=10>5 adevărat → x←3.)
O valoare inițială posibilă pentru x astfel încât y să fie 2 la final este x = 5. (Pentru x=5: x>3 adevărat, x<7 adevărat, x%2=0 fals → y←2.)
Simulator pas cu pas care numără de câte ori un termen se divide cu termenul anterior. Pentru datele citite n=6, a=4 și secvența 8, 7, 21, 3, 6, rezultatul final este nr = 1 (doar 8 este divizibil cu 4; restul comparațiilor — 7 cu 8, 21 cu 7, 3 cu 21, 6 cu 3 — nu adaugă la număr conform trace-ului din cod).
Simulator pas cu pas: în bucla pentru i←1,n execută x←x*x, x se ridică la pătrat de n ori. Pentru n=3, x=2 se obține: 2→4→16→256, deci valoarea finală afișată este x = 256.
Simulator pas cu pas al calculului factorialului (f←1; pentru i←1,n: f←f*i). Rezultatul este n!. Pentru valoarea implicită n=6 se obține 6! = 720.
Simulator pas cu pas al calculului puterii (p←1; pentru i←1,n: p←p*x).
Rezultatul este x^n. Pentru valorile implicite n=5, x=2 se obține 2^5 = 32.
Simulator interactiv al algoritmului de dobândă compusă (citește S, n, d; repetă de n ori S ← S + S*d/100; scrie S). Nu are un răspuns unic de validat — utilizatorul introduce S, d și n, iar programul calculează suma finală pas cu pas. Pentru valorile implicite S=1000, d=10%, n=5 ani, rezultatul afișat este 1610.51 lei (1000 → 1100 → 1210 → 1331 → 1464.10 → 1610.51).
Algoritm: i←a, x←0; cât timp i<=b: x←x+i, i←i+1; scrie x (adică suma numerelor de la a la b).
a. Pentru a=1, b=10 valoarea afișată este 55.
b. Perechi (a b) care dau x=22: „4 7" (4+5+6+7=22) sau „-3 7" (−3+…+7=22).
Valoarea inițială corectă a lui x este 5. (Algoritm: d←2; cât timp d<50: x←x*d, d←d*d; scrie x. Se execută pentru d=2, 4, 16 → x se înmulțește succesiv cu 2, 4 și 16, adică ×128; 5×128 = 640.)
Rezultatul afișat este 5. (Algoritmul determină lungimea maximă a unei secvențe în progresie aritmetică din șirul citit: 16, 7, 9, 11, 9, 7, 5, 3, 3, 3, 3, 6, 9, 12, 15, 18, 20 — lgmax = 5.)
Răspuns corect: f. Singurul nume de variabilă corect este Clasa_9A. Sunt greșite: 10x (începe cu cifră), 2B||!2B (conține operatori), Nr elevi (conține spațiu), Șoim (conține diacritice/caracter neacceptat) și 'x' (conține apostrofuri).
Expresiile corecte sunt: b și c. Sunt greșite: „x = 0 and x = 1" (imposibil simultan) și „not (x ≠ 0 or x ≠ 1)".
Se afișează valoarea 2. (Pentru a=7, b=11: a%2=1 adevărat → b>a adevărat → b+a%2=11+1=12, deci condiția „=1" este falsă → se execută ramura altfel „scrie 2".)
1. Afirmații corecte: a, b, d.
2. Pentru n=12 se afișează 8.
3. Cel mai mic și cel mai mare număr pentru care se afișează 16: 16 și 31 (algoritmul afișează cea mai mare putere a lui 2 din intervalul [1, n]).
Secvența (a=b=10; b+=5 → b=15) afișează, pe linii succesive: False (a is b — obiecte diferite); 1 1.5 5 (b//10, b/10, b%10); <class 'float'> (type(a/2)); <class 'bool'> (type(a<=b)); 16 (a + 2*b//5 = 10 + 30//5 = 10+6).
Răspunsul corect este varianta c: (a * b - 2) / (5 * b) – 7 / 2.
Parantezele la numitor (5 * b) sunt obligatorii, altfel Python ar împărți la 5 și apoi ar înmulți cu b (operatori cu prioritate egală, evaluați stânga→dreapta).
Expresia corectă este n // 100 % 10 (echivalent: n % 1000 // 100).
Elimină ultimele două cifre prin // 100, apoi izolează cifra unităților prin % 10 — adică a treia cifră (cea din mijloc).
Valoarea expresiei x - y este 9. (Din condiții: cifra zecilor lui x = cifra unităților lui y, cifra zecilor lui y = cifra unităților lui x, iar cifra zecilor lui x = cifra unităților lui x + 1; rezultă x - y = 9(a-b) = 9·1 = 9, ex.: 21 și 12.)
Expresia corectă: x % d == 0 and y % d == 0 (echivalente acceptate: not(x%d) and not(y%d), sau x%d == y%d == 0). Ambele resturi trebuie să fie 0, legate prin operatorul and.
Singura variantă corectă este: b.
Echivalează S % 2 == 0 and S // 2 >= P (suma pară ȘI jumătatea ≥ P). Varianta „S % 2 == 0 AND S // 2 >= P" este greșită doar pentru că AND e scris cu majuscule (Python cere and).
Singura variantă corectă este: c (9 și 2 sunt prime între ele, iar 9·2=18). Greșite: a (6 și 3 nu sunt prime între ele, ex. n=12), b (folosește // în loc de %) și d (or în loc de and).
Expresia echivalentă este: d.
Greșite: varianta care păstrează or între blocuri; varianta fără paranteze „a <= b or a >= c and a < d" (and are prioritate față de or) și varianta cu inegalități stricte „(a < b or a > c) and a < d".
Singura expresie corectă este: a. (Pentru x = 234 dă 2374)
Varianta corectă este: a, pentru că un număr este în afara reuniunii dacă x <= -10, sau -2 <= x < 50, sau x > 100. Celelalte variante folosesc greșit semnele la margini (x <= 50 sau x >= 100 includ eronat 50, respectiv 100; x < -10 exclude eronat -10).
Asocierile corecte:
numărul de pagini ale unei cărți → <class 'int'>;
dacă un utilizator este logat sau nu → <class 'bool'>;
un mesaj de eroare → <class 'str'>;
prețul unui produs → <class 'float'>.
Variantele corecte (bucle) sunt: b și c.
Nu sunt corecte: a (instrucțiune de control, nu buclă) și d (instrucțiune condițională).
Valorile posibile sunt 7 și 8 (numerele naturale cu nota >= 7 și nota < 9).
La 9 sau mai mult s-ar afișa „Excelent”, iar sub 7 s-ar afișa „Bine” sau „Insuficient”.
Se afișează: 1 2 4 8 16 32 64 128 (primele 8 puteri ale lui 2, pe o singură linie separate prin spațiu).
n trebuie să aibă inițial valoarea 6. Bucla while n > 2 se execută pentru n = 6, 5, 4, 3 (4 iterații), fiecare afișând „##”, adică 4 × 2 = 8 caractere #.
Simulator pas cu pas al algoritmului care calculează suma cifrelor unui număr natural n (s = 0; while n > 0: s += n % 10; n //= 10).
Nu are un răspuns unic — depinde de valoarea introdusă. Exemplu (valoarea implicită n = 375): suma cifrelor = 3 + 7 + 5 = 15, deci se afișează „Suma cifrelor este 15”.
Simulator pas cu pas al algoritmului care construiește oglinditul (răsturnatul) unui număr natural n (oglindit = 0; while n > 0: oglindit = oglindit*10 + n%10; n //= 10).
Nu are răspuns unic — depinde de valoarea introdusă. Exemplu (valoarea implicită n = 3075): oglinditul = 5703, deci se afișează „Oglinditul este 5703”.
Singura variantă corectă este d (izolează prima cifră prin împărțiri întregi succesive la 10).
Celelalte variante sunt greșite: a (elimină doar ultima cifră), b (dă ultima cifră, nu prima) și c (nu se termină / nu extrage prima cifră).
Variantele corecte sunt a și d.
Variantele b (fără inițializare, suprascrie crescător la fiecare pas) și c (n //= 10 doar pe ramura else, buclă potențial infinită) sunt greșite.
a. Pentru n = 32425 și cifra c = 2 se afișează 305.
b. Pentru n = 322245227 și cifra c = 2 se afișează 300007.
Simulator pas cu pas al afișării tuturor divizorilor lui n (afișează 1, apoi fiecare d din 2..n//2 care divide n, apoi n).
Nu are răspuns unic — depinde de n. Exemplu (valoarea implicită n = 24): divizorii afișați sunt 1 2 3 4 6 8 12 24.
Simulator pas cu pas al variantei optimizate de aflare a divizorilor (afișează 1; pentru d cu d*d < n și n % d == 0 afișează perechea d și n//d; dacă d*d == n afișează d; la final n).
Nu are răspuns unic — depinde de n. Exemplu (valoarea implicită n = 36): divizorii afișați sunt 1 2 3 4 6 9 12 18 36.
Simulator pas cu pas al testului de primalitate: afișează „DA” dacă n este prim, „NU” dacă nu este (tratează n < 2 → NU, n == 2 → DA, numerele pare > 2 → NU, apoi verifică divizori impari d cu d*d <= n).
Nu are răspuns unic — depinde de n. Exemplu (valoarea implicită n = 49): 49 = 7 × 7, deci se afișează „NU”.
Simulator pas cu pas al descompunerii lui n în factori primi, afișând fiecare factor prim d și exponentul p (perechi „d p”).
Nu are răspuns unic — depinde de n. Exemplu (valoarea implicită n = 2500): 2500 = 2^2 · 5^4, deci se afișează perechile „2 2” și „5 4”.
Simulator de descompunere în factori primi. Pentru valoarea implicită n = 6408, rezultatul afișat este: 2 3, 3 2, 89 1 (adică 6408 = 2^3 × 3^2 × 89). Programul afișează, pe câte o linie, fiecare divizor prim urmat de exponentul (puterea) lui.
Simulator al algoritmului lui Euclid pentru cmmdc. Pentru valorile implicite n = 121 și m = 4950, rezultatul afișat este: cmmdc = 11.
Răspuns corect: variantele b și d.
Varianta b (d=2; while x%d!=0: d=d+1; print(x//d)) găsește cel mai mic divizor prim și afișează x împărțit la el.
Varianta d (d=x//2; while x%d!=0: d=d-1; print(d)) caută descendent primul divizor.
Programul afișează cel mai mare factor prim al numărului citit.
a. Pentru numărul 720 se afișează 5 (720 = 2^4 × 3^2 × 5, deci factorul prim maxim este 5).
b. Trei valori distincte pentru care programul afișează chiar numărul citit sunt orice trei numere prime distincte > 1, de exemplu 2, 3, 5 (sau 7, 11, 13 etc.) — la un număr prim, factorul prim maxim este numărul însuși.
Programul afișează toți divizorii comuni ai lui a și b mai mari decât 1.
a. Pentru a=70 și b=308 se afișează divizorii comuni: 2, 7 și 14.
b. Pentru a=363 (=3×11^2), astfel încât să se afișeze 11 și 121, b trebuie să fie multiplu de 121 dar NU multiplu de 3; trei exemple distincte: 121, 242, 484 (toate multipli de 121 și nedivizibili cu 3).
Răspuns corect: b („divizorii lui 25”, adică 1 5 25).
La executarea secvenței (n=25; for i in range(1,n+1): if n%i==0: print(i, end=' ')) se afișează divizorii lui 25.
Răspuns corect: variantele b și d.
Varianta b (while n%10==0: n//=10) și varianta d (while n>0: if n%10==0: n//=10 else: break) elimină corect zerourile finale.
Variantele a și c sunt greșite (a - intră în buclă infinită / e incorectă, c - are condiția greșită).
Completarea corectă a spațiilor libere din buclă: rez = rez + p (echivalent p + rez) și p = p * b (echivalent b * p). Astfel se acumulează suma puterilor bazei corespunzătoare celor n cifre egale cu 1.
Cel mai mare număr de două cifre pentru care, după împărțirile succesive la 2, 3 și 5, rezultatul devine 1 este 96 (96 = 2^5 × 3), deci conține doar factorii primi 2 și 3.
Răspuns: 96.
Afirmațiile adevărate sunt: a, b, e, f și g.
Se scrie o funcție cu un parametru care returnează pătratul acestuia. Exemplu corect:
def patrat(x):
return x * x
Sunt acceptate și variantele return x ** 2 sau return pow(x, 2), cu orice nume valid de funcție și de parametru.
Funcțiile corecte sunt c și d.
Varianta c (if n%2==0: return n-2, n; else return n-3, n-1) și varianta d (buclă while care crește b cu 2 cât timp b+2<=n, apoi return b-2, b) returnează corect cele mai mari două numere pare mai mici sau egale cu n.
Varianta b este greșită (instrucțiuni return consecutive inaccesibile), iar varianta a returnează valori greșite / poate da eroare.
Funcțiile corecte sunt a și d.
Varianta a folosește import math și formula grade * math.pi / 180, iar varianta d folosește from math import pi și grade * pi / 180.
Varianta b este greșită (formula inversată: grade*180/math.pi), iar varianta c folosește pi fără import (dă eroare).
Variantele corecte sunt a, b și c.
Varianta a apelează de două ori o funcție simplă, varianta b transmite numărul de iterații ca argument (f(2)), iar varianta c folosește o variabilă globală n=2 pentru bucla for.
Varianta d este greșită — funcția are un parametru obligatoriu (def f(n)), dar este apelată fără argument (f()), deci dă eroare la execuție.
Răspunsuri corecte: a, b și e.
Afirmațiile greșite sunt: c, d și f (formulările cu „întotdeauna”/„complet” sunt false).
Răspunsuri corecte: a și b.
Variantele c (ultima_cifra(x, c) – două argumente) și d (ultima_cifra() – niciun argument) sunt greșite pentru că nu respectă numărul de parametri (unul singur).
Răspuns corect: c.
Numerele întregi se transmit prin valoare (fiind imutabile): în funcție n devine 10+13=23 și se afișează 23, dar variabila globală n rămâne 10, deci print(n) afișează 10.
Răspuns corect: „Fals”.
Afirmația este falsă, pentru că o variabilă locală este vizibilă doar în interiorul funcției în care a fost definită.
Trebuie două numere distincte de trei cifre (100–999) care să fie pătrate perfecte (pentru care r*r == x). Exemplu de răspuns corect: 121 (=11²) și 144 (=12²). Alte variante valide: 100, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961 — orice două distincte dintre acestea.
Răspuns corect: „6.0 6 7 6”. round(6.5, 0) → 6.0 (rotunjire bancară la par, tip float), math.floor(6.5) → 6, math.ceil(6.5) → 7, int(6.5) → 6 (trunchiere).
Corectă este doar varianta b (cea care folosește împărțirea întreagă n //= 10 și are return p).
Varianta a este greșită (folosește /= — împărțire reală). Varianta c cere doi parametri la apel și nu are return. Varianta d este greșită, deoarece inițializează p = n % 10, deci dacă numărul se termină în 0, p devine 0 și anulează produsul.
Răspuns corect: „0 1 2 5 12 29 70” (primii 7 termeni ai șirului lui Pell, fiecare termen nou obținut prin 2*b + a).
Răspuns corect: b.
Fișierul este deschis cu modul "r" (citire), iar apelul write() va genera o eroare (io.UnsupportedOperation).
Răspuns corect: c. Metoda write() acceptă doar șiruri de caractere; transmiterea numărului întreg 25 produce o eroare de tip TypeError.
Răspuns corect: b. Parcurgerea obiectului fișier cu bucla for citește nativ linie cu linie, iar end="" evită liniile goale suplimentare.
Răspuns corect: c. Modul "w" trunchiază fișierul existent (șterge conținutul vechi). Pentru păstrarea datelor și adăugare la final se folosește modul "a".
Răspuns corect: c (persistența datelor).
În spațiul liber se scrie „str”, adică f.write(str(13)). Funcția str() convertește numărul întreg 13 în șirul "13", deoarece write() nu acceptă direct numere întregi.
Răspuns corect: a.
Blank 1 (modul de deschidere): "w". Blank 2 (conversia liniei): int(linie) — se acceptă și int(linie.strip()) sau int(linie.split()[0]). Blank 3 (scrierea valorii pare urmată de spațiu): fout.write(str(nr) + " ") — se acceptă și fout.write(f'{nr} '), sau print(nr, end=" ", file=fout) / print(str(nr), end=" ", file=fout) (ordinea argumentelor end și file poate fi inversată).
Blank 1 (deschidere fișier): open("incasari.txt", "r") — se acceptă și open("incasari.txt"). Blank 2 (divizarea șirului): linie.split() — se acceptă și linie.split(" "). Blank 3 (conversia la întreg): int(incasare).
Din lista [2, 4, 3, 6, 5, 9, 12, 14, 17], după ștergerea numerelor pare rămâne [3, 5, 9, 17]. Predecesorul lui 3: nu există (3 este primul element) — se completează cu „-” (sau „nu există” / „nu are”). Succesorul lui 3: „5”.
Configurația finală a listei este [15, 7201, 20, 1003, 12, 5, 8, 7]. Regula: numerele cu cel puțin două cifre se pun la începutul listei, cele cu o singură cifră la final, iar duplicatele se ignoră. Urmărire: 5→[5]; 12→[12,5]; 1003→[1003,12,5]; 20→[20,1003,12,5]; 1003 duplicat, ignorat; 7201→[7201,20,1003,12,5]; 8→[7201,20,1003,12,5,8]; 15→[15,7201,20,1003,12,5,8]; 8 duplicat, ignorat; 7→[15,7201,20,1003,12,5,8,7].
Pornind de la lista [20, 40, 60, 80], scopul este să se obțină [80, 60, 40, 20] folosind operațiile Del(poz) (șterge elementul de pe poziția poz) și Ad(x, poz) (inserează valoarea x pe poziția poz). O soluție validă (indexare de la 1): Del(4); Ad(80,1); Del(4); Ad(60,2); Del(4); Ad(40,3) → lista devine [80,60,40,20]. O altă soluție (ștergere completă și readăugare, indexare de la 1): Del(1); Del(1); Del(1); Del(1); Ad(80,1); Ad(60,2); Ad(40,3); Ad(20,4). Orice succesiune care aduce lista la [80, 60, 40, 20] este acceptată (funcționează cu indexare de la 0 sau de la 1).
Secvența de operații pe coadă: Ad(7), Ad(3), Del, Ad(10), Ad(5), Del, Ad(1). Stările succesive: (7); (7,3); (3) după Del; (3,10); (3,10,5); (10,5) după Del; (10,5,1) final. La final coada este (10, 5, 1): primul element (începutul cozii) = 10, ultimul element (sfârșitul cozii) = 1, lungimea cozii = 3 elemente.
Stiva după introducerea numerelor 11, 31, 2, 4, 10, 100, 34 are în vârf 34. Se extrag elemente până când vârful este pătrat perfect: se extrage 34, iar vârful devine 100 (=10², pătrat perfect), deci extragerile se opresc. b) Elementul din vârful stivei la final: 100. c) Dimensiunea stivei la final: 6 elemente (11, 31, 2, 4, 10, 100).
Răspuns: 6 operații. Valoarea comună 4 se aduce cel mai repede: din stivă (vârf 349, 12, 34, 4, ...) sunt necesare 3 extrageri (349, 12, 34) pentru ca vârful să devină 4; din coadă (început 3, 21, 2, 4, 5) sunt necesare 3 extrageri (3, 21, 2) pentru ca începutul să devină 4. Total: 3 + 3 = 6.
Inițial: stiva S = [2, 4, 6] (vârf 6), coada Q = [1, 3, 5, 7, 9]. După secvența DelAd(S,Q), DelAd(S,Q), DelAd(Q,S), DelAd(Q,S), DelAd(S,Q): valoarea din vârful stivei S la final = 1; valoarea de la începutul cozii Q la final = 5; valoarea de la sfârșitul cozii Q la final = 3. (S final = [2, 1] cu vârf 1; Q final = [5, 7, 9, 6, 4, 3].)
Demonstrație interactivă (fără verificare a răspunsului elevului). Rezultatele exemplelor: [1, "2", 3] < [1, 2, 3] → apare TypeError (la poziția 1 nu se pot compara str "2" și int 2); [1, "2", 3] == [1, 2, 3] → False; [1, 2] < [1, 2, 5] → True (lista mai scurtă, prefix, este mai mică); [1, 4, 9] > [1, 3, 10] → True (prima diferență, 4 > 3, decide). Principiu: listele se compară element cu element de la stânga la dreapta, prima pereche de elemente diferite stabilind rezultatul.
Răspuns corect: c.
Celelalte variante sunt false: dimensiunea unei liste POATE fi modificată; indexarea începe de la 0 (nu de la 1); listele POT conține elemente de tipuri diferite.
Se afișează: [1, 2, 3] [3, 4, 1, 2, 3] [1, 2, 3, 3, 4].
Explicație: lista1=[1,2,3] rămâne neschimbată; lista3 = lista1 + lista2 = [1,2,3,3,4] (operatorul + creează o listă nouă); lista2 += lista1 modifică lista2 în [3,4,1,2,3].
Completările corecte: condiția if numere[0] == numere[1] (acceptat și numere[1]==numere[0] sau numere[0]-numere[1]==0); indexul modificat este [1] (al doilea element); valoarea atribuită este 2*numere[0] (sau numere[0]*2). Deci: if numere[0] == numere[1]: numere[1] = 2*numere[0].
Expresia corectă: [1, 2] * 4 (sau echivalent 4 * [1, 2]), care produce lista [1, 2, 1, 2, 1, 2, 1, 2]. Se acceptă și forma cu atribuire, ex. lista = [1, 2] * 4.
Răspunsul corect este metoda count, varianta b. (index caută poziția unui element, len dă lungimea totală a listei, pop șterge un element; count returnează numărul de apariții ale unei valori.)
Se afișează: [10, 16, 15, 20, 15, 25]. Explicație: numere.index(15) returnează 1 (prima apariție a lui 15), iar numere.insert(1, 16) inserează valoarea 16 pe poziția 1, deplasând restul elementelor la dreapta.
Răspuns corect: b.
Metoda remove(20) caută valoarea 20, care nu există în listă, deci Python ridică ValueError. Celelalte variante nu produc erori: append(40) adaugă la final; insert(5, 10) cu index mai mare decât lungimea adaugă la final (fără eroare); sort() ordonează lista.
Completare corectă (parcurgere directă a elementelor): for x in numere: print(x, end='#') — prima casetă o variabilă validă (ex. x), a doua casetă numere, a treia casetă x, end='#'. Variantă alternativă (parcurgere prin indici): for i in range(len(numere)): print(numere[i], end='#'). Rezultatul afișat: 4#7#2#9#.
1) „Instrucțiunea for poate fi folosită pentru a parcurge elementele unei liste.” → Adevărat.
2) „Parcurgerea unei liste se poate face doar folosind indici.” → Fals (se poate parcurge și direct prin elemente: for x in lista).
3) „Parcurgerea unei liste nu poate fi realizată cu ajutorul instrucțiunii while.” → Fals (se poate folosi un contor de index cu while).
4) „Media aritmetică a elementelor unei liste poate fi calculată cu o singură parcurgere a listei.” → Adevărat.
Simulator pas cu pas, fără răspuns unic de grilă: rulează un algoritm care generează numere palindromice și le poziționează într-o listă. Codul reține în listă doar numerele a căror poziție (indice) se află în intervalul [a, b], iar la final afișează lista inversată. Pentru valorile implicite a=25, b=29, algoritmul construiește secvența pe pozițiile din interval și o afișează cu funcția reverse(). Este o demonstrație a mecanismului de generare/poziționare, nu un exercițiu cu variantă corectă.
Simulator pas cu pas. Funcția alergare(n,x,y,z) construiește lista caloriilor pe zile: dist = x + i*y, calorii = dist*z. Pentru valorile implicite n=4, x=2, y=3, z=1 rezultă calorii = [2, 5, 8, 11]. Apoi se însumează caloriile de la ultima zi spre început până se atinge pragul k=16: 11 (ziua 4) + 8 (ziua 3) = 19 ≥ 16.
Rezultat afișat: numărul minim de zile = 2, iar caloriile consumate în aceste zile sunt 8 și 11.
Simulator pas cu pas. Se generează termenii Fibonacci ≤ n și se descompune n ca sumă cu număr minim de termeni Fibonacci (de la cel mai mare termen). Pentru valoarea implicită n=200, termenii sunt [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144], iar descompunerea afișată este: 200 = 144 + 55 + 1.
Răspuns corect: d. Prima buclă generează [10, 20, 30, 40, 50]; a doua buclă (i de la 1 la 4) face lista[i] -= lista[i-1] cumulativ: lista[1]=20-10=10, lista[2]=30-10=20, lista[3]=40-20=20, lista[4]=50-20=30.
Se afișează [2, 6, 12, 42, 56, 72]. Lista inițială este [0, 2, 6, 12, 20, 30, 42, 56, 72, 90] (i*i+i), iar bucla while elimină toate numerele divizibile cu 10 (0, 20, 30, 90), rămânând 2, 6, 12, 42, 56, 72.
Se completează cu expresia i * 20 + 7 (echivalent: 20*i+7 / 7+i*20 / 7+20*i). Pentru i de la 0 la 9 generează [7, 27, 47, 67, 87, 107, 127, 147, 167, 187].
Răspuns corect: a.
În Python, for i in range(len(lista)) evaluează len(lista)=3 o singură dată la început, deci bucla rulează exact 3 pași (i=0,1,2) chiar dacă lista crește: se adaugă lista[0]*2=2, lista[1]*2=4, lista[2]*2=6.
Simulator vizual al sortării prin selecția minimului; nu are răspuns de grilă. La final lista introdusă este ordonată crescător. Pentru lista implicită 23, 78, 45, 18, 32, 56, 64, 27, 51 rezultatul sortat este [18, 23, 27, 32, 45, 51, 56, 64, 78].
Simulator vizual al sortării prin metoda bulelor (bubble sort); nu are răspuns de grilă. La final lista este ordonată crescător. Pentru lista implicită 23, 78, 45, 18, 32, 56, 64, 27, 51 rezultatul sortat este [18, 23, 27, 32, 45, 51, 56, 64, 78].
Simulator vizual al sortării prin numărare (listă de frecvențe), pentru valori între 0 și 9; nu are răspuns de grilă. Se numără aparițiile fiecărei valori în vectorul nr, apoi se reconstruiește lista sortată. Pentru lista implicită 2, 5, 6, 2, 3, 8, 8, 4 rezultatul sortat este [2, 2, 3, 4, 5, 6, 8, 8].
Răspuns corect: b.
Pentru o listă cu N=6 elemente, sortarea prin selecția minimului face 5+4+3+2+1 = 15 comparații (formula N*(N-1)/2 = 6*5/2 = 15).
Răspunsuri corecte: a și c. Sunt cazuri cu interval mic și bine definit de valori.
Variante greșite: b și d (interval de valori uriaș).
Răspuns corect: d.
Funcția care parcurge i de la 0 la len(L)-1 și returnează False imediat ce găsește L[i] > L[i+1], altfel returnează True. Varianta a verifică descrescător, varianta b provoacă IndexError (range(len(L)) cu L[i+1]), iar varianta c verifică descrescător.
a) Pentru L=[2,0,1,4,6,3], după apel L devine [0, 1, 2, 4, 3, 6] (o singură parcurgere care împinge maximul spre dreapta). b) Orice listă deja ordonată crescător (cu cel puțin 2 elemente), de exemplu [1, 2, 3, 4] – nu se face nicio interschimbare. c) Orice listă neordonată care după o singură parcurgere devine crescătoare, de exemplu [3, 1, 2, 4] → devine [1, 2, 3, 4] (elementul mare din stânga „coboară” la locul lui).
a) Pentru x=20341 se afișează 14302 (programul afișează cifrele în ordine inversă, adică oglinditul numărului).
b) Orice număr palindrom (egal cu oglinditul său), de exemplu 121, 55, 404, sau un număr de o singură cifră – pentru acesta șirul afișat este identic cu cel citit.
Răspuns corect: c.
Pentru L=[1,3,7], L.append(7) mărește lista cu un element pe ultima poziție, rezultând [1, 3, 7, 7] (listele Python acceptă valori duplicate, nu apare eroare).
Răspuns corect: d.
Bucla parcurge lista L = [2, 4, 6, 8, 7, 12, 13] și adună doar elementele divizibile cu 4 (x % 4 == 0): 4 + 8 + 12 = 24. Se va afișa valoarea 24.
Răspuns corect: b.
Lista nr = [2, 0, 1, 3, 0, 2] este un vector de frecvență, deci lista ordonată reconstruită este L = [0, 0, 2, 3, 3, 3, 5, 5]. Elementul de pe poziția 5 (indexare de la 0) este 3.
Răspuns corect: c. Este complexitatea în cazul cel mai defavorabil pentru algoritmul Bubble Sort, deoarece numărul total de comparații este n·(n−1)/2, al cărui termen dominant este n².
Răspuns corect: [7, 5, 2, 9, 3, 1].
Programul extrage cifrele numărului 715329 de la coadă spre început; la iterațiile impare inserează cu insert(i, cifra), iar la cele pare cu insert(0, cifra), rezultând lista finală [7, 5, 2, 9, 3, 1].