Back(k):
    pentru fiecare valoare v posibilă pe poziția k:
        dacă v este validă (nu încalcă restricțiile):
            plasează v pe poziția k
            dacă am ajuns la soluție completă:
                afișează soluția
            altfel:
                Back(k + 1)      # recurge pe nivelul următor
            (retragere implicită — alta valoare va fi încercată)

123  132  213  231  312  321

def permutari(n):
    st = [0] * n
    folosit = [False] * (n + 1)

    def back(k):
        if k == n:                          # soluție completă
            print(*st)
            return
        for v in range(1, n + 1):           # încercăm fiecare valoare
            if not folosit[v]:              # validare: nu e deja folosit
                st[k] = v
                folosit[v] = True
                back(k + 1)                 # recurgem
                folosit[v] = False          # backtrack

    back(0)

permutari(3)

#include <iostream>
using namespace std;
int n, st[20];
bool folosit[21];

void back(int k) {
    if (k == n) {
        for (int i = 0; i < n; i++) cout << st[i] << " ";
        cout << endl;
        return;
    }
    for (int v = 1; v <= n; v++) {
        if (!folosit[v]) {
            st[k] = v;
            folosit[v] = true;
            back(k + 1);
            folosit[v] = false;
        }
    }
}

int main() {
    n = 3;
    back(0);
    return 0;
}

def aranjamente(n, k):
    st = [0] * k
    folosit = [False] * (n + 1)

    def back(poz):
        if poz == k:
            print(*st)
            return
        for v in range(1, n + 1):
            if not folosit[v]:
                st[poz] = v
                folosit[v] = True
                back(poz + 1)
                folosit[v] = False

    back(0)

aranjamente(3, 2)

def combinari(n, k):
    st = [0] * k

    def back(poz, start):
        if poz == k:
            print(*st)
            return
        for v in range(start, n + 1):
            st[poz] = v
            back(poz + 1, v + 1)  # următorul trebuie să fie > v

    back(0, 1)

combinari(4, 2)

void comb_back(int poz, int start) {
    if (poz == k) {
        for (int i = 0; i < k; i++) cout << st[i] << " ";
        cout << endl;
        return;
    }
    for (int v = start; v <= n; v++) {
        st[poz] = v;
        comb_back(poz + 1, v + 1);
    }
}
// apelat: comb_back(0, 1);

111 112 121 122 211 212 221 222

def produs_cartezian(n, k):
    st = [0] * k

    def back(poz):
        if poz == k:
            print(*st)
            return
        for v in range(1, n + 1):
            st[poz] = v
            back(poz + 1)

    back(0)

produs_cartezian(2, 3)

def regine(n):
    st = [0] * n
    nr_solutii = [0]

    def valid(poz):
        for i in range(poz):
            if st[i] == st[poz] or abs(i - poz) == abs(st[i] - st[poz]):
                return False
        return True

    def back(poz):
        if poz == n:
            nr_solutii[0] += 1
            # afișare tablă
            for i in range(n):
                print('. ' * st[i] + 'Q ' + '. ' * (n - st[i] - 1))
            print()
            return
        for col in range(n):
            st[poz] = col
            if valid(poz):
                back(poz + 1)

    back(0)
    print(f"Număr total soluții: {nr_solutii[0]}")

regine(4)  # 2 soluții
# regine(8)  # 92 soluții

4
1+3, 3+1, 2+2
1+1+2, 1+2+1, 2+1+1
1+1+1+1

4, 3+1, 2+2, 2+1+1, 1+1+1+1

def compozitii(n):
    st = []

    def back(rest):
        if rest == 0:
            print(" + ".join(map(str, st)))
            return
        for v in range(1, rest + 1):
            st.append(v)
            back(rest - v)
            st.pop()

    back(n)

compozitii(4)

def partitii(n):
    st = []

    def back(rest, minim):
        if rest == 0:
            print(" + ".join(map(str, st)))
            return
        for v in range(minim, rest + 1):
            st.append(v)
            back(rest - v, v)   # următorul ≥ v
            st.pop()

    back(n, 1)

partitii(4)

