def cautare_secventiala(a, x):
    for i in range(len(a)):
        if a[i] == x:
            return i
    return -1  # nu a fost găsit

Pas 1: [2, 5, 7, 12, 17, 23, 31, 45, 58, 72]
        ↑                    ↑               ↑
       st=0                mij=4           dr=9
       a[4]=17 < 23 → mergem dreapta

Pas 2: [23, 31, 45, 58, 72]
        ↑       ↑        ↑
       st=5   mij=7     dr=9
       a[7]=45 > 23 → mergem stânga

Pas 3: [23, 31]
        ↑   ↑
       st=5 mij=5  (dr=6)
       a[5]=23 → GĂSIT! poziția 5

def cautare_binara(a, x):
    st, dr = 0, len(a) - 1
    while st <= dr:
        mij = (st + dr) // 2
        if a[mij] == x:
            return mij
        elif a[mij] < x:
            st = mij + 1
        else:
            dr = mij - 1
    return -1

lista = [2, 5, 7, 12, 17, 23, 31, 45, 58, 72]
print(cautare_binara(lista, 23))  # 5
print(cautare_binara(lista, 100)) # -1

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

int cautare_binara(vector<int>& a, int x) {
    int st = 0, dr = a.size() - 1;
    while (st <= dr) {
        int mij = st + (dr - st) / 2;  // evităm overflow
        if (a[mij] == x) return mij;
        else if (a[mij] < x) st = mij + 1;
        else dr = mij - 1;
    }
    return -1;
}

int main() {
    vector<int> lista = {2, 5, 7, 12, 17, 23, 31, 45, 58, 72};
    cout << cautare_binara(lista, 23);  // 5
    return 0;
}

def cautare_binara_rec(a, x, st, dr):
    if st > dr:
        return -1
    mij = (st + dr) // 2
    if a[mij] == x:
        return mij
    elif a[mij] < x:
        return cautare_binara_rec(a, x, mij + 1, dr)
    else:
        return cautare_binara_rec(a, x, st, mij - 1)

lista = [2, 5, 7, 12, 17, 23, 31, 45, 58, 72]
print(cautare_binara_rec(lista, 23, 0, len(lista) - 1))  # 5

A = [1, 4, 7, 9]
B = [2, 3, 8, 10, 15]

i=0, j=0: A[0]=1 < B[0]=2 → adaugăm 1   Rezultat: [1]
i=1, j=0: A[1]=4 > B[0]=2 → adaugăm 2   Rezultat: [1, 2]
i=1, j=1: A[1]=4 > B[1]=3 → adaugăm 3   Rezultat: [1, 2, 3]
i=1, j=2: A[1]=4 < B[2]=8 → adaugăm 4   Rezultat: [1, 2, 3, 4]
i=2, j=2: A[2]=7 < B[2]=8 → adaugăm 7   Rezultat: [1, 2, 3, 4, 7]
i=3, j=2: A[3]=9 > B[2]=8 → adaugăm 8   Rezultat: [1, 2, 3, 4, 7, 8]
i=3, j=3: A[3]=9 < B[3]=10 → adaugăm 9  Rezultat: [1, 2, 3, 4, 7, 8, 9]
A epuizată → copiem rest din B         Rezultat: [1, 2, 3, 4, 7, 8, 9, 10, 15]

def interclasare(a, b):
    rezultat = []
    i, j = 0, 0
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            rezultat.append(a[i])
            i += 1
        else:
            rezultat.append(b[j])
            j += 1
    # Copiem elementele rămase (doar una din bucle va executa)
    while i < len(a):
        rezultat.append(a[i])
        i += 1
    while j < len(b):
        rezultat.append(b[j])
        j += 1
    return rezultat

A = [1, 4, 7, 9]
B = [2, 3, 8, 10, 15]
print(interclasare(A, B))
# [1, 2, 3, 4, 7, 8, 9, 10, 15]

vector<int> interclasare(vector<int>& a, vector<int>& b) {
    vector<int> rezultat;
    int i = 0, j = 0;
    while (i < a.size() && j < b.size()) {
        if (a[i] <= b[j]) rezultat.push_back(a[i++]);
        else              rezultat.push_back(b[j++]);
    }
    while (i < a.size()) rezultat.push_back(a[i++]);
    while (j < b.size()) rezultat.push_back(b[j++]);
    return rezultat;
}

         A           B
      ┌─────┐     ┌─────┐
      │  1  │     │  5  │
      │  2  │  3  │  6  │
      │     │  4  │     │
      └─────┘─────└─────┘
              ↑
         A ∩ B = {3, 4}

# Mulțime vidă — ATENȚIE: {} este dicționar, nu set!
m = set()

# Mulțime cu valori
fructe = {"mere", "pere", "banane"}
numere = {1, 2, 3, 4, 5}

