Erori Algoritmi și structuri de date explicate: ce înseamnă și cum le repari
Mesajele de eroare Algoritmi și structuri de date pe care le primești cel mai des, fiecare explicat pe înțeles: ce înseamnă, de ce apare, cod greșit lângă cod corect și cum o repari. Înveți de la zero cu Curs Algoritmi pentru interviuri: primele 2 lecții sunt gratuite.
Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
- 151erori
- 10capitole
- 75ușor
- 65mediu
- 11greu
Aici găsești erorile pe care le primești când implementezi algoritmi și structuri de date în Python: RecursionError la recursivitate fără caz de bază, IndexError la căutarea binară și la două pointere, KeyError la grafuri, heapq cu elemente care nu se pot compara, bucle infinite oprite de limita de timp, dar și rezultatele greșite care nu dau nicio eroare: off-by-one, liste goale în backtracking, argumente implicite mutabile, matrice cu rânduri comune. Fiecare pagină explică pe înțeles ce înseamnă mesajul, de ce apare, cu cod greșit lângă cod corect, cum îl repari și cum îl eviți.
Erorile sunt grupate pe capitole, ca în cursul de algoritmi: recursivitate, tablouri, căutare binară, dicționare, stive și cozi, arbori, grafuri, programare dinamică și capcanele limbajului. Caută mesajul exact pe care l-ai primit sau simptomul pe care îl vezi, citește cauzele, apoi repară codul direct în pagină, în secțiunea „Repară tu”, și rulează-l ca să vezi că merge.
Recursivitate și backtracking
RecursionError: maximum recursion depth exceeded Funcția recursivă s-a apelat de prea multe ori fără să se oprească, iar Python a depășit limita de aproximativ 1000 de apeluri imbricate. Adaugă un caz de bază (de exemplu if n <= 1: return 1) și verifică dacă fiecare apel se apropie de el. Explicația completă → Mediu Repară tu TypeError: unsupported operand type(s) for +: 'int' and 'NoneType' Ai adunat un număr cu rezultatul unei funcții care a returnat None: de obicei o funcție recursivă care, într-o ramură, face apelul recursiv fără return în fața lui. Pune return pe fiecare ramură a funcției. Explicația completă → Mediu Repară tu UnboundLocalError: cannot access local variable 'numar' where it is not associated with a value O funcție interioară (de obicei un dfs sau backtrack definit în altă funcție) modifică cu += o variabilă a funcției din afară. Python o tratează ca variabilă locală nouă, fără valoare. Declar-o cu nonlocal numar sau folosește o listă / returnează valoarea. Explicația completă → Mediu Repară tu Backtracking-ul returnează liste goale: [[], [], []] Ai adăugat în rezultat chiar lista de lucru (rezultat.append(drum)), nu o copie a ei. La final backtracking-ul golește lista, deci toate intrările arată goale. Adaugă o copie: rezultat.append(drum[:]) sau list(drum). Explicația completă → Ușor Repară tu TypeError: merg() missing 1 required positional argument: 'drum' Ai apelat funcția cu mai puține argumente decât are în definiție. În recursivitate apare când adaugi un parametru nou (drum, vizitat, memo) la def, dar uiți să-l treci și în apelul recursiv. Trimite toate argumentele la fiecare apel sau dă parametrului o valoare implicită sigură. Explicația completă → Ușor Repară tu TypeError: suma() takes 1 positional argument but 2 were given Ai apelat funcția cu mai multe argumente decât acceptă definiția ei. În algoritmi apare când apelul recursiv trimite un indice sau un acumulator pe care def nu îl are, sau la metode fără self. Adaugă parametrul în def sau scoate argumentul în plus din apel. Explicația completă → Mediu Repară tu SyntaxError: no binding for nonlocal 'contor' found Ai scris nonlocal contor într-o funcție interioară, dar funcția exterioară nu are nicio variabilă contor. nonlocal leagă doar de o variabilă care există deja într-o funcție care o conține. Creează contor = 0 în funcția exterioară înainte de def-ul interior sau folosește global pentru o variabilă de modul. Explicația completă → Mediu Repară tu Backtracking fără drum.pop(): drumul se lungește și lipsesc soluții Ai adăugat elementul în drum înainte de apelul recursiv, dar nu l-ai scos după. Drumul crește la fiecare ramură și nu mai are lungimea cerută. Pune drum.pop() imediat după apelul recursiv, ca să anulezi alegerea înainte de următoarea. Explicația completă → Mediu Repară tu Permutările ies duplicate când lista are elemente care se repetă Backtracking-ul tratează cele două litere A din „AAB” ca elemente diferite, deci fiecare ordine apare de mai multe ori. Sortează elementele și sari peste un element egal cu cel dinaintea lui la același nivel: if i > 0 and ramase[i] == ramase[i - 1]: continue. Explicația completă → Mediu Repară tu Generatorul recursiv nu produce rezultatele din apelurile interioare (lipsește yield from) Un apel recursiv la un generator doar creează un generator nou, care nu rulează dacă nu-l parcurgi. Scrie yield from functie(...) în loc de simplul apel functie(...), ca valorile din apelul interior să ajungă la apelant. Explicația completă → Ușor Repară tu TypeError: can only concatenate list (not "int") to list Ai încercat să lipești un număr la o listă cu +, de obicei drum + nod într-un backtracking. Operatorul + între liste cere o listă și în dreapta: scrie drum + [nod], sau folosește drum.append(nod) urmat de drum.pop(). Explicația completă → Tablouri, două pointere și ferestre
IndexError: list index out of range la lista[i + 1] Compari fiecare element cu următorul (lista[i] și lista[i + 1]), dar bucla merge până la ultimul element, care nu are un următor. Oprește bucla cu un pas mai devreme: for i in range(len(lista) - 1). Explicația completă → Ușor Repară tu IndexError: list index out of range la două pointere Pointerul din dreapta a pornit de la len(lista) în loc de len(lista) - 1, sau unul din pointeri a ieșit din listă fără ca bucla să se oprească. Pornește cu dreapta = len(lista) - 1 și pune condiția stanga < dreapta în while. Explicația completă → Ușor Repară tu IndexError: list index out of range la parcurgerea unei matrice Ai inversat numărul de rânduri cu numărul de coloane (sau i cu j) la o matrice care nu e pătrată. len(grila) e numărul de rânduri, len(grila[0]) e numărul de coloane, iar accesul se face mereu grila[rand][coloana]. Explicația completă → Mediu Repară tu IndexError: list index out of range după del lista[i] în buclă Ștergi elemente din listă în timp ce o parcurgi cu for i in range(len(lista)). Lista se scurtează, dar range-ul a fost calculat la început, așa că i ajunge dincolo de capăt. Construiește o listă nouă cu elementele păstrate sau parcurge lista de la coadă. Explicația completă → Ușor Repară tu TypeError: cannot unpack non-iterable NoneType object Ai scris a, b = functie(...), dar funcția a returnat None, de obicei pentru că nu a găsit perechea căutată și s-a terminat fără return. Returnează explicit ceva pe toate drumurile și verifică rezultatul înainte să-l despachetezi. Explicația completă → Ușor Repară tu ValueError: max() iterable argument is empty Ai apelat max() (sau min()) pe o listă goală, deci nu există un maxim. Tratează lista goală înainte (if not lista: return ...) sau dă-i lui max o valoare implicită: max(lista, default=0). Explicația completă → Mediu Repară tu Fereastra glisantă sare peste ultima fereastră (off-by-one la range) O listă cu n elemente are n - k + 1 ferestre de lungime k, deci bucla trebuie să fie range(len(lista) - k + 1). Cu range(len(lista) - k) ultima fereastră nu e verificată, iar rezultatul e greșit fără nicio eroare. Explicația completă → Ușor Repară tu ValueError: list.remove(x): x not in list Ai cerut ștergerea unei valori care nu (mai) e în listă: lista.remove(x) caută valoarea, nu poziția, și aruncă eroare dacă nu o găsește. Verifică înainte cu if x in lista sau folosește un set / un Counter pentru elementele disponibile. Explicația completă → Ușor Repară tu IndexError: list assignment index out of range Ai scris rezultat[i] = valoare pe o poziție care nu există încă în listă. O listă Python nu crește singură la atribuire. Creează lista cu lungimea potrivită (rezultat = [0] * n) sau adaugă elementele cu append. Explicația completă → Ușor Repară tu ValueError: too many values to unpack (expected 2, got 3) Ai mai puține variabile în stânga decât valori în elementul pe care îl despachetezi: for u, v in muchii, dar fiecare muchie e (u, v, cost). Pune atâtea variabile câte valori are fiecare element (for u, v, cost in muchii) sau folosește _ pentru cele de care nu ai nevoie. Explicația completă → Ușor Repară tu TypeError: 'str' object does not support item assignment Textele (str) în Python nu se pot modifica pe loc, deci s[i] = 'x' nu e permis. Transformă textul în listă (litere = list(s)), modifică lista, apoi refă textul cu ''.join(litere). Explicația completă → Ușor Repară tu TypeError: object of type 'NoneType' has no len() Variabila pe care o măsori cu len() e None, nu o listă. Cel mai des ai scris lista = lista.sort() (sau .reverse(), .append()), iar aceste metode modifică lista pe loc și returnează None. Scrie doar lista.sort() sau folosește lista = sorted(lista). Explicația completă → Ușor Repară tu TypeError: sequence item 0: expected str instance, int found Ai dat lui join() o listă de numere, dar join lipește doar texte. Transformă fiecare element în text înainte: ' '.join(map(str, nums)) sau ', '.join(str(x) for x in nums). Explicația completă → Mediu Repară tu Kadane returnează 0 pentru o listă doar cu numere negative Ai pornit maximul (sau suma curentă) de la 0, iar când toate numerele sunt negative, nicio secvență nu trece de 0. Pornește de la primul element: cel_mai_bun = curent = nums[0], apoi curent = max(x, curent + x) pentru restul. Explicația completă → Mediu Repară tu Suma pe interval cu sume prefix iese greșită (prefix[j] - prefix[i] fără +1) Cu prefix[k] = suma primelor k elemente, suma de la i la j inclusiv este prefix[j + 1] - prefix[i]. Dacă scrii prefix[j] - prefix[i], pierzi elementul j; dacă scrii prefix[j] - prefix[i - 1] cu altă convenție, pici la i = 0. Explicația completă → Ușor Repară tu TypeError: must assign iterable to extended slice Ai atribuit un singur număr unei felii de listă, de exemplu lista[2:5] = 0. O felie se înlocuiește doar cu o colecție. Scrie lista[2:5] = [0] * (5 - 2) dacă vrei zerouri pe toate pozițiile, sau lista[2:5] = [0] dacă vrei un singur element în loc. Explicația completă → Mediu Repară tu ValueError: attempt to assign sequence of size 2 to extended slice of size 3 Ai atribuit unei felii cu pas (lista[::2]) o listă cu alt număr de elemente decât are felia. La feliile cu pas, lungimile trebuie să fie egale. Verifică dacă în dreapta ai folosit aceeași felie (de ex. nums[::2], nu nums[1::2]). Explicația completă → Ușor Repară tu ValueError: range() arg 3 must not be zero Al treilea argument din range(start, stop, pas) e 0, iar o buclă cu pasul 0 nu ar avansa niciodată. De obicei pasul e calculat (len(lista) // k) și iese 0 când lista e mai scurtă decât k. Rotunjește în sus și asigură-te că pasul e cel puțin 1: max(1, -(-n // k)). Explicația completă → Ușor Repară tu Rotirea listei cu k mai mare decât lungimea dă lista nemodificată lista[-k:] + lista[:-k] merge doar pentru k mai mic decât lungimea. Pentru k mai mare, ambele felii se „lipesc” de capete și primești lista neschimbată. Reduce întâi k cu k %= len(lista) (după ce verifici că lista nu e goală). Explicația completă → Ușor Repară tu lista.remove(x) în bucla for sare peste elemente: rămân valori care trebuiau șterse Când ștergi din listă în timp ce o parcurgi cu for, elementele de după cel șters se mută cu o poziție la stânga, iar bucla sare peste următorul. Construiește o listă nouă cu elementele păstrate: [x for x in nums if x >= 0], sau parcurge o copie (for x in nums[:]). Explicația completă → Ușor Repară tu Bucla inversă range(len(nums) - 1, 0, -1) sare peste primul element range se oprește înainte de valoarea stop, deci range(n - 1, 0, -1) se termină la 1 și nu ajunge la indexul 0. Pentru a parcurge toți indicii de la coadă scrie range(len(nums) - 1, -1, -1) sau reversed(range(len(nums))). Explicația completă → Ușor Repară tu TypeError: 'list' object cannot be interpreted as an integer Ai dat o listă unei funcții care așteaptă un număr întreg, aproape mereu range(nums) în loc de range(len(nums)). Pentru indici scrie range(len(nums)), iar dacă îți trebuie și valoarea, folosește for i, x in enumerate(nums). Explicația completă → Ușor Repară tu TypeError: reduce() of empty iterable with no initial value Ai apelat functools.reduce pe o listă goală fără valoare inițială, iar reduce nu are de unde să pornească. Dă-i al treilea argument, elementul neutru: reduce(f, nums, 1) pentru produs, reduce(f, nums, 0) pentru sumă, sau folosește math.prod și sum. Explicația completă → Ușor Repară tu TypeError: unsupported operand type(s) for +: 'int' and 'list' Ai apelat sum() pe o listă de liste: sum pornește de la 0 și încearcă 0 + [1, 2]. Pentru totalul unei matrice scrie sum(map(sum, matrice)), iar pentru aplatizare folosește [x for rand in matrice for x in rand]. Explicația completă → Mediu Repară tu Fereastra glisantă variabilă se micșorează cu if în loc de while: rezultatul iese prea mare La fereastra de lungime variabilă, marginea din stânga trebuie mutată cât timp condiția e încă îndeplinită, nu o singură dată. Înlocuiește if suma >= tinta cu while suma >= tinta, ca fereastra să se strângă până la cea mai mică lungime validă. Explicația completă → Mediu Repară tu Transpunerea matricei pe loc nu schimbă nimic: fiecare pereche e interschimbată de două ori Bucla j parcurge toată matricea, deci fiecare pereche (i, j) e interschimbată o dată la (i, j) și încă o dată la (j, i), iar matricea revine la forma inițială. Pornește a doua buclă de la i + 1: for j in range(i + 1, n). Explicația completă → Căutare binară și sortări
Căutarea binară intră în buclă infinită (stanga = mijloc) Când ai actualizat capătul cu stanga = mijloc (sau dreapta = mijloc într-o buclă cu <=), intervalul nu se mai micșorează și bucla se repetă la nesfârșit; editorul oprește programul după limita de timp. Mută capătul dincolo de mijloc: stanga = mijloc + 1 și dreapta = mijloc - 1. Explicația completă → Ușor Repară tu IndexError: list index out of range la căutarea binară Ai pornit căutarea binară cu dreapta = len(lista) și bucla while stanga <= dreapta, așa că mijlocul poate ajunge la len(lista), o poziție care nu există. Cu <= pornește de la dreapta = len(lista) - 1. Explicația completă → Ușor Repară tu TypeError: list indices must be integers or slices, not float Ai calculat poziția cu împărțirea obișnuită /, care dă mereu un număr zecimal (2.0, 2.5), iar indicii de listă trebuie să fie întregi. Folosește împărțirea întreagă: mijloc = (stanga + dreapta) // 2. Explicația completă → Mediu Repară tu RecursionError în merge sort: cazul de bază nu oprește lista cu un element Cazul de bază din merge sort verifică doar lista goală (if not lista), dar o listă cu un element se împarte în [] și [x], iar [x] se reîmparte la nesfârșit. Oprește recursivitatea la cel mult un element: if len(lista) <= 1: return lista. Explicația completă → Mediu Repară tu Căutarea binară nu găsește elementul de la capăt (while stanga < dreapta) Ai folosit while stanga < dreapta cu intervalul închis [0, len - 1] și actualizări mijloc + 1 / mijloc - 1. Bucla se oprește când rămâne un singur element, fără să-l verifice, deci returnează -1 deși valoarea există. Folosește while stanga <= dreapta. Explicația completă → Ușor Repară tu TypeError: sort() takes no positional arguments Ai dat funcția de ordonare lui sort() fără nume: lista.sort(lambda p: p[1]). În Python 3, sort() și sorted() acceptă funcția doar ca argument cu nume: lista.sort(key=lambda p: p[1]), plus opțional reverse=True. Explicația completă → Mediu Repară tu TypeError: sort() got an unexpected keyword argument 'cmp' Parametrul cmp a existat doar în Python 2. În Python 3, sort() și sorted() primesc doar key și reverse. Dacă ai un comparator cu doi parametri, învelește-l: from functools import cmp_to_key, apoi lista.sort(key=cmp_to_key(compara)). Explicația completă → Mediu Repară tu bisect dă poziții greșite pe o listă nesortată bisect (și orice căutare binară) presupune că lista e sortată crescător. Pe o listă nesortată nu dă eroare, dar returnează poziții fără sens. Sortează lista o dată înainte (lista.sort()) sau păstreaz-o sortată cu bisect.insort. Explicația completă → Ușor Repară tu Numerele sortate ca text: '10' apare înaintea lui '9' Valorile tale sunt texte ('10', '9'), iar textele se compară literă cu literă, deci '10' < '9' pentru că '1' < '9'. Transformă-le în numere înainte de sortare (int / float) sau sortează cu key=int. Explicația completă → Mediu Repară tu TypeError: bad operand type for unary -: 'str' Ai pus minus în fața unui text, de obicei în cheia de sortare (key=lambda p: -p[0]) ca să sortezi descrescător după nume. Minusul merge doar pe numere. Pentru texte sortează în doi pași (sortarea e stabilă) sau folosește reverse=True. Explicația completă → Mediu Repară tu bisect_left în loc de bisect_right: numărul de valori dintr-un interval iese prea mic bisect_left(lista, b) dă poziția dinaintea primei apariții a lui b, deci valorile egale cu b nu sunt numărate. Pentru câte valori sunt în intervalul [a, b] folosește bisect_right(lista, b) - bisect_left(lista, a). Explicația completă → Mediu Repară tu Căutarea binară returnează o apariție oarecare, nu prima, când valoarea se repetă Căutarea binară clasică se oprește la prima potrivire întâlnită, care poate fi oricare dintre valorile egale. Ca să găsești prima apariție, când nums[mijloc] == x salvează poziția și continuă căutarea în stânga (dreapta = mijloc - 1). Explicația completă → Greu Repară tu cmp_to_key cu un comparator care returnează True/False: ordinea iese greșită Funcția dată lui cmp_to_key trebuie să returneze un număr negativ (a înaintea lui b), 0 (egale) sau pozitiv (b înaintea lui a), nu True/False. False înseamnă 0, adică „egale”, iar sortarea nu mai are informații corecte. Returnează -1, 0 sau 1. Explicația completă → Ușor Repară tu TypeError: len() takes exactly one argument (0 given) Ai scris key=len() la sortare: parantezele apelează len pe loc, fără argument. Parametrul key primește funcția însăși, fără paranteze: sorted(cuvinte, key=len). La fel pentru key=str.lower și key=abs. Explicația completă → Mediu Repară tu RecursionError în quicksort: pivotul rămâne în sublista din stânga Sublista cu elementele mai mici sau egale conține și pivotul, deci când pivotul e maximul, apelul recursiv primește aceeași listă la nesfârșit. Scoate pivotul înainte de împărțire (lista[1:]) și pune-l separat între cele două părți. Explicația completă → Mediu Repară tu IndexError: list index out of range la sortarea prin inserție (lipsește j >= 0) Bucla while nums[j] > x nu se oprește când j trece de începutul listei: j devine -1, -2..., Python citește elementele de la capăt și în final iese din listă. Adaugă condiția j >= 0 înaintea comparației: while j >= 0 and nums[j] > x. Explicația completă → Ușor Repară tu Interclasarea din merge sort pierde elementele rămase dintr-una dintre liste Bucla while i < len(a) and j < len(b) se oprește când una dintre liste se termină, iar elementele rămase din cealaltă nu mai ajung în rezultat. După buclă adaugă restul: rez.extend(a[i:]) și rez.extend(b[j:]). Explicația completă → Mediu Repară tu Sortarea după două criterii iese greșită: al doilea sort() strică ordinea primului Fiecare sort() rearanjează toată lista după cheia lui, deci ultimul apel decide ordinea principală. Sortează o singură dată cu o cheie compusă, key=lambda e: (-e[1], e[0]), sau fă sorturile în ordine inversă: întâi criteriul secundar, apoi cel principal. Explicația completă → Ușor Repară tu Sortarea alfabetică pune toate cuvintele cu majusculă înaintea celor cu literă mică Textele se compară după codul Unicode al literelor, iar toate majusculele (A-Z) au coduri mai mici decât literele mici (a-z), deci 'Zalau' vine înaintea lui 'arad'. Sortează fără să ții cont de majuscule: sorted(cuvinte, key=str.lower). Explicația completă → Dicționare și set-uri
KeyError: 'a' la frecv[litera] += 1 frecv[litera] += 1 citește întâi valoarea cheii, iar la prima apariție a literei cheia nu există încă. Folosește frecv[litera] = frecv.get(litera, 0) + 1, un defaultdict(int) sau direct Counter(text). Explicația completă → Mediu Repară tu TypeError: cannot use 'list' as a set element (unhashable type: 'list') Ai pus o listă (de exemplu o poziție [r, c] sau o combinație) într-un set sau ca cheie de dicționar. Listele se pot modifica, deci nu au hash. Folosește un tuplu: vizitate.add((r, c)) sau tuple(combinatie). Explicația completă → Mediu Repară tu RuntimeError: Set changed size during iteration Ai adăugat sau ai șters elemente dintr-un set în timp ce îl parcurgeai cu for. Python oprește bucla, pentru că ordinea internă a set-ului se schimbă. Parcurge o copie (for x in list(multime)) sau construiește un set nou. Explicația completă → Ușor Repară tu AttributeError: 'set' object has no attribute 'append' Un set nu are append, pentru că nu are ordine sau poziții. Elementele se adaugă cu add(x), iar mai multe deodată cu update(lista). Pe dos, la o listă se folosește append, nu add. Explicația completă → Ușor Repară tu TypeError: 'set' object is not subscriptable Un set nu are poziții, deci s[0] sau s[-1] nu are sens. Dacă vrei cel mai mic sau cel mai mare element, folosește min(s) / max(s); pentru un element oarecare, next(iter(s)); pentru poziții, transformă în listă sortată: sorted(s)[0]. Explicația completă → Ușor Repară tu TypeError: 'dict_keys' object is not subscriptable d.keys(), d.values() și d.items() returnează vederi (views), nu liste, deci nu acceptă d.keys()[0]. Transformă în listă (list(d)[0]) sau, mai des, folosește direct ce vrei: max(d, key=d.get) pentru cheia cu valoarea cea mai mare. Explicația completă → Ușor Repară tu TypeError: first argument must be callable or None defaultdict primește o funcție care creează valoarea implicită, nu valoarea însăși. Scrie defaultdict(int) pentru 0, defaultdict(list) pentru [], defaultdict(set) pentru set(), nu defaultdict(0) sau defaultdict([]). Explicația completă → Mediu Repară tu Time Limit Exceeded: x in lista într-o buclă face soluția O(n²) x in lista caută element cu element (O(n)), iar într-o buclă peste n elemente devine O(n²): pe date mari programul depășește limita de timp. Transformă lista în set o singură dată (set_b = set(b)), apoi x in set_b e O(1) în medie. Explicația completă → Ușor Repară tu KeyError: 'popitem(): dictionary is empty' Ai apelat dict.popitem() pe un dicționar gol. popitem scoate ultima pereche adăugată, iar când nu mai e niciuna dă KeyError. Verifică înainte că dicționarul nu e gol (if istoric:) sau limitează numărul de apeluri la len(dicționar). Explicația completă → Ușor Repară tu KeyError: 'pop from an empty set' Ai apelat set.pop() pe un set gol. pop scoate un element oarecare și dă KeyError când nu mai e niciunul. Verifică înainte cu if not libere: (sau while libere:) și tratează cazul în care elementele se termină. Explicația completă → Ușor Repară tu max(dicționar) returnează cea mai mare cheie, nu cheia cu cea mai mare valoare max() parcurge un dicționar după chei, deci max(voturi) dă numele cel mai mare alfabetic. Pentru cheia cu cea mai mare valoare scrie max(voturi, key=voturi.get), iar pentru valoarea maximă max(voturi.values()). Explicația completă → Mediu Repară tu Two Sum folosește același element de două ori: returnează (0, 0) Ai pus toate valorile în dicționar înainte să cauți perechea, așa că pentru x = buget / 2 găsești chiar elementul curent. Caută complementul înainte să adaugi elementul curent în dicționar (o singură trecere), sau verifică că indicii sunt diferiți. Explicația completă → Mediu Repară tu dict.fromkeys(chei, []): toate cheile au aceeași listă dict.fromkeys pune aceeași valoare la toate cheile, iar dacă valoarea e o listă, e același obiect pentru toate. Un append la o cheie apare la toate. Folosește un dict comprehension ({g: [] for g in chei}) sau defaultdict(list). Explicația completă → Mediu Repară tu defaultdict adaugă chei noi doar pentru că le-ai citit: len() iese prea mare La un defaultdict, frecv[cheie] pentru o cheie lipsă nu doar returnează 0, ci și adaugă cheia în dicționar. După ce ai citit cuvinte care nu existau, len(frecv) și parcurgerile le includ. Pentru citire fără efecte folosește frecv.get(cheie, 0) sau cheie in frecv. Explicația completă → Ușor Repară tu TypeError: unsupported operand type(s) for &: 'list' and 'list' Operatorii de mulțimi &, |, - și ^ funcționează pe set-uri, nu pe liste. Transformă listele în set-uri: set(a) & set(b) pentru elementele comune, set(a) | set(b) pentru reuniune, set(a) - set(b) pentru diferență. Explicația completă → Stive, cozi și liste înlănțuite
IndexError: pop from empty list Ai apelat stiva.pop() pe o stivă goală. La verificarea parantezelor înseamnă de obicei o paranteză închisă fără pereche. Verifică înainte cu if not stiva: (și tratează cazul) sau pune condiția în while stiva and ... Explicația completă → Ușor Repară tu AttributeError: 'list' object has no attribute 'popleft' popleft() există doar la collections.deque, nu la liste. Creează coada cu from collections import deque și coada = deque([start]); lista.pop(0) ar merge, dar e O(n) la fiecare scoatere. Explicația completă → Ușor Repară tu IndexError: pop from an empty deque Ai apelat coada.popleft() (sau pop()) pe un deque gol: bucla a continuat după ce coada s-a golit, sau ai scos de două ori pentru un singur element pus. Folosește while coada: și scoate un singur element pe iterație. Explicația completă → Mediu Repară tu AttributeError: 'NoneType' object has no attribute 'urm' Ai ajuns la capătul listei înlănțuite (nodul curent e None) și ai cerut încă .urm sau .val. Verifică nodul înainte de acces: while curent and curent.urm:, iar la doi pași (rapid.urm.urm) verifică ambii pași. Explicația completă → Ușor Repară tu Parcurgerea listei înlănțuite nu se mai oprește (lipsește curent = curent.urm) În bucla while curent: ai uitat să avansezi cu curent = curent.urm (sau avansezi doar pe o ramură a unui if), așa că nodul curent nu se schimbă și bucla rulează la nesfârșit; editorul o oprește după limita de timp. Avansează pe fiecare drum prin buclă. Explicația completă → Ușor Repară tu TypeError: 'Nod' object is not iterable Ai pus un nod de listă înlănțuită (sau de arbore) într-un for, dar clasa ta nu știe să fie parcursă. Parcurge manual cu while curent: ... curent = curent.urm, sau adaugă clasei o metodă __iter__. Explicația completă → Ușor Repară tu print(nod) afișează <__main__.Nod object at 0x7f...> în loc de valori Nu e o eroare: Python nu știe cum să afișeze un obiect din clasa ta, așa că arată tipul și adresa din memorie. Adaugă clasei o metodă __repr__ care returnează un text, de exemplu valorile listei înlănțuite, sau afișează explicit nod.val. Explicația completă → Ușor Repară tu Verificarea parantezelor returnează True pentru „((” (stiva rămâne nevidă) Funcția verifică doar parantezele închise, dar la final nu verifică dacă au rămas paranteze deschise în stivă. Înlocuiește return True de la final cu return not stiva (sau len(stiva) == 0). Explicația completă → Mediu Repară tu Inversarea listei înlănțuite pierde noduri (curent.urm suprascris înainte de avans) Ai schimbat curent.urm = anterior înainte să salvezi următorul nod, iar apoi curent = curent.urm te duce înapoi, nu înainte. Salvează întâi urmator = curent.urm, abia apoi întoarce legătura și avansează cu curent = urmator. Explicația completă → Mediu Repară tu RuntimeError: deque mutated during iteration Ai adăugat sau scos elemente dintr-un deque în timp ce îl parcurgeai cu for. Pentru o coadă BFS nu parcurge cu for: folosește while coada: nod = coada.popleft(), iar vecinii noi îi adaugi cu append. Explicația completă → Ușor Repară tu TypeError: sequence index must be integer, not 'slice' Ai încercat să tai o felie dintr-un deque (coada[-3:]), dar deque nu acceptă felii, doar indici simpli. Transformă-l în listă înainte (list(coada)[-3:]) sau folosește itertools.islice pentru o porțiune de la început. Explicația completă → Ușor Repară tu ValueError: deque.remove(x): x not in deque Ai cerut ștergerea unei valori care nu e în deque. remove caută valoarea și dă ValueError dacă nu o găsește. Verifică înainte cu if x in coada: sau prinde eroarea cu try/except ValueError. Explicația completă → Mediu Repară tu Ștergerea din lista înlănțuită nu șterge primul nod (capul listei) Bucla verifică mereu curent.urm, deci nu ajunge niciodată să compare capul listei. Pune un nod fals (santinelă) înaintea capului: santinela = Nod(0, cap), parcurge de la ea și returnează santinela.urm. Explicația completă → Greu Repară tu Stiva monotonă păstrează valori în loc de indici: distanțele ies greșite Dacă pui în stivă valorile, nu mai știi pe ce poziție era fiecare, iar lista.index(v) găsește prima apariție, nu pe cea corectă. Pune în stivă indicii (stiva.append(i)) și compară cu t[stiva[-1]]. Explicația completă → Mediu Repară tu Evaluarea formei postfixate dă rezultat greșit la - și /: operanzii scoși din stivă în ordine inversă Primul element scos din stivă e operandul din dreapta, nu cel din stânga. Scrie b = stiva.pop(); a = stiva.pop() și calculează a - b sau a / b. La + și * ordinea nu contează, de aceea greșeala apare doar la scădere și împărțire. Explicația completă → Mediu Repară tu TypeError: object of type 'Queue' has no len() queue.Queue e o coadă pentru fire de execuție, nu o structură de date pentru algoritmi: nu are len(), iar while coada: nu se oprește niciodată. Pentru BFS folosește collections.deque, cu append, popleft și while coada. Explicația completă → Arbori și heap-uri
AttributeError: 'NoneType' object has no attribute 'stanga' Funcția recursivă pe arbore a coborât într-un copil care nu există (None) și a cerut .stanga sau .val. Pune cazul de bază la început: if nod is None: return 0 (sau valoarea potrivită), înainte de orice acces la atributele nodului. Explicația completă → Greu Repară tu TypeError: '<' not supported between instances of 'Nod' and 'Nod' Ai pus în heapq tupluri (prioritate, obiect), iar două elemente au aceeași prioritate, așa că heapq a încercat să compare obiectele, care nu știu să se compare. Adaugă un contor unic între ele: (prioritate, contor, obiect). Explicația completă → Ușor Repară tu IndexError: index out of range la heapq.heappop heapq.heappop(heap) pe un heap gol aruncă IndexError: index out of range (fără „list”). Verifică while heap: sau if heap: înainte să scoți, iar la „cele mai mari k” nu scoate de mai multe ori decât elemente ai. Explicația completă → Mediu Repară tu heapq scoate cel mai mic element, nu cel mai mare (max-heap lipsă) heapq din Python e un min-heap: heappop returnează mereu cel mai mic element. Pentru cel mai mare, pune valorile negate (heappush(h, -x), apoi -heappop(h)), folosește heapq.nlargest, sau, din Python 3.14, heappush_max / heappop_max. Explicația completă → Greu Repară tu Validarea unui BST compară doar cu copiii direcți și acceptă arbori greșiți Într-un arbore binar de căutare, toate valorile din subarborele stâng trebuie să fie mai mici decât nodul, nu doar copilul stâng. Transmite în recursivitate un interval permis (minim, maxim) și verifică fiecare nod față de el. Explicația completă → Ușor Repară tu TypeError: heappop() argument must be list, not None Ai salvat rezultatul lui heapq.heapify(lista), care e None: heapify transformă lista pe loc și nu returnează nimic. Scrie heapq.heapify(nums) pe un rând și folosește apoi chiar nums ca heap. Explicația completă → Ușor Repară tu TypeError: heappush expected 2 arguments, got 1 heapq.heappush primește două argumente: lista heap și elementul. Ai dat doar elementul (de obicei un tuplu). Scrie heapq.heappush(heap, (distanta, nume)). Dacă primești got 3, ai uitat parantezele tuplului. Explicația completă → Mediu Repară tu heap[-1] nu e cel mai mare element dintr-un min-heap Un heap garantează doar că heap[0] e minimul; restul listei nu e sortat, deci heap[-1] e o valoare oarecare. Pentru maxim folosește max(heap), un al doilea heap cu valori negate sau heapq.nlargest(1, heap). Explicația completă → Mediu Repară tu Inserarea în BST pierde nodurile noi: rezultatul apelului recursiv nu e atribuit Funcția recursivă returnează nodul nou când ajunge la None, dar dacă nu scrii rad.stanga = insereaza(rad.stanga, val), nodul nu e legat de arbore. Atribuie rezultatul la fiecare nivel și la apelul de sus (rad = insereaza(rad, val)). Explicația completă → Mediu Repară tu Parcurgerea pe niveluri pune fiecare nod pe un nivel separat (lipsește len(coada)) BFS-ul scoate nodurile corect, dar nu știe unde se termină un nivel. La începutul fiecărui nivel, fixează câte noduri are: for _ in range(len(coada)):, scoate exact atâtea, iar copiii lor formează nivelul următor. Explicația completă → Ușor Repară tu Parcurgerea în inordine returnează doar rădăcina: rezultatele apelurilor recursive sunt ignorate Funcția apelează inordine(nod.stanga) și inordine(nod.dreapta), dar nu folosește ce returnează, deci rezultatul conține doar valoarea nodului curent. Combină rezultatele: return inordine(nod.stanga) + [nod.val] + inordine(nod.dreapta). Explicația completă → Mediu Repară tu heappop nu scoate minimul: ai adăugat în heap cu append în loc de heappush Un heap din heapq e o listă obișnuită care respectă o anumită ordine internă, iar append sau o atribuire directă strică ordinea. Adaugă doar cu heapq.heappush(heap, x), iar dacă ai modificat elemente direct, refă ordinea cu heapq.heapify(heap). Explicația completă → Grafuri: BFS și DFS
KeyError: 'D' la graf[nod] (nodul nu are listă de vecini) Graful e un dicționar de liste de vecini, dar un nod apare doar ca vecin, nu și ca cheie (de obicei un nod fără muchii de ieșire). graf[nod] dă KeyError. Folosește graf.get(nod, []) sau construiește graful cu defaultdict(list) și adaugă toate nodurile. Explicația completă → Mediu Repară tu RuntimeError: dictionary changed size during iteration Parcurgi un dicționar (de obicei graful) cu for, iar în buclă adaugi sau ștergi chei. Cu defaultdict, chiar și citirea graf[v] pentru un nod nou adaugă o cheie. Parcurge list(graf) sau citește cu graf.get(v, []). Explicația completă → Mediu Repară tu RecursionError la DFS: graful are un ciclu și lipsesc nodurile vizitate DFS-ul recursiv nu ține minte nodurile vizitate, iar graful are un ciclu (sau e neorientat: A-B înseamnă și B-A), deci se plimbă la nesfârșit până la RecursionError. Adaugă un set vazut și nu reintra în nodurile din el. Explicația completă → Mediu Repară tu BFS-ul nu se mai oprește pe un graf cu ciclu (lipsesc nodurile vizitate) BFS-ul pune în coadă vecinii fără să verifice dacă au mai fost descoperiți, iar pe un graf cu ciclu (sau neorientat) aceleași noduri intră în coadă la nesfârșit; editorul oprește programul după limita de timp. Marchează nodul ca vizitat când îl pui în coadă. Explicația completă → Ușor Repară tu IndexError: list index out of range la un graf cu noduri numerotate de la 1 Nodurile sunt numerotate de la 1 la n, dar lista de adiacență are n poziții (0..n-1), așa că graf[n] nu există. Creează n + 1 liste: graf = [[] for _ in range(n + 1)], și ignoră poziția 0. Explicația completă → Ușor Repară tu TypeError: 'int' object is not iterable la deque(start) deque(...) primește o colecție pe care o parcurge, nu un element. deque(start) cu start = 0 încearcă să parcurgă numărul 0. Pune elementul într-o listă: deque([start]) sau deque([(start, 0)]). Explicația completă → Mediu Repară tu Vecinul grila[-1][j] nu dă eroare: indicii negativi trec de verificarea marginii În Python, grila[-1] e ultimul rând, nu o eroare. Dacă verifici doar i < len(grila), vecinul de deasupra primului rând „există” și BFS/DFS-ul trece pe partea cealaltă a hărții. Verifică ambele margini: 0 <= i < randuri and 0 <= j < coloane. Explicația completă → Ușor Repară tu Graful neorientat are muchiile adăugate doar într-un sens: BFS nu ajunge la toate nodurile Pentru un graf neorientat (drumuri, prietenii, cabluri), fiecare muchie u-v trebuie adăugată în ambele liste: graf[u].append(v) și graf[v].append(u). Cu un singur sens, din v nu mai poți ajunge înapoi la u, iar BFS/DFS ratează noduri. Explicația completă → Greu Repară tu Dijkstra dă distanțe greșite: nodul e marcat vizitat când e pus în heap La Dijkstra, prima distanță găsită spre un nod nu e neapărat cea mai mică. Dacă marchezi nodul ca vizitat când îl pui în heap, nu mai poți îmbunătăți distanța lui. Actualizează distanța ori de câte ori găsești una mai mică și ignoră la scoatere intrările vechi (if d > dist[u]: continue). Explicația completă → Mediu Repară tu OverflowError: cannot convert float infinity to integer Încerci să transformi float('inf') într-un întreg, de obicei cu int() sau round() pe o distanță care a rămas infinită pentru că nodul nu poate fi atins. Verifică înainte dacă valoarea e infinită (math.isinf sau == float('inf')) și returnează -1 sau un mesaj. Explicația completă → Mediu Repară tu BFS cu coada.pop() în loc de popleft(): distanțele ies prea mari pop() scoate ultimul element, deci coada ta funcționează ca o stivă și parcurgerea devine DFS. Nodurile sunt descoperite pe drumuri lungi și primesc distanțe prea mari. La BFS folosește deque și scoate cu popleft() (cel mai vechi element). Explicația completă → Ușor Repară tu AttributeError: 'int' object has no attribute 'append' Valoarea pe care apelezi .append() e un număr, nu o listă. În algoritmi, cauza tipică e defaultdict(int) folosit pentru liste de vecini sau grupe. Pentru liste folosește defaultdict(list), pentru set-uri defaultdict(set); int e doar pentru numărare. Explicația completă → Mediu Repară tu TypeError: can only concatenate tuple (not "int") to tuple Aduni un număr la un tuplu. În Dijkstra, cauza tipică e d = heapq.heappop(heap), care dă perechea întreagă (distanta, nod), iar d + cost încearcă să lipească un număr de tuplu. Despachetează perechea: d, u = heapq.heappop(heap), apoi d + cost. Explicația completă → Greu Repară tu Union-Find leagă nodurile, nu rădăcinile: ciclurile nu sunt detectate La reuniune ai scris parinte[a] = b, care rupe nodul a din grupul lui vechi. Trebuie să legi rădăcinile: ra, rb = gaseste(a), gaseste(b); dacă sunt diferite, parinte[ra] = rb. Altfel grupurile se despart și găsirea ciclurilor dă rezultate greșite. Explicația completă → Mediu Repară tu Sortarea topologică nu detectează ciclul: returnează o ordine incompletă Algoritmul lui Kahn scoate doar nodurile fără dependențe rămase; nodurile dintr-un ciclu nu ajung niciodată la gradul 0, deci lipsesc din rezultat. La final verifică len(ordine) == n și returnează None (sau o eroare) dacă nu e așa. Explicația completă → Ușor Repară tu IndexError: tuple index out of range la muchii[i][3] Ai cerut dintr-un tuplu o poziție care nu există, de obicei m[3] dintr-o muchie (u, v, cost), care are doar pozițiile 0, 1 și 2. Numără elementele tuplului de la 0 sau, mai sigur, despachetează-l: for u, v, cost in muchii. Explicația completă → Greu Repară tu Dijkstra dă distanțe greșite pe un graf cu muchii de cost negativ Dijkstra presupune că toate costurile sunt pozitive sau zero: un nod scos din heap are deja distanța finală. Cu o muchie negativă, un drum mai lung poate deveni mai scurt după aceea. Pentru costuri negative folosește Bellman-Ford. Explicația completă → Greu Repară tu Detectarea ciclului într-un graf orientat găsește cicluri care nu există (doar un set vizitat) Într-un graf orientat, un nod deja vizitat nu înseamnă ciclu: poate fi atins pe două drumuri diferite. Ciclu există doar dacă revii la un nod aflat încă pe drumul curent al DFS-ului. Ține trei stări: nevizitat, pe stivă, terminat. Explicația completă → Programare dinamică și memoizare
Recursivitatea fără memoizare rulează la nesfârșit: fib(40) nu se mai termină Funcția recursivă recalculează aceleași subprobleme de un număr exponențial de ori (fib(40) face sute de milioane de apeluri), așa că pare blocată și editorul o oprește după limita de timp. Salvează rezultatele: @lru_cache(maxsize=None) sau un dicționar memo. Explicația completă → Mediu Repară tu TypeError: unhashable type: 'list' cu @lru_cache @lru_cache folosește argumentele funcției ca cheie de dicționar, iar o listă nu poate fi cheie. Transmite un tuplu (tuple(lista)) sau, mai bine, păstrează lista în afara funcției memoizate și trimite doar indici. Explicația completă → Ușor Repară tu TypeError: 'int' object is not subscriptable la dp[i][j] Ai creat tabelul DP cu o singură dimensiune (dp = [0] * n), deci dp[i] este un număr, iar dp[i][j] încearcă să ia un element dintr-un număr. Creează o matrice: dp = [[0] * coloane for _ in range(randuri)]. Explicația completă → Ușor Repară tu IndexError: list index out of range la dp[n] (tabelul DP e prea scurt) Ai creat tabelul cu dp = [0] * n, dar răspunsul e dp[n], iar o listă cu n elemente are doar indicii 0..n-1. Când dp[i] înseamnă „primele i elemente” sau „treapta i”, tabelul are nevoie de n + 1 poziții: dp = [0] * (n + 1). Explicația completă → Greu Repară tu Memo greșit: cheia nu conține toți parametrii, iar rezultatul e greșit Ai salvat în memo rezultatul doar după i (memo[i]), dar funcția depinde și de alt parametru (capacitate, j, suma rămasă), așa că un rezultat calculat pentru o stare e refolosit pentru alta. Cheia memo-ului trebuie să conțină toți parametrii care schimbă rezultatul: memo[(i, capacitate)]. Explicația completă → Mediu Repară tu ValueError: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit Numărul tău întreg are peste 4300 de cifre, iar din Python 3.11 transformarea lui în text (print, str, f-string) e limitată. În algoritmi, aproape mereu enunțul cere rezultatul modulo 10**9 + 7: aplică % MOD la fiecare pas. Dacă chiar vrei toate cifrele, ridică limita cu sys.set_int_max_str_digits(0). Explicația completă → Greu Repară tu Rucsacul 0/1 cu tabel 1D parcurs crescător folosește același obiect de mai multe ori În rucsacul 0/1 cu un singur rând dp, dacă parcurgi capacitățile crescător, dp[w - g] e deja actualizat cu obiectul curent, deci obiectul e pus de mai multe ori. Parcurge capacitatea descrescător: for w in range(C, g - 1, -1). Explicația completă → Mediu Repară tu Restul minim cu monede iese 0: tabelul DP e inițializat cu 0 în loc de infinit La un DP de minim (cele mai puține monede), valoarea inițială trebuie să fie „imposibil” (float('inf')), nu 0, pentru că min(0, orice) rămâne 0. Pornește cu dp = [float('inf')] * (suma + 1), dp[0] = 0, iar la final returnează -1 dacă dp[suma] e tot infinit. Explicația completă → Ușor Repară tu TypeError: 'functools._lru_cache_wrapper' object is not subscriptable Ai scris numele funcției memoizate cu paranteze pătrate, drumuri[n - 1], ca și cum ar fi un tabel DP. O funcție se apelează cu paranteze rotunde: drumuri(n - 1). Paranteze pătrate folosești doar pentru liste și dicționare (dp[i]). Explicația completă → Greu Repară tu Numărul de moduri de a da restul iese prea mare: DP-ul numără permutări, nu combinații Dacă bucla exterioară e peste sume și cea interioară peste monede, 1 + 2 și 2 + 1 sunt numărate separat. Pentru combinații, pune monedele în bucla exterioară: for m in monede: for s in range(m, suma + 1): dp[s] += dp[s - m]. Explicația completă → Mediu Repară tu Cel mai lung subșir crescător returnează dp[-1] în loc de max(dp) dp[i] e lungimea celui mai lung subșir crescător care se termină chiar la poziția i, nu cea mai bună din tot șirul. Răspunsul e maximul din tot tabelul: return max(dp, default=0), nu dp[-1]. Explicația completă → Ușor Repară tu Fibonacci iterativ dă 1, 2, 4, 8: a = b și b = a + b pe linii separate Pe linii separate, a = b suprascrie valoarea veche a lui a înainte să o folosești în b = a + b, deci b se dublează la fiecare pas. Fă actualizarea simultan: a, b = b, a + b, sau salvează valoarea veche într-o variabilă temporară. Explicația completă → Ușor Repară tu ValueError: k must be a non-negative integer Ai apelat math.comb(n, k) sau math.perm(n, k) cu k negativ, de obicei dintr-un indice decalat cu 1 (k - 1 pentru k = 0). Verifică intervalul lui k: combinările C(n, k) au sens pentru k de la 0 la n, deci folosește for k in range(n + 1) cu math.comb(n, k). Explicația completă → Mediu Repară tu Distanța de editare iese prea mică: prima linie și prima coloană din tabel nu sunt inițializate dp[i][0] e costul transformării primelor i litere în textul gol, adică i ștergeri, iar dp[0][j] e j inserări. Dacă le lași 0, algoritmul crede că poți șterge sau insera gratuit. Inițializează dp[i][0] = i și dp[0][j] = j înainte de bucle. Explicația completă → Capcane Python în algoritmi
Argumentul implicit mutabil (rezultat=[]) păstrează valorile între apeluri Valoarea implicită a unui parametru (rezultat=[], memo={}) se creează o singură dată, când e definită funcția, și e aceeași listă la toate apelurile, așa că al doilea apel vede ce a adăugat primul. Folosește rezultat=None și creează lista în funcție: if rezultat is None: rezultat = []. Explicația completă → Mediu Repară tu [[0] * m] * n: modifici o celulă și se schimbă toată coloana [[0] * m] * n nu creează n rânduri, ci n referințe la același rând, așa că dp[0][1] = 5 apare în toate rândurile. Creează fiecare rând separat: [[0] * m for _ in range(n)]. Explicația completă → Ușor Repară tu TypeError: 'int' object is not callable Ai pus paranteze după ceva care e un număr. Aproape mereu ai dat unei variabile numele unei funcții (max = 0, sum = 0, min = ...) și apoi ai apelat funcția. Redenumește variabila (cel_mai_bun, total) și, în consolă, șterge-o cu del max. Explicația completă → Ușor Repară tu TypeError: 'list' object is not callable Ai pus paranteze rotunde după o listă: nums(i) în loc de nums[i], sau ai numit o variabilă list și apoi ai apelat list(...). Elementele se accesează cu paranteze drepte, iar variabilele nu trebuie să se numească list, str, dict sau set. Explicația completă → Ușor Repară tu NameError: name 'deque' is not defined Folosești deque (sau heapq, Counter, defaultdict, lru_cache, inf) fără să-l fi importat. Adaugă importul la începutul fișierului: from collections import deque, import heapq, from functools import lru_cache, from math import inf. Explicația completă → Ușor Repară tu TypeError: 'module' object is not callable. Did you mean: 'bisect.bisect(...)'? Ai importat modulul (import bisect) și apoi l-ai apelat ca pe o funcție: bisect(lista, x). Modulul conține funcțiile, deci scrie bisect.bisect_left(lista, x) sau importă direct funcția: from bisect import bisect_left. Explicația completă → Ușor Repară tu TypeError: 'tuple' object does not support item assignment Tuplurile nu se pot modifica după ce le-ai creat, deci pozitie[0] += 1 nu e permis. Creează un tuplu nou (pozitie = (r + 1, c)), lucrează cu variabile separate, sau folosește o listă dacă valoarea trebuie schimbată pe loc. Explicația completă → Mediu Repară tu StopIteration la next() pe un generator fără rezultate next(generator) cere următorul element, iar dacă nu mai există niciunul aruncă StopIteration. La next(x for x in nums if conditie), asta înseamnă că niciun element nu respectă condiția. Dă o valoare implicită: next((x for x in nums if conditie), None). Explicația completă → Mediu Repară tu nou = stare nu copiază lista: modifici „copia” și se schimbă și originalul nou = stare nu creează o listă nouă, ci un al doilea nume pentru aceeași listă. Orice modificare prin nou se vede și prin stare. Copiază explicit: nou = stare[:] sau list(stare), iar pentru liste de liste [r[:] for r in stare]. Explicația completă → Ușor Repară tu TypeError: 'generator' object is not subscriptable Ai încercat să accesezi cu [i] un generator (o funcție cu yield sau o expresie (x for x in ...)). Generatoarele produc valorile pe rând și nu au indici. Transformă rezultatul în listă cu list(...) sau scrie o comprehensiune de listă [x for x in ...]. Explicația completă → Mediu Repară tu grila.copy() (sau grila[:]) pe o matrice: modifici copia și se schimbă și originalul copy() și [:] fac o copie superficială: lista nouă conține aceleași rânduri ca originalul. Modificarea unei celule apare în ambele. Pentru o matrice copiază fiecare rând: [rand[:] for rand in grila], sau folosește copy.deepcopy(grila). Explicația completă → Ușor Repară tu itertools.permutations returnează tupluri: comparația cu o listă dă mereu False permutations, combinations și product produc tupluri, iar în Python o listă nu e niciodată egală cu un tuplu, chiar dacă au aceleași elemente. Compară tot cu tupluri, tuple(x) in permutations(...), sau transformă rezultatele: [list(p) for p in permutations(...)]. Explicația completă → Numere, biți și caractere
x ^ 2 nu ridică la pătrat: în Python ^ înseamnă XOR pe biți Operatorul ^ face XOR pe biți, deci 3 ^ 2 dă 1, nu 9. Pentru putere folosește ** (x ** 2) sau pow(x, 2), iar pentru constanta 10^9 + 7 scrie 10 ** 9 + 7. Explicația completă → Ușor Repară tu Numărul de cifre iese peste 300: n = n / 10 în loc de n = n // 10 În Python 3, / face împărțire reală și dă mereu un float, deci n / 10 nu ajunge niciodată la 0 într-un număr mic de pași: 12345 devine 1234.5, 123.45 și tot așa. Pentru cifre folosește împărțirea întreagă: n //= 10, iar ultima cifră e n % 10. Explicația completă → Ușor Repară tu Testul de primalitate spune că 4, 9 și 25 sunt prime: range(2, int(n ** 0.5)) se oprește prea devreme range exclude capătul din dreapta, deci range(2, int(n ** 0.5)) nu verifică chiar rădăcina pătrată, iar pătratele numerelor prime (4, 9, 25, 49) trec drept prime. Adaugă +1: range(2, math.isqrt(n) + 1). Explicația completă → Mediu Repară tu 0.1 + 0.2 == 0.3 dă False: float-urile comparate cu == Numerele float sunt stocate în binar și majoritatea zecimalelor (0.1, 0.2) nu au o reprezentare exactă, deci 0.1 + 0.2 e 0.30000000000000004. Nu compara float-uri cu ==: folosește math.isclose(a, b), sau lucrează cu întregi (bani în loc de lei). Explicația completă → Mediu Repară tu Inversarea unui număr negativ intră în buclă infinită: -1 // 10 este -1, iar -123 % 10 este 7 În Python, // rotunjește în jos (spre minus infinit) și % are semnul împărțitorului, deci -1 // 10 rămâne -1 și bucla while n != 0 nu se oprește. Lucrează cu valoarea absolută: semn = -1 if n < 0 else 1, n = abs(n), iar la final înmulțește cu semnul. Explicația completă → Mediu Repară tu OverflowError: int too large to convert to float Un întreg Python poate fi oricât de mare, dar un float nu trece de aproximativ 1.8e308, iar math.sqrt, / sau float() încearcă să-l transforme. Rămâi în întregi: math.isqrt(n) pentru radical, // pentru împărțire, comparații între întregi. Explicația completă → Ușor Repară tu TypeError: ord() expected a character, but string of length 2 found ord() primește exact un caracter și returnează codul lui, dar tu i-ai dat un text întreg (sau unul gol). Aplică ord pe fiecare literă: sum(ord(c) - ord('a') + 1 for c in cuvant), sau verifică lungimea textului înainte. Explicația completă → Ușor Repară tu Cifrul lui Caesar produce caractere ca { | }: lipsește % 26 la deplasare chr(ord(c) + k) continuă după z în tabelul Unicode, deci x, y, z devin {, |, }. Calculează poziția în alfabet, aplică deplasarea modulo 26 și revino la literă: chr((ord(c) - ord('a') + k) % 26 + ord('a')). Explicația completă → Nicio eroare nu se potrivește căutării. Încearcă doar partea fixă a mesajului (fără numele variabilelor).
Erori explicate la alte tehnologii
Învață Algoritmi și structuri de date de la zero, cu exerciții la fiecare lecție
Curs Algoritmi pentru interviuri: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 2 lecții sunt gratuite.