def plata_suma(S, monede):
    st = []
    nr = [0]

    def back(rest, idx):
        if rest == 0:
            nr[0] += 1
            print(st)
            return
        for i in range(idx, len(monede)):
            if monede[i] <= rest:
                st.append(monede[i])
                back(rest - monede[i], i)  # i pentru a permite repetări
                st.pop()

    back(S, 0)
    print(f"Total: {nr[0]} moduri")

plata_suma(5, [1, 2, 5])
# [1, 1, 1, 1, 1]
# [1, 1, 1, 2]
# [1, 2, 2]
# [5]
# Total: 4 moduri

def coloreaza(n, m, vecini):
    # n = număr țări, m = număr culori
    # vecini[i] = listă de țări vecine cu i
    culori = [0] * n
    nr = [0]

    def valid(tara, cul):
        for v in vecini[tara]:
            if v < tara and culori[v] == cul:  # doar cele plasate deja
                return False
        return True

    def back(tara):
        if tara == n:
            nr[0] += 1
            return
        for c in range(1, m + 1):
            culori[tara] = c
            if valid(tara, c):
                back(tara + 1)

    back(0)
    return nr[0]

# 4 țări: 0-1, 0-2, 1-2, 1-3, 2-3
vecini = [[1, 2], [0, 2, 3], [0, 1, 3], [1, 2]]
print(coloreaza(4, 3, vecini))  # numărul de colorări cu 3 culori

    0 1 2 3
  ┌─────────
0 │ 0 1 1 0
1 │ 1 0 0 1
2 │ 1 0 0 0
3 │ 0 1 0 0

n = 4
a = [[0] * n for _ in range(n)]
muchii = [(0,1), (0,2), (1,3)]
for u, v in muchii:
    a[u][v] = 1
    a[v][u] = 1  # pentru neorientat

int n = 4;
int a[100][100] = {0};
int muchii[][2] = {{0,1}, {0,2}, {1,3}};
for (auto& m : muchii) {
    a[m[0]][m[1]] = 1;
    a[m[1]][m[0]] = 1;
}

0: [1, 2]
1: [0, 3]
2: [0]
3: [1]

adj = [[] for _ in range(n)]
muchii = [(0,1), (0,2), (1,3)]
for u, v in muchii:
    adj[u].append(v)
    adj[v].append(u)  # neorientat

# Pentru orientat — doar un singur append

vector<vector<int>> adj(n);
for (auto& m : muchii) {
    adj[m[0]].push_back(m[1]);
    adj[m[1]].push_back(m[0]);
}

muchii = [(0, 1), (0, 2), (1, 3)]
# sau ponderate:
muchii_p = [(0, 1, 5), (0, 2, 3), (1, 3, 7)]

def grade(a, n):
    for i in range(n):
        grad = sum(a[i])
        print(f"deg({i}) = {grad}")

def este_lant(a, sir):
    # a = matrice adiacență, sir = lista de noduri
    for i in range(len(sir) - 1):
        if a[sir[i]][sir[i+1]] == 0:
            return False
    return True

# exemplu
a = [[0,1,1,0],[1,0,1,0],[1,1,0,1],[0,0,1,0]]
print(este_lant(a, [0, 2, 3]))   # True
print(este_lant(a, [0, 3]))      # False

def numar_muchii(a, n, orientat=False):
    total = sum(sum(row) for row in a)
    return total if orientat else total // 2

def noduri_izolate(a, n):
    return [i for i in range(n) if sum(a[i]) == 0]

BFS(start):
    marchează start ca vizitat
    adaugă start în coadă
    cât timp coada nu e vidă:
        u = scoate din față
        afișează u
        pentru fiecare vecin v al lui u:
            dacă v nu e vizitat:
                marchează v ca vizitat
                adaugă v în coadă

from collections import deque

def bfs(adj, start, n):
    vizitat = [False] * n
    ordine = []
    coada = deque([start])
    vizitat[start] = True
    while coada:
        u = coada.popleft()
        ordine.append(u)
        for v in adj[u]:
            if not vizitat[v]:
                vizitat[v] = True
                coada.append(v)
    return ordine

# Exemplu
adj = [[1, 2], [0, 3, 4], [0], [1], [1]]
print(bfs(adj, 0, 5))  # [0, 1, 2, 3, 4]

#include <queue>
#include <vector>
using namespace std;