# Din listă (elimină automat duplicatele)
lista = [1, 2, 2, 3, 3, 3, 4]
unice = set(lista)  # {1, 2, 3, 4}

# Set comprehension
patrate = {x*x for x in range(1, 6)}  # {1, 4, 9, 16, 25}

# Corect
m = {1, 2, "text", (3, 4)}

# EROARE — lista este mutabilă
# m = {1, 2, [3, 4]}  # TypeError: unhashable type: 'list'

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

print(A | B)   # {1, 2, 3, 4, 5, 6}
print(A & B)   # {3, 4}
print(A - B)   # {1, 2}
print(A ^ B)   # {1, 2, 5, 6}
print(3 in A)  # True
print({1, 2} <= A)  # True (subset)
print(A == B)  # False

m = {1, 2, 3}

# Adăugare
m.add(4)              # {1, 2, 3, 4}
m.add(2)              # {1, 2, 3, 4}  — fără efect, deja exista

# Eliminare
m.remove(2)           # {1, 3, 4}  — eroare dacă nu există
m.discard(99)         # {1, 3, 4}  — nu dă eroare dacă nu există
x = m.pop()           # elimină și returnează un element oarecare

# Operații cu returnare (nu modifică mulțimea originală)
A = {1, 2, 3}
B = {3, 4, 5}
print(A.union(B))         # {1, 2, 3, 4, 5}
print(A.intersection(B))  # {3}
print(A.difference(B))    # {1, 2}

# Operații care modifică mulțimea
A.update(B)               # A devine A ∪ B
A.intersection_update(B)  # A devine A ∩ B

# Copiere
C = A.copy()

# Verificări
print(A.issubset({1, 2, 3, 4}))    # True
print(A.issuperset({1, 2}))         # True
print(A.isdisjoint({9, 10}))        # True — nu au elemente comune

#include <iostream>
#include <set>
#include <unordered_set>
using namespace std;

int main() {
    set<int> A = {3, 1, 4, 1, 5, 9, 2, 6};  // duplicatele se elimină

    // set este ORDONAT
    for (int x : A) cout << x << " ";
    // Ieșire: 1 2 3 4 5 6 9

    A.insert(7);
    A.erase(4);

    if (A.count(3)) cout << "3 există";
    if (A.find(10) == A.end()) cout << "10 nu există";

    // Reuniune și intersecție — din <algorithm>
    set<int> B = {4, 5, 6, 7};
    set<int> reuniune;
    set_union(A.begin(), A.end(), B.begin(), B.end(),
              inserter(reuniune, reuniune.begin()));
    return 0;
}

def elimina_duplicate(lista):
    return list(set(lista))

print(elimina_duplicate([1, 2, 2, 3, 3, 3, 4]))  # [1, 2, 3, 4]

def cifre_distincte(n):
    return set(str(n))  # convertim în șir, apoi în mulțime

print(cifre_distincte(122334))  # {'1', '2', '3', '4'}

def sunt_anagrame(s1, s2):
    # Pentru verificare cu frecvențe, nu doar mulțimi:
    return sorted(s1) == sorted(s2)
    # set(s1) == set(s2) este INSUFICIENT! 
    # Ex: "aab" și "abb" au același set dar nu sunt anagrame

print(sunt_anagrame("listen", "silent"))  # True
print(sunt_anagrame("aab", "abb"))         # False

def cifre_comune(a, b):
    cifre_a = set(str(a))
    cifre_b = set(str(b))
    return cifre_a & cifre_b

print(cifre_comune(12345, 56789))  # {'5'}

import random

def bingo(cate, minim, maxim):
    numere = set()
    while len(numere) < cate:
        numere.add(random.randint(minim, maxim))
    return sorted(numere)

print(bingo(6, 1, 49))  # 6 numere distincte din 1..49

print(ord('A'))   # 65 — codul numeric
print(ord('ă'))   # 259 — caracter românesc
print(chr(65))    # 'A' — caracterul de la codul 65
print(chr(8364))  # '€' — simbolul euro

s = "Programare"
#    0123456789
#   -10-9...-1

# Acces la caracter
print(s[0])    # 'P'
print(s[4])    # 'r'
print(s[-1])   # 'e'  (ultimul)
print(s[-2])   # 'r'  (penultimul)

# Slicing [start:stop:step]
print(s[0:4])   # "Prog"  (poziții 0, 1, 2, 3)
print(s[4:])    # "ramare"
print(s[:4])    # "Prog"
print(s[::2])   # "Pormr"  (din 2 în 2)
print(s[::-1])  # "eramargorP"  (inversat)

s = "Alex"
# s[0] = 'M'  # EROARE!

# Trebuie să creezi un șir NOU
s_nou = "M" + s[1:]  # "Mlex"

s = "Python"

# Prin caracter
for c in s:
    print(c)

# Prin index
for i in range(len(s)):
    print(f"s[{i}] = {s[i]}")

# Prin index și caracter
for i, c in enumerate(s):
    print(f"{i}: {c}")

s1 = 'Salut'              # apostrofuri simple
s2 = "Alex"                # ghilimele duble
s3 = '''Text pe
mai multe linii'''         # apostrofuri triple
s4 = """La fel cu 
ghilimele triple"""
s5 = "El a spus: \"Salut\""  # escape cu backslash
s6 = 'El a spus: "Salut"'    # mai elegant

s = "Salut"
t = "lume"

# Concatenare
print(s + " " + t)    # "Salut lume"

# Multiplicare
print("ab" * 3)        # "ababab"
print("-" * 20)        # "--------------------"

# Apartenență
print("lut" in s)      # True
print("xyz" in s)      # False
print("ab" not in s)   # True

# Comparare (lexicografică — ordine alfabetică)
print("abc" < "abd")   # True
print("abc" < "abcd")  # True (mai scurt = mai mic la prefix)
print("Abc" < "abc")   # True (majuscula < minuscula în ASCII)

# Dimensiune
print(len(s))          # 5

s = "Bună Ziua, Alex!"

print(s.upper())       # "BUNĂ ZIUA, ALEX!"
print(s.lower())       # "bună ziua, alex!"
print(s.title())       # "Bună Ziua, Alex!" — fiecare cuvânt cu majusculă
print(s.capitalize())  # "Bună ziua, alex!" — doar prima literă
print(s.swapcase())    # "bUNĂ zIUA, aLEX!" — inversează

print("abc123".isalnum())   # True — litere și cifre
print("abc".isalpha())       # True — doar litere
print("123".isdigit())       # True — doar cifre
print("   ".isspace())       # True — doar spații
print("ABC".isupper())       # True
print("abc".islower())       # True
print("Title Text".istitle()) # True

s = "Bună ziua, bună seara"

# Indexul primei apariții
print(s.find("bună"))      # 11
print(s.find("xyz"))       # -1 (nu există)
print(s.index("bună"))     # 11 (ERoare dacă nu există)

# Indexul ultimei apariții
print(s.rfind("bună"))     # 11 (doar una este aici)

# Numărul de apariții
print(s.count("bună"))     # 1 (case-sensitive!)
print(s.lower().count("bună"))  # 2

# Verifică început/sfârșit
print(s.startswith("Bună"))   # True
print(s.endswith("seara"))    # True

s = "  Salut, lume!  "

# Eliminare spații
print(s.strip())        # "Salut, lume!"
print(s.lstrip())       # "Salut, lume!  "
print(s.rstrip())       # "  Salut, lume!"

# Înlocuire
print("abcabc".replace("a", "X"))     # "XbcXbc"
print("abcabc".replace("a", "X", 1))  # "Xbcabc" — doar prima apariție

# Divizare
print("a,b,c,d".split(","))            # ["a", "b", "c", "d"]
print("unul doi trei".split())         # ["unul", "doi", "trei"] — spații
print("abc\ndef\nghi".splitlines())    # ["abc", "def", "ghi"]

# Alipire (inversul lui split)
print("-".join(["2024", "01", "15"]))  # "2024-01-15"
print(" ".join(["Alex", "e", "aici"])) # "Alex e aici"

nume = "Alex"
varsta = 15
media = 9.723456

# f-strings (Python 3.6+)
print(f"Salut, {nume}! Ai {varsta} ani.")
print(f"Media: {media:.2f}")         # 2 zecimale
print(f"Media: {media:8.2f}")         # 8 caractere total, 2 zecimale
print(f"Procent: {0.85:.0%}")         # "85%"

# Format alternativ
print("Salut, {}! Ai {} ani.".format(nume, varsta))
print("Media: %.2f" % media)

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

int main() {
    string s = "Salut";
    string t = "lume";

    // Concatenare
    string u = s + " " + t;         // "Salut lume"
    s += "!";                        // "Salut!"

    // Acces la caracter
    cout << s[0] << endl;            // 'S'
    cout << s.length() << endl;      // 6 (len)
    cout << s.size() << endl;        // 6 (tot len)

    // Substring
    cout << s.substr(0, 3) << endl;  // "Sal" (poz 0, lungime 3)

    // Căutare
    cout << s.find("lut") << endl;   // 2
    cout << s.find("xy") << endl;    // string::npos (-1 in practica)

    // Înlocuire
    string v = "abcabc";
    size_t pos = v.find("a");
    if (pos != string::npos) v.replace(pos, 1, "X");  // "Xbcabc"

    // Conversii (C++11+)
    int nr = stoi("42");
    double r = stod("3.14");
    string snr = to_string(123);

    // Transformare (manuală cu <algorithm>)
    string w = "Hello";
    transform(w.begin(), w.end(), w.begin(), ::tolower);  // "hello"

    // Comparare lexicografică
    cout << (string("abc") < string("abd")) << endl;  // 1 (true)

    return 0;
}