vector<int> bfs(vector<vector<int>>& adj, int start, int n) {
    vector<bool> viz(n, false);
    vector<int> ordine;
    queue<int> q;
    q.push(start);
    viz[start] = true;
    while (!q.empty()) {
        int u = q.front(); q.pop();
        ordine.push_back(u);
        for (int v : adj[u]) {
            if (!viz[v]) {
                viz[v] = true;
                q.push(v);
            }
        }
    }
    return ordine;
}

def bfs_distante(adj, start, n):
    dist = [-1] * n
    dist[start] = 0
    coada = deque([start])
    while coada:
        u = coada.popleft()
        for v in adj[u]:
            if dist[v] == -1:
                dist[v] = dist[u] + 1
                coada.append(v)
    return dist

def dfs(adj, start, n):
    vizitat = [False] * n
    ordine = []

    def explorare(u):
        vizitat[u] = True
        ordine.append(u)
        for v in adj[u]:
            if not vizitat[v]:
                explorare(v)

    explorare(start)
    return ordine

adj = [[1, 2], [0, 3, 4], [0], [1], [1]]
print(dfs(adj, 0, 5))  # [0, 1, 3, 4, 2]

def dfs_iter(adj, start, n):
    vizitat = [False] * n
    ordine = []
    stiva = [start]
    while stiva:
        u = stiva.pop()
        if vizitat[u]:
            continue
        vizitat[u] = True
        ordine.append(u)
        for v in reversed(adj[u]):  # reversed pentru ordine similară cu recursia
            if not vizitat[v]:
                stiva.append(v)
    return ordine

void dfs(int u, vector<vector<int>>& adj, vector<bool>& viz) {
    viz[u] = true;
    cout << u << " ";
    for (int v : adj[u])
        if (!viz[v])
            dfs(v, adj, viz);
}

def este_conex(adj, n):
    if n == 0:
        return True
    vizitat = [False] * n
    vizitat[0] = True
    coada = deque([0])
    nr = 1
    while coada:
        u = coada.popleft()
        for v in adj[u]:
            if not vizitat[v]:
                vizitat[v] = True
                nr += 1
                coada.append(v)
    return nr == n

def componente_conexe(adj, n):
    comp = [-1] * n
    k = 0
    for s in range(n):
        if comp[s] == -1:
            k += 1
            coada = deque([s])
            comp[s] = k
            while coada:
                u = coada.popleft()
                for v in adj[u]:
                    if comp[v] == -1:
                        comp[v] = k
                        coada.append(v)
    return comp, k

# comp[i] = numărul componentei din care face parte nodul i

def matrice_drumuri(a, n):
    d = [row[:] for row in a]  # copie matricea adiacență
    for k in range(n):
        for i in range(n):
            for j in range(n):
                if d[i][k] and d[k][j]:
                    d[i][j] = 1
    return d

def tare_conex(a, n):
    d = matrice_drumuri(a, n)
    for i in range(n):
        for j in range(n):
            if i != j and d[i][j] == 0:
                return False
    return True

dist[start] = 0, rest = infinit
PQ ← {(0, start)}
cât timp PQ nu e vidă:
    (d, u) = scoate minimul din PQ
    dacă d > dist[u]: continuă (versiune veche)
    pentru fiecare vecin v cu cost c:
        dacă dist[u] + c < dist[v]:
            dist[v] = dist[u] + c
            adaugă (dist[v], v) în PQ

import heapq
INF = float('inf')

def dijkstra(adj, start, n):
    # adj[u] = lista de perechi (v, cost)
    dist = [INF] * n
    dist[start] = 0
    pq = [(0, start)]
    while pq:
        d, u = heapq.heappop(pq)
        if d > dist[u]:
            continue
        for v, cost in adj[u]:
            nd = d + cost
            if nd < dist[v]:
                dist[v] = nd
                heapq.heappush(pq, (nd, v))
    return dist

# Exemplu
adj = [
    [(1, 4), (2, 1)],          # 0 → 1 (cost 4), 0 → 2 (cost 1)
    [(3, 1)],                   # 1 → 3 (cost 1)
    [(1, 2), (3, 5)],          # 2 → 1 (cost 2), 2 → 3 (cost 5)
    []
]
print(dijkstra(adj, 0, 4))   # [0, 3, 1, 4]