def email_valid(s):
    return s.count("@") == 1 and "." in s.split("@")[1] and " " not in s

print(email_valid("alex@exemplu.ro"))    # True
print(email_valid("alex@@exemplu.ro"))   # False
print(email_valid("alex@exemplu"))       # False
print(email_valid("alex exemplu.ro"))    # False

def numar_vocale(s):
    vocale = set("aeiouăîâAEIOUĂÎÂ")
    return sum(1 for c in s if c in vocale)

print(numar_vocale("Bună ziua, Alex!"))  # 7

def caesar_cripteaza(text, k):
    rezultat = ""
    for c in text:
        if c.isupper():
            rezultat += chr((ord(c) - ord('A') + k) % 26 + ord('A'))
        elif c.islower():
            rezultat += chr((ord(c) - ord('a') + k) % 26 + ord('a'))
        else:
            rezultat += c  # caracterele non-literă rămân neschimbate
    return rezultat

def caesar_decripteaza(text, k):
    return caesar_cripteaza(text, -k)

mesaj = "Salut, Alex!"
cifrat = caesar_cripteaza(mesaj, 3)
print(cifrat)                            # "Vdoxw, Doha!"
print(caesar_decripteaza(cifrat, 3))     # "Salut, Alex!"

def este_palindrom(s):
    s_curat = ''.join(c.lower() for c in s if c.isalnum())
    return s_curat == s_curat[::-1]

print(este_palindrom("capac"))               # True
print(este_palindrom("Ele fac cafele"))      # True
print(este_palindrom("python"))              # False

def frecventa_cuvinte(text):
    cuvinte = text.lower().split()
    frecv = {}
    for c in cuvinte:
        c_curat = c.strip(".,!?;:")
        frecv[c_curat] = frecv.get(c_curat, 0) + 1
    return frecv

text = "Ana are mere. Mere sunt roșii. Ana iubește mere."
print(frecventa_cuvinte(text))
# {'ana': 2, 'are': 1, 'mere': 3, 'sunt': 1, 'roșii': 1, 'iubește': 1}

indice:    0       1         2      3
valori: "Ana"  "Bogdan"  "Ion"  "Maria"

chei:     "Ana"  "Bogdan"  "Ion"  "Maria"
valori:     9      10        7      8

# Dicționar vid
d1 = {}
d2 = dict()

# Cu valori
note = {"Ana": 9, "Bogdan": 10, "Ion": 7}
persoana = {
    "nume": "Alex",
    "varsta": 15,
    "oras": "București"
}

# Din liste de perechi
perechi = [("a", 1), ("b", 2), ("c", 3)]
d = dict(perechi)  # {"a": 1, "b": 2, "c": 3}

# Cu zip
chei = ["a", "b", "c"]
valori = [1, 2, 3]
d = dict(zip(chei, valori))  # {"a": 1, "b": 2, "c": 3}

# Dict comprehension
patrate = {x: x*x for x in range(1, 6)}
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

note = {"Ana": 9, "Bogdan": 10, "Ion": 7}

# Acces direct
print(note["Ana"])       # 9
# print(note["Maria"])   # EROARE — KeyError

# Acces sigur cu get()
print(note.get("Ana"))           # 9
print(note.get("Maria"))         # None — fără eroare
print(note.get("Maria", 0))      # 0 — valoare implicită

# Adăugare / modificare
note["Maria"] = 8       # adaugă cheie nouă
note["Ana"] = 10        # modifică valoarea existentă

# Verificare existență
print("Ana" in note)        # True
print("Xyz" in note)        # False
print("Ana" not in note)    # False

note = {"Ana": 9, "Bogdan": 10, "Ion": 7}

# Obținere vizualizări (view objects)
print(list(note.keys()))    # ["Ana", "Bogdan", "Ion"]
print(list(note.values()))  # [9, 10, 7]
print(list(note.items()))   # [("Ana", 9), ("Bogdan", 10), ("Ion", 7)]

# Eliminare
x = note.pop("Ion")         # x = 7, cheia "Ion" este eliminată
# note.pop("Xyz")           # EROARE
y = note.pop("Xyz", None)   # y = None, fără eroare

ultimul = note.popitem()    # elimină și returnează (cheie, valoare) ultima adăugată

note.clear()                # golește dicționarul

# Actualizare cu alt dicționar
note = {"Ana": 9}
alte_note = {"Bogdan": 10, "Ana": 8}
note.update(alte_note)     # {"Ana": 8, "Bogdan": 10}  — actualizat!

# setdefault — adaugă cheia doar dacă nu există
note.setdefault("Cristina", 7)  # adaugă "Cristina": 7
note.setdefault("Ana", 5)       # NU modifică, "Ana" există deja