#include <vector>
#include <queue>
using namespace std;
const int INF = 1e9;

vector<int> dijkstra(vector<vector<pair<int,int>>>& adj, int start, int n) {
    vector<int> dist(n, INF);
    dist[start] = 0;
    priority_queue<pair<int,int>, vector<pair<int,int>>, greater<>> pq;
    pq.push({0, start});
    while (!pq.empty()) {
        auto [d, u] = pq.top(); pq.pop();
        if (d > dist[u]) continue;
        for (auto [v, cost] : adj[u]) {
            if (dist[u] + cost < dist[v]) {
                dist[v] = dist[u] + cost;
                pq.push({dist[v], v});
            }
        }
    }
    return dist;
}

import heapq

def prim(adj, n):
    # adj[u] = lista de (v, cost)
    in_apm = [False] * n
    cost_min = [float('inf')] * n
    parinte = [-1] * n
    cost_min[0] = 0
    pq = [(0, 0)]
    total = 0
    muchii_apm = []
    while pq:
        c, u = heapq.heappop(pq)
        if in_apm[u]:
            continue
        in_apm[u] = True
        total += c
        if parinte[u] != -1:
            muchii_apm.append((parinte[u], u, c))
        for v, cost in adj[u]:
            if not in_apm[v] and cost < cost_min[v]:
                cost_min[v] = cost
                parinte[v] = u
                heapq.heappush(pq, (cost, v))
    return total, muchii_apm

def ciclu_eulerian(adj, n):
    # adj[u] = lista de muchii (v, id_muchie)
    folosit = [False] * sum(len(l) for l in adj) // 2
    stiva = [0]
    drum = []
    while stiva:
        u = stiva[-1]
        gasit = False
        while adj[u]:
            v, id_m = adj[u][-1]
            if folosit[id_m]:
                adj[u].pop()
            else:
                folosit[id_m] = True
                stiva.append(v)
                gasit = True
                break
        if not gasit:
            drum.append(stiva.pop())
    return drum[::-1]

           A           ← rădăcină (nivel 0)
         / | \
        B  C  D        ← nivel 1 (fiii lui A)
       / \    |
      E   F   G        ← nivel 2 (frunze: E, F, G)

arbore:   1
         / \
        2   3
       /|
      4 5

tata = [_, 0, 1, 1, 2, 2]   # index 0 neutilizat
tata[1] = 0 (rădăcină)
tata[2] = 1, tata[3] = 1
tata[4] = 2, tata[5] = 2

fii = {
    1: [2, 3],
    2: [4, 5],
    3: [],
    4: [],
    5: []
}

stg[i] = fiul stâng al lui i (0 sau -1 dacă lipsește)
drp[i] = fiul drept al lui i

class Nod:
    def __init__(self, val):
        self.val = val
        self.stg = None
        self.drp = None

         8
       /   \
      3     10
     / \      \
    1   6      14
       / \     /
      4   7   13

class Nod:
    def __init__(self, val):
        self.val = val
        self.stg = None
        self.drp = None

def preordine(n):
    if n is None: return
    print(n.val, end=' ')
    preordine(n.stg)
    preordine(n.drp)

def inordine(n):
    if n is None: return
    inordine(n.stg)
    print(n.val, end=' ')
    inordine(n.drp)

def postordine(n):
    if n is None: return
    postordine(n.stg)
    postordine(n.drp)
    print(n.val, end=' ')

struct Nod {
    int val;
    Nod *stg, *drp;
};

void preordine(Nod* n) {
    if (!n) return;
    cout << n->val << " ";
    preordine(n->stg);
    preordine(n->drp);
}
// similar pentru inordine și postordine

        1
       / \
      2   3
     / \   \
    4   5   6

def cauta(nod, val):
    if nod is None:
        return False
    if nod.val == val:
        return True
    if val < nod.val:
        return cauta(nod.stg, val)
    return cauta(nod.drp, val)

def insereaza(nod, val):
    if nod is None:
        return Nod(val)
    if val < nod.val:
        nod.stg = insereaza(nod.stg, val)
    elif val > nod.val:
        nod.drp = insereaza(nod.drp, val)
    return nod

       5
      / \
     3   7
    / \   \
   1   4   8

def minim(nod):
    while nod.stg:
        nod = nod.stg
    return nod

def sterge(nod, val):
    if nod is None:
        return None
    if val < nod.val:
        nod.stg = sterge(nod.stg, val)
    elif val > nod.val:
        nod.drp = sterge(nod.drp, val)
    else:
        # Am găsit nodul
        if nod.stg is None:
            return nod.drp
        if nod.drp is None:
            return nod.stg
        # Două subarbori — înlocuim cu succesorul inorder
        succ = minim(nod.drp)
        nod.val = succ.val
        nod.drp = sterge(nod.drp, succ.val)
    return nod

def reconstruieste(preord, inord):
    if not preord:
        return None
    val_rad = preord[0]
    rad = Nod(val_rad)
    idx = inord.index(val_rad)
    rad.stg = reconstruieste(preord[1:idx+1], inord[:idx])
    rad.drp = reconstruieste(preord[idx+1:], inord[idx+1:])
    return rad

preord = [1, 2, 4, 5, 3, 6]
inord = [4, 2, 5, 1, 3, 6]
arb = reconstruieste(preord, inord)
postordine(arb)  # 4 5 2 6 3 1

def nr_frunze(nod):
    if nod is None:
        return 0
    if nod.stg is None and nod.drp is None:
        return 1
    return nr_frunze(nod.stg) + nr_frunze(nod.drp)

def inaltime(nod):
    if nod is None:
        return -1
    return 1 + max(inaltime(nod.stg), inaltime(nod.drp))

def noduri_pe_nivel(nod, k):
    if nod is None:
        return 0
    if k == 0:
        return 1
    return noduri_pe_nivel(nod.stg, k-1) + noduri_pe_nivel(nod.drp, k-1)

def este_bst(nod, min_val=float('-inf'), max_val=float('inf')):
    if nod is None:
        return True
    if nod.val <= min_val or nod.val >= max_val:
        return False
    return (este_bst(nod.stg, min_val, nod.val) and
            este_bst(nod.drp, nod.val, max_val))

from collections import deque

def parcurgere_niveluri(rad):
    if rad is None: return
    coada = deque([rad])
    while coada:
        nod = coada.popleft()
        print(nod.val, end=' ')
        if nod.stg: coada.append(nod.stg)
        if nod.drp: coada.append(nod.drp)

# Stil procedural
def creeaza_elev(nume, varsta):
    return {"nume": nume, "varsta": varsta, "note": []}

def adauga_nota(e, n):
    e["note"].append(n)

def media(e):
    return sum(e["note"]) / len(e["note"])

# Stil obiectual
class Elev:
    def __init__(self, nume, varsta):
        self.nume = nume
        self.varsta = varsta
        self.note = []

    def adauga_nota(self, n):
        self.note.append(n)

    def media(self):
        return sum(self.note) / len(self.note)

alex = Elev("Alex", 17)
alex.adauga_nota(9)
alex.adauga_nota(10)
print(alex.media())

class ContBancar:
    def __init__(self, titular, sold_initial=0):
        self.titular = titular
        self._sold = sold_initial  # convenție: _ = protected, __ = private

    def depune(self, suma):
        if suma > 0:
            self._sold += suma

    def retrage(self, suma):
        if 0 < suma <= self._sold:
            self._sold -= suma
            return True
        return False

    def sold(self):
        return self._sold

             Vehicul
           /   |    \
    Autoturism  Camion  Autocar

class NumeClasa:
    def __init__(self, parametri):
        # constructor — inițializează atributele
        self.atribut1 = parametri

    def metoda(self, argumente):
        # self = referința la obiectul curent (ca "this" din alte limbaje)
        # logică...
        pass

class Dreptunghi:
    def __init__(self, lungime, latime):
        self.lungime = lungime
        self.latime = latime

    def aria(self):
        return self.lungime * self.latime

    def perimetrul(self):
        return 2 * (self.lungime + self.latime)

    def afiseaza(self):
        print(f"Dreptunghi {self.lungime} × {self.latime}")

# Utilizare
d1 = Dreptunghi(5, 3)
d1.afiseaza()           # "Dreptunghi 5 × 3"
print(d1.aria())        # 15
print(d1.perimetrul())  # 16