# fromkeys — creează dict cu chei date și valoare comună
d = dict.fromkeys(["a", "b", "c"], 0)   # {"a": 0, "b": 0, "c": 0}
d = dict.fromkeys(["a", "b", "c"])      # {"a": None, "b": None, "c": None}

# Copiere
note_copie = note.copy()

note = {"Ana": 9, "Bogdan": 10, "Ion": 7}

# Implicit — iterează pe CHEI
for k in note:
    print(k, "->", note[k])

# Explicit pe chei
for k in note.keys():
    print(k)

# Pe valori
for v in note.values():
    print(v)

# Pe perechi (recomandat)
for k, v in note.items():
    print(f"{k}: {v}")

note = {"Ana": 9, "Bogdan": 10, "Ion": 7, "Maria": 8}

# Suma valorilor
total = sum(note.values())      # 34

# Media
medie = sum(note.values()) / len(note)  # 8.5

# Elevul cu nota maximă
elev_max = max(note, key=note.get)    # "Bogdan"
# Alternativ:
elev_max = max(note.items(), key=lambda x: x[1])[0]

# Elevi cu notă >= 9
premiați = {k: v for k, v in note.items() if v >= 9}
# {"Ana": 9, "Bogdan": 10}

# Inversare chei-valori (atenție la duplicate!)
inversat = {v: k for k, v in note.items()}

elevi = {
    "Alex": {
        "varsta": 15,
        "clasa": "9A",
        "note": [9, 8, 10]
    },
    "Maria": {
        "varsta": 16,
        "clasa": "10B",
        "note": [10, 9, 9]
    }
}

# Acces
print(elevi["Alex"]["clasa"])        # "9A"
print(elevi["Alex"]["note"][0])      # 9

# Modificare
elevi["Alex"]["note"].append(7)

# Adăugare elev nou
elevi["Cristina"] = {
    "varsta": 15,
    "clasa": "9A",
    "note": []
}

# Afișare
for nume, date in elevi.items():
    print(f"{nume}: clasa {date['clasa']}, media {sum(date['note'])/len(date['note']):.2f}")

stoc1 = {"pâine": 5, "lapte": 3}
stoc2 = {"ouă": 12, "lapte": 2}

# Operator | (unire)
total = stoc1 | stoc2      # {"pâine": 5, "lapte": 2, "ouă": 12}
# La cheile comune, rămâne valoarea din al doilea

# Operator |= (actualizează pe loc)
stoc1 |= stoc2

# Unpacking (funcționează și în versiuni mai vechi)
total = {**stoc1, **stoc2}

def frecvente(s):
    f = {}
    for c in s:
        f[c] = f.get(c, 0) + 1
    return f

print(frecvente("informatica"))
# {'i': 2, 'n': 1, 'f': 1, 'o': 1, 'r': 1, 'm': 1, 'a': 2, 't': 1, 'c': 1}

dict_ro_en = {
    "mere": "apple",
    "pere": "pear",
    "struguri": "grapes",
    "căpșune": "strawberries"
}

def tradu(cuvant):
    return dict_ro_en.get(cuvant.lower(), "cuvânt necunoscut")

print(tradu("Mere"))    # "apple"
print(tradu("banane"))  # "cuvânt necunoscut"

def agenda_interactiva():
    agenda = {}
    while True:
        print("\n1. Adaugă  2. Caută  3. Șterge  4. Afișează tot  0. Ieșire")
        op = input("Opțiune: ")
        if op == "1":
            nume = input("Nume: ")
            tel = input("Telefon: ")
            agenda[nume] = tel
        elif op == "2":
            nume = input("Nume: ")
            print(agenda.get(nume, "Nu există"))
        elif op == "3":
            nume = input("Nume: ")
            if agenda.pop(nume, None):
                print("Șters.")
            else:
                print("Nu există.")
        elif op == "4":
            for n, t in sorted(agenda.items()):
                print(f"{n}: {t}")
        elif op == "0":
            break

# agenda_interactiva()

stoc = {
    "pâine":     {"pret": 3.50, "cantitate": 50},
    "lapte":     {"pret": 6.00, "cantitate": 30},
    "ouă":       {"pret": 1.20, "cantitate": 200},
}

def valoare_totala(stoc):
    return sum(d["pret"] * d["cantitate"] for d in stoc.values())

def actualizeaza_pret(stoc, produs, pret_nou):
    if produs in stoc:
        stoc[produs]["pret"] = pret_nou
    else:
        print(f"Produsul {produs} nu există.")

def produse_scumpe(stoc, prag):
    return [p for p, d in stoc.items() if d["pret"] > prag]

print(f"Valoare totală: {valoare_totala(stoc):.2f} lei")
print(f"Produse > 5 lei: {produse_scumpe(stoc, 5)}")