class Fisier:
    def __init__(self, nume):
        self.nume = nume
        self.f = open(nume, 'w')
        print(f"S-a deschis {nume}")

    def __del__(self):
        self.f.close()
        print(f"S-a închis {self.nume}")

# f = Fisier("test.txt")
# del f  # apelează __del__

class Elev:
    scoala = "CN Tudor Vianu"  # atribut de clasă — comun tuturor elevilor

    def __init__(self, nume):
        self.nume = nume        # atribut de instanță — specific fiecăruia

a = Elev("Ana")
b = Elev("Bogdan")
print(a.scoala, b.scoala)   # ambele: "CN Tudor Vianu"

Elev.scoala = "CN Mihai Viteazul"
print(a.scoala, b.scoala)   # ambele schimbate!

class Cont:
    def __init__(self, sold):
        self.nume = "Public"       # public
        self._sold = sold           # protected
        self.__parola = "secret"    # privat

c = Cont(1000)
print(c.nume)       # OK
print(c._sold)      # OK dar "nu ar trebui"
# print(c.__parola) # EROARE — tehnic accesibil prin c._Cont__parola, dar nu se face

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __add__(self, altul):
        return Vector(self.x + altul.x, self.y + altul.y)

    def __eq__(self, altul):
        return self.x == altul.x and self.y == altul.y

    def __len__(self):
        return int((self.x**2 + self.y**2)**0.5)

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1)           # (1, 2)  — folosește __str__
v3 = v1 + v2        # folosește __add__
print(v3)           # (4, 6)
print(v1 == Vector(1, 2))  # True — __eq__

class Vehicul:
    def __init__(self, marca, viteza_max):
        self.marca = marca
        self.viteza_max = viteza_max

    def info(self):
        return f"{self.marca}, viteză max: {self.viteza_max}"

class Autoturism(Vehicul):
    def __init__(self, marca, viteza_max, nr_locuri):
        super().__init__(marca, viteza_max)  # apel constructor părinte
        self.nr_locuri = nr_locuri

    def info(self):
        # Extindem metoda părintelui
        return super().info() + f", locuri: {self.nr_locuri}"

class Camion(Vehicul):
    def __init__(self, marca, viteza_max, tonaj):
        super().__init__(marca, viteza_max)
        self.tonaj = tonaj

    def info(self):
        return super().info() + f", tonaj: {self.tonaj}t"

# Utilizare
a = Autoturism("Dacia", 180, 5)
c = Camion("Volvo", 130, 20)
print(a.info())  # "Dacia, viteză max: 180, locuri: 5"
print(c.info())  # "Volvo, viteză max: 130, tonaj: 20t"

# Polimorfism — aceeași interfață
for v in [a, c]:
    print(v.info())  # fiecare folosește propria versiune

print(isinstance(a, Autoturism))  # True
print(isinstance(a, Vehicul))     # True — moștenire!
print(isinstance(a, Camion))      # False

print(issubclass(Autoturism, Vehicul))  # True

class Carte:
    def __init__(self, titlu, autor, isbn):
        self.titlu = titlu
        self.autor = autor
        self.isbn = isbn
        self.imprumutata = False

    def __str__(self):
        stare = "împrumutată" if self.imprumutata else "disponibilă"
        return f"[{self.isbn}] {self.titlu} - {self.autor} ({stare})"

class Cititor:
    def __init__(self, nume, numar_fisa):
        self.nume = nume
        self.numar_fisa = numar_fisa
        self.carti_imprumutate = []

class Biblioteca:
    def __init__(self, nume):
        self.nume = nume
        self.carti = {}
        self.cititori = {}

    def adauga_carte(self, carte):
        self.carti[carte.isbn] = carte

    def inregistreaza_cititor(self, cititor):
        self.cititori[cititor.numar_fisa] = cititor

    def imprumuta(self, isbn, fisa):
        if isbn not in self.carti:
            return "Carte inexistentă"
        if fisa not in self.cititori:
            return "Cititor neînregistrat"
        carte = self.carti[isbn]
        cititor = self.cititori[fisa]
        if carte.imprumutata:
            return "Carte deja împrumutată"
        carte.imprumutata = True
        cititor.carti_imprumutate.append(carte)
        return "OK"

    def returneaza(self, isbn, fisa):
        carte = self.carti.get(isbn)
        cititor = self.cititori.get(fisa)
        if carte and cititor and carte in cititor.carti_imprumutate:
            carte.imprumutata = False
            cititor.carti_imprumutate.remove(carte)
            return "OK"
        return "Eroare"

    def afiseaza_disponibile(self):
        for c in self.carti.values():
            if not c.imprumutata:
                print(c)

# Utilizare
b = Biblioteca("Biblioteca Școlii")
b.adauga_carte(Carte("Ion", "Liviu Rebreanu", "001"))
b.adauga_carte(Carte("Moromeții", "Marin Preda", "002"))
b.inregistreaza_cititor(Cititor("Alex", 1))

b.imprumuta("001", 1)
b.afiseaza_disponibile()  # afișează doar "Moromeții"

class NumeClasa {
private:
    // date private
    int atribut1;

public:
    // constructor
    NumeClasa(int val) : atribut1(val) {}

    // destructor
    ~NumeClasa() {}

    // metode
    void metoda() {
        // cod
    }

    // getter
    int getAtribut() const { return atribut1; }
};

#include <iostream>
using namespace std;

class Dreptunghi {
private:
    double lungime, latime;

public:
    // Constructor
    Dreptunghi(double L, double l) : lungime(L), latime(l) {}

    // Constructor implicit
    Dreptunghi() : lungime(1), latime(1) {}

    // Destructor
    ~Dreptunghi() {
        cout << "Obiect distrus" << endl;
    }

    double aria() const { return lungime * latime; }
    double perimetrul() const { return 2 * (lungime + latime); }

    void afiseaza() const {
        cout << "Dreptunghi " << lungime << " x " << latime << endl;
    }

    // Setter
    void setLungime(double L) {
        if (L > 0) lungime = L;
    }
};

int main() {
    Dreptunghi d(5, 3);
    d.afiseaza();
    cout << "Arie: " << d.aria() << endl;
    return 0;
}

class A {
public:
    int x;       // public
private:
    int y;       // privat (default)
protected:
    int z;       // protected
};

class Vehicul {
protected:
    string marca;
    int vitezaMax;

public:
    Vehicul(string m, int v) : marca(m), vitezaMax(v) {}

    virtual void info() const {
        cout << marca << ", vmax: " << vitezaMax;
    }

    virtual ~Vehicul() {}   // destructor virtual — important!
};

class Autoturism : public Vehicul {
private:
    int nrLocuri;

public:
    Autoturism(string m, int v, int n) : Vehicul(m, v), nrLocuri(n) {}

    void info() const override {
        Vehicul::info();
        cout << ", locuri: " << nrLocuri << endl;
    }
};

int main() {
    Autoturism a("Dacia", 180, 5);
    a.info();  // "Dacia, vmax: 180, locuri: 5"

    // Polimorfism prin pointer
    Vehicul* v = new Autoturism("BMW", 250, 4);
    v->info();  // apelează versiunea din Autoturism (virtual)
    delete v;
    return 0;
}

class Forma {
public:
    virtual double aria() const = 0;   // pur virtuală
    virtual ~Forma() {}
};

class Cerc : public Forma {
    double raza;
public:
    Cerc(double r) : raza(r) {}
    double aria() const override {
        return 3.14159 * raza * raza;
    }
};

class Patrat : public Forma {
    double latura;
public:
    Patrat(double l) : latura(l) {}
    double aria() const override {
        return latura * latura;
    }
};

int main() {
    Forma* forme[] = {new Cerc(3), new Patrat(4)};
    for (auto f : forme) {
        cout << f->aria() << endl;
        delete f;
    }
}

class Vector {
    int x, y;
public:
    Vector(int a, int b) : x(a), y(b) {}

    Vector operator+(const Vector& v) const {
        return Vector(x + v.x, y + v.y);
    }

    bool operator==(const Vector& v) const {
        return x == v.x && y == v.y;
    }

    friend ostream& operator<<(ostream& os, const Vector& v) {
        os << "(" << v.x << ", " << v.y << ")";
        return os;
    }
};

// C imperativ
int suma = 0;
for (int i = 1; i <= 10; i++) {
    suma += i;
}
printf("%d\n", suma);