# Matrice 3x4 — 3 rânduri, 4 coloane
matrice = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]

# Acces: matrice[rând][coloană]
print(matrice[0][0])   # 1
print(matrice[2][3])   # 12
print(matrice[1])      # [5, 6, 7, 8] — un rând întreg

# Dimensiuni
n = len(matrice)         # 3 rânduri
m = len(matrice[0])      # 4 coloane

# Parcurgere
for i in range(n):
    for j in range(m):
        print(matrice[i][j], end=" ")
    print()

n, m = 3, 4

# CORECT
M = [[0] * m for _ in range(n)]

# GREȘIT! — toate rândurile se referă la ACEEAȘI listă!
# M = [[0] * m] * n

# Verificare
M[0][1] = 99
print(M)  # cu metoda corectă, doar primul rând are 99

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

int main() {
    // Tablou static
    int m[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    // Vector dinamic
    vector<vector<int>> M(3, vector<int>(4, 0));
    M[1][2] = 99;

    // Parcurgere
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            cout << m[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

# 4 persoane: Ana(0), Bogdan(1), Cristina(2), Daniel(3)
# Ana e prietenă cu Bogdan și Cristina
# Bogdan e prieten cu Ana și Daniel
# Cristina e prietenă cu Ana
# Daniel e prieten cu Bogdan
prietenii = [
    [0, 1, 1, 0],   # Ana
    [1, 0, 0, 1],   # Bogdan
    [1, 0, 0, 0],   # Cristina
    [0, 1, 0, 0]    # Daniel
]

# Câți prieteni are fiecare persoană?
nume = ["Ana", "Bogdan", "Cristina", "Daniel"]
for i, n in enumerate(nume):
    print(f"{n}: {sum(prietenii[i])} prieteni")

def vecini_elementului(M, i, j):
    n, m = len(M), len(M[0])
    directii = [(-1, -1), (-1, 0), (-1, 1),
                ( 0, -1),          ( 0, 1),
                ( 1, -1), ( 1, 0), ( 1, 1)]
    vecini = []
    for di, dj in directii:
        ni, nj = i + di, j + dj
        if 0 <= ni < n and 0 <= nj < m:
            vecini.append(M[ni][nj])
    return vecini

# Matricea originală 3x3
M = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Bordată cu 0 — devine 5x5
bordata = [
    [0, 0, 0, 0, 0],
    [0, 1, 2, 3, 0],
    [0, 4, 5, 6, 0],
    [0, 7, 8, 9, 0],
    [0, 0, 0, 0, 0]
]

# Acum putem accesa M[i-1][j-1] fără să verificăm

elevi = [
    {"nume": "Ana", "varsta": 15, "media": 9.5},
    {"nume": "Bogdan", "varsta": 16, "media": 8.7},
    {"nume": "Cristina", "varsta": 15, "media": 9.8},
    {"nume": "Daniel", "varsta": 17, "media": 7.2}
]

# Filtrare
buni = [e for e in elevi if e["media"] >= 9]

# Sortare după un câmp
elevi_sortati = sorted(elevi, key=lambda e: e["media"], reverse=True)

# Media generală
medie_generala = sum(e["media"] for e in elevi) / len(elevi)

# Găsire după criteriu
ana = next((e for e in elevi if e["nume"] == "Ana"), None)

# Elevii grupați pe clase
clase = {
    "9A": ["Ana", "Bogdan", "Cristina"],
    "10B": ["Daniel", "Elena"],
    "11C": ["Florin", "Gabriela", "Horia"]
}

# Adăugare elev
clase["9A"].append("Ion")

# Număr total elevi
total = sum(len(l) for l in clase.values())

# Crearea automată a grupurilor
elevi_plati = [("Ana", "9A"), ("Bogdan", "9A"), ("Daniel", "10B")]
grupate = {}
for nume, clasa in elevi_plati:
    grupate.setdefault(clasa, []).append(nume)

# Evidență magazin: produs → detalii
magazin = {
    "001": {"denumire": "Pâine", "pret": 3.50, "stoc": 50},
    "002": {"denumire": "Lapte", "pret": 6.00, "stoc": 30},
    "003": {"denumire": "Ouă", "pret": 0.80, "stoc": 200}
}

# Acces
print(magazin["001"]["denumire"])

# Modificare
magazin["001"]["pret"] = 4.00

# Adăugare produs nou
magazin["004"] = {"denumire": "Unt", "pret": 12.00, "stoc": 15}

# Valoare totală stoc
valoare = sum(p["pret"] * p["stoc"] for p in magazin.values())

def atacuri_regina(tabla, i, j):
    """Returnează nr. reginei inamice atacate de cea de la (i,j)."""
    culoare = tabla[i][j]
    if culoare == 0:
        return 0

    directii = [(-1, 0), (1, 0), (0, -1), (0, 1),   # ortogonale
                (-1, -1), (-1, 1), (1, -1), (1, 1)]  # diagonale

    atacuri = 0
    n = len(tabla)
    for di, dj in directii:
        ni, nj = i + di, j + dj
        while 0 <= ni < n and 0 <= nj < n:
            if tabla[ni][nj] != 0:
                if tabla[ni][nj] != culoare:  # culoare opusă
                    atacuri += 1
                break  # oprire la prima piesă întâlnită
            ni += di
            nj += dj
    return atacuri

0! = 1                  (cazul de bază)
n! = n × (n-1)!         (pasul recursiv)

def factorial(n):
    if n == 0 or n == 1:       # caz de bază
        return 1
    return n * factorial(n - 1) # pas recursiv

print(factorial(5))  # 120

int factorial(int n) {
    if (n == 0 || n == 1) return 1;
    return n * factorial(n - 1);
}

factorial(5)
  └─ 5 * factorial(4)
       └─ 4 * factorial(3)
            └─ 3 * factorial(2)
                 └─ 2 * factorial(1)
                      └─ return 1     ← caz de bază
                 ← return 2*1 = 2
            ← return 3*2 = 6
       ← return 4*6 = 24
  ← return 5*24 = 120

# Directă
def A(n):
    if n == 0: return
    A(n - 1)

# Indirectă (A → B → A → B ...)
def par(n):
    if n == 0: return True
    return impar(n - 1)

def impar(n):
    if n == 0: return False
    return par(n - 1)

print(par(10))   # True
print(impar(7))  # True

def suma_cifre(n):
    if n == 0:
        return 0
    return n % 10 + suma_cifre(n // 10)

print(suma_cifre(1234))  # 10

def suma_lista(lista, i=0):
    if i == len(lista):
        return 0
    return lista[i] + suma_lista(lista, i + 1)

# Sau, mai elegant:
def suma_lista_v2(lista):
    if not lista:
        return 0
    return lista[0] + suma_lista_v2(lista[1:])

print(suma_lista([1, 2, 3, 4, 5]))    # 15
print(suma_lista_v2([1, 2, 3, 4, 5])) # 15

def cmmdc(a, b):
    if b == 0:
        return a
    return cmmdc(b, a % b)

print(cmmdc(48, 18))  # 6

def putere(a, n):
    if n == 0:
        return 1
    if n % 2 == 0:                    # putere pară
        jumatate = putere(a, n // 2)
        return jumatate * jumatate
    return a * putere(a, n - 1)       # putere impară

print(putere(2, 10))  # 1024

def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)

print(fib(10))  # 55
# fib(30) durează 1-2 secunde
# fib(40) durează zeci de secunde!

fib(5)
├── fib(4)                         ← calculat 1 dată
│   ├── fib(3)                     ← calculat 2 ori
│   │   ├── fib(2)                 ← calculat 3 ori
│   │   │   ├── fib(1) → 1
│   │   │   └── fib(0) → 0
│   │   └── fib(1) → 1
│   └── fib(2)                     ← recalculat!
│       ├── fib(1) → 1
│       └── fib(0) → 0
└── fib(3)                         ← recalculat!
    ...

def fib_memo(n, cache={}):
    if n in cache:
        return cache[n]
    if n < 2:
        return n
    cache[n] = fib_memo(n-1, cache) + fib_memo(n-2, cache)
    return cache[n]

print(fib_memo(100))  # 354224848179261915075 — instantaneu!

# Recursiv
def suma_rec(n):
    if n == 0:
        return 0
    return n + suma_rec(n - 1)

# Iterativ
def suma_iter(n):
    s = 0
    for i in range(1, n + 1):
        s += i
    return s

# Formula directă O(1)
def suma_formula(n):
    return n * (n + 1) // 2

def comb(n, k):
    if k == 0 or k == n:
        return 1
    return comb(n-1, k-1) + comb(n-1, k)

print(comb(5, 2))  # 10

f(n) = ceva + f(n-1)

f(n) = f(n-1) + f(n-2)

f(n) = combine(f(n/2), f(n/2))

DIVIDE_IMPERA(problema):
    dacă problema este simplă:
        rezolvă direct
    altfel:
        împarte problema în subprobleme
        rezolvă fiecare subproblemă prin DIVIDE_IMPERA
        combină soluțiile

def max_di(lista, st, dr):
    if st == dr:                       # caz de bază: un singur element
        return lista[st]
    mij = (st + dr) // 2
    max_stg = max_di(lista, st, mij)      # rezolvă stânga
    max_drp = max_di(lista, mij + 1, dr)  # rezolvă dreapta
    return max(max_stg, max_drp)          # combină

lista = [3, 7, 2, 9, 1, 8, 5]
print(max_di(lista, 0, len(lista) - 1))  # 9

def suma_di(lista, st, dr):
    if st == dr:
        return lista[st]
    mij = (st + dr) // 2
    return suma_di(lista, st, mij) + suma_di(lista, mij + 1, dr)

print(suma_di([1, 2, 3, 4, 5], 0, 4))  # 15

def interclasare(a, b):
    rezultat = []
    i = j = 0
    while i < len(a) and j < len(b):
        if a[i] <= b[j]:
            rezultat.append(a[i]); i += 1
        else:
            rezultat.append(b[j]); j += 1
    rezultat += a[i:]
    rezultat += b[j:]
    return rezultat

def merge_sort(lista):
    if len(lista) <= 1:
        return lista
    mij = len(lista) // 2
    stanga = merge_sort(lista[:mij])
    dreapta = merge_sort(lista[mij:])
    return interclasare(stanga, dreapta)

print(merge_sort([5, 3, 8, 1, 9, 2, 7]))
# [1, 2, 3, 5, 7, 8, 9]

                    [5, 3, 8, 1, 9, 2, 7]
                      /                \
                 [5, 3, 8]             [1, 9, 2, 7]
                  /     \                /       \
                [5]   [3, 8]          [1, 9]   [2, 7]
                       /  \            / \      /  \
                     [3]  [8]        [1] [9]  [2]  [7]
                       \  /           \ /      \ /
                       [3,8]          [1,9]    [2,7]
                    /       \            \     /
                [3, 5, 8]              [1, 2, 7, 9]
                        \              /
                       [1, 2, 3, 5, 7, 8, 9]

#include <vector>
using namespace std;

vector<int> interclasare(vector<int>& a, vector<int>& b) {
    vector<int> rez;
    int i = 0, j = 0;
    while (i < a.size() && j < b.size()) {
        if (a[i] <= b[j]) rez.push_back(a[i++]);
        else              rez.push_back(b[j++]);
    }
    while (i < a.size()) rez.push_back(a[i++]);
    while (j < b.size()) rez.push_back(b[j++]);
    return rez;
}

vector<int> merge_sort(vector<int> v) {
    if (v.size() <= 1) return v;
    int mij = v.size() / 2;
    vector<int> stg(v.begin(), v.begin() + mij);
    vector<int> drp(v.begin() + mij, v.end());
    stg = merge_sort(stg);
    drp = merge_sort(drp);
    return interclasare(stg, drp);
}

def hanoi(n, sursa, auxiliar, destinatie):
    if n == 1:
        print(f"Mută discul 1 de pe {sursa} pe {destinatie}")
        return
    hanoi(n - 1, sursa, destinatie, auxiliar)
    print(f"Mută discul {n} de pe {sursa} pe {destinatie}")
    hanoi(n - 1, auxiliar, sursa, destinatie)

hanoi(3, 'A', 'B', 'C')
# Mută discul 1 de pe A pe C
# Mută discul 2 de pe A pe B
# Mută discul 1 de pe C pe B
# Mută discul 3 de pe A pe C
# Mută discul 1 de pe B pe A
# Mută discul 2 de pe B pe C
# Mută discul 1 de pe A pe C

def putere(a, n):
    if n == 0: return 1
    if n % 2 == 0:
        x = putere(a, n // 2)
        return x * x          # combinare: x * x
    return a * putere(a, n - 1)

import turtle

def sierpinski(t, l, nivel):
    if nivel == 0:
        for _ in range(3):
            t.forward(l)
            t.left(120)
        return
    sierpinski(t, l / 2, nivel - 1)
    t.forward(l / 2)
    sierpinski(t, l / 2, nivel - 1)
    t.backward(l / 2)
    t.left(60)
    t.forward(l / 2)
    t.right(60)
    sierpinski(t, l / 2, nivel - 1)
    t.left(60)
    t.backward(l / 2)
    t.right(60)

# t = turtle.Turtle()
# sierpinski(t, 200, 4)
# turtle.done()

T(n) = a · T(n/b) + O(n^d)

Activități: A(1-4), B(3-5), C(0-6), D(5-7), E(3-9), F(5-9), G(6-10), H(8-11)

def selectie_activitati(activitati):
    # activitati = listă de tuple (start, sfarsit)
    # Sortare după sfârșit
    activitati_sortate = sorted(activitati, key=lambda x: x[1])

    selectate = [activitati_sortate[0]]
    ultim_sfarsit = activitati_sortate[0][1]

    for start, sfarsit in activitati_sortate[1:]:
        if start >= ultim_sfarsit:
            selectate.append((start, sfarsit))
            ultim_sfarsit = sfarsit
    return selectate

activitati = [(1,4), (3,5), (0,6), (5,7), (3,9), (5,9), (6,10), (8,11)]
print(selectie_activitati(activitati))
# [(1, 4), (5, 7), (8, 11)]  — 3 activități