Python — Partea 3: Exerciții simple și foarte simple

def al_doilea_maxim(a):
    distincte = set(a)
    if len(distincte) < 2:
        raise ValueError("Nu există al doilea maxim distinct.")
    maxim = max(distincte)
    return max(x for x in distincte if x != maxim)

def suma_si_produs(a):
    suma_pare = 0
    produs_impare = 1
    exista_impar = False
    for x in a:
        if x % 2 == 0:
            suma_pare += x
        else:
            produs_impare *= x
            exista_impar = True
    return suma_pare, produs_impare if exista_impar else 0

def prefix_sufix(s):
    for lungime in range(len(s) - 1, 0, -1):
        if s[:lungime] == s[-lungime:]:
            return s[:lungime]
    return 

def sume_dreapta(a):
    rezultat = [0] * len(a)
    suma = 0
    for i in range(len(a) - 1, -1, -1):
        rezultat[i] = suma
        suma += a[i]
    return rezultat

def impartire_egala(a):
    total = sum(a)
    stanga = 0
    for x in a[:-1]:
        stanga += x
        if stanga * 2 == total:
            return True
    return False

def diferenta_ordonata(a, b):
    b = set(b)
    return [x for x in a if x not in b]

def comprimare(a):
    if not a:
        return []
    rezultat = []
    curent = a[0]
    nr = 1
    for x in a[1:]:
        if x == curent:
            nr += 1
        else:
            rezultat.append((curent, nr))
            curent, nr = x, 1
    rezultat.append((curent, nr))
    return rezultat

def crescatoare_maxima(a):
    if not a:
        return []
    best = curent = [a[0]]
    for x in a[1:]:
        if x > curent[-1]:
            curent.append(x)
        else:
            curent = [x]
        if len(curent) > len(best):
            best = curent[:]
    return best

def nr_divizori(n):
    nr = 0
    for d in range(1, int(n ** 0.5) + 1):
        if n % d == 0:
            nr += 2 if d * d != n else 1
    return nr

def lungime_suma_zero(a):
    prima = {0: -1}
    suma = best = 0
    for i, x in enumerate(a):
        suma += x
        if suma in prima:
            best = max(best, i - prima[suma])
        else:
            prima[suma] = i
    return best

def interschimba(a, b):
    return b, a
# Exemplu: x, y = interschimba(x, y)

def invers(n):
    semn = -1 if n < 0 else 1
    n = abs(n)
    rezultat = 0
    while n:
        rezultat = rezultat * 10 + n % 10
        n //= 10
    return semn * rezultat

def frecventa_maxima(a):
    f = {}
    for x in a:
        f[x] = f.get(x, 0) + 1
    return min(f, key=lambda x: (-f[x], x))

def cuvinte_capete_egale(s):
    nr = 0
    for cuvant in s.split():
        if cuvant and cuvant[0].lower() == cuvant[-1].lower():
            nr += 1
    return nr

def urmator_palindrom(n):
    x = n + 1
    while str(x) != str(x)[::-1]:
        x += 1
    return x

def pozitii_minim(a):
    m = min(a)
    return [i for i, x in enumerate(a) if x == m]

def suma_diagonala(m):
    return sum(m[i][i] for i in range(min(len(m), len(m[0]))))

def negative_in_fata(a):
    return [x for x in a if x < 0] + [x for x in a if x >= 0]

def lungime_intersectie(a, b, c, d):
    st = max(a, c)
    dr = min(b, d)
    return max(0, dr - st)

def puncte_minime(intervale):
    intervale = sorted(intervale, key=lambda x: x[1])
    puncte = []
    for st, dr in intervale:
        if not puncte or puncte[-1] < st:
            puncte.append(dr)
    return puncte

def peste_prag(a, prag=0):
    return sum(x > prag for x in a)

def medie(*numere):
    if not numere:
        return 0
    return sum(numere) / len(numere)

def valori_la_indici(a, *indici):
    return [a[i] for i in indici]

def materia_maxima(**note):
    return max(note, key=note.get) if note else None

def calculeaza(a, b, operatia="+"):
    if operatia == "+": return a + b
    if operatia == "-": return a - b
    if operatia == "*": return a * b
    if operatia == "/": return a / b
    raise ValueError("Operație necunoscută")

def aplica(a, functie):
    return [functie(x) for x in a]

def maxim_dupa_f(a, f):
    if not a:
        return None
    return max(f(x) for x in a)

def blocuri(a, k):
    return [a[i:i+k] for i in range(0, len(a), k)]

def filtreaza(a, prag, invers=False):
    r = [x for x in a if x >= prag]
    return r[::-1] if invers else r

def coloana(m, j):
    if not m or j < 0 or j >= len(m[0]):
        raise IndexError("Coloană invalidă")
    return [linie[j] for linie in m]

def transforma_valori(d, f):
    return {cheie: f(valoare) for cheie, valoare in d.items()}

def egale(a, b, strict=True):
    return a == b if strict else set(a) == set(b)

def comune(*liste):
    if not liste:
        return set()
    rezultat = set(liste[0])
    for a in liste[1:]:
        rezultat &= set(a)
    return rezultat

def timp(secunde, format_lung=False):
    h, rest = divmod(secunde, 3600)
    m, s = divmod(rest, 60)
    return f"{h} ore, {m} minute, {s} secunde" if format_lung else (h, m, s)

def suma_interval(a, start=0, stop=None):
    return sum(a[start:stop])

def mai_mare(a, b, compara):
    return a if compara(a, b) else b

def maxim(a, key=None):
    return max(a, key=key)

def reduce_simplu(f, initial, a):
    rezultat = initial
    for x in a:
        rezultat = f(rezultat, x)
    return rezultat

def divizibile_de_toti(a, *divizori):
    return [x for x in a if all(x % d == 0 for d in divizori)]

def configurare(**optiuni):
    return {
        "mod": optiuni.get("mod", "normal"),
        "limita": optiuni.get("limita", 100),
        "activ": optiuni.get("activ", True)
    }

def calculeaza():
    x = 10
    return x
y = calculeaza()
print(y)

valoare = 20
def afisare():
    return valoare
def dublare():
    return valoare * 2
print(afisare(), dublare())

x = 100
def f(x):
    return x
print(f(5))
print(x)

def puteri(n):
    patrat = n * n
    cub = patrat * n
    return patrat, cub

def suma_lista(a):
    s = 0
    for x in a:
        s += x
    return s

def prima(a):
    rezultat = a * 3
    return rezultat
def a_doua(x):
    return x + 10
rezultat = a_doua(prima(7))

def test():
    x = 42
    return x
x = test()
print(x)

x = 50
def f():
    x = 10
    return x
print(f())
print(x)

def dublu(x):
    y = 2 * x
    return y
a = dublu(3)
b = dublu(9)
print(a, b)

def pret_final(pret, reducere, taxa):
    pret_reducere = pret * (1 - reducere)
    return pret_reducere * (1 + taxa)

def rezultat(a, b, c):
    intermediar = a * b
    return intermediar + c

def statistici(a):
    suma = sum(a)
    nr = len(a)
    return suma, suma / nr if nr else 0

s = 100
def f(a):
    s = sum(a)
    return s
print(f([1, 2, 3]))
print(s)

def dublare_nemutanta(a):
    rezultat = []
    for x in a:
        rezultat.append(2 * x)
    return rezultat

def f(x): return x + 2
def g(x): return x * 3
def h(x): return x - 1
rezultat = h(g(f(5)))

def calculeaza(x):
    rezultat = x * x
    return rezultat

def genereaza():
    secret_local = 123
    return secret_local
valoare_globala = genereaza()

def exista(a, x):
    for element in a:
        if element == x:
            return True
    return False

def frecvente(a):
    f = {}
    for x in a:
        f[x] = f.get(x, 0) + 1
    return f
def cea_mai_frecventa(a):
    f = frecvente(a)
    return max(f, key=f.get)

def statistici_complete(a):
    s = sum(a)
    minim = min(a)
    maxim = max(a)
    return s, minim, maxim

def pozitii_pare(t):
    return tuple(t[::2])

def inversare(t):
    a, b, c = t
    return c, b, a

def elev_maxim(t):
    return max(t, key=lambda pereche: pereche[1])[0]

def frecvente_tuplu(t):
    f = {}
    for x in t:
        f[x] = f.get(x, 0) + 1
    return tuple(f.items())

def este_palindrom(t):
    return t == t[::-1]

def distanta_manhattan(p):
    x, y = p
    return abs(x) + abs(y)

def concateneaza(lista):
    rezultat = ()
    for t in lista:
        rezultat += t
    return rezultat

def elimina(t, valoare):
    return tuple(x for x in t if x != valoare)

def interval_maxim(t):
    return max(t, key=lambda x: x[1] - x[0])

def distincte(t):
    vazute = set()
    r = []
    for x in t:
        if x not in vazute:
            vazute.add(x)
            r.append(x)
    return tuple(r)

def suma_elemente(a, b):
    return tuple(x + y for x, y in zip(a, b))

def transpusa(m):
    return tuple(zip(*m))

def cel_mai_lung(t):
    return max(t, key=len) if t else 

def data_valida(t):
    an, luna, zi = t
    return an > 0 and 1 <= luna <= 12 and 1 <= zi <= 31

def prefix_crescator(t):
    if not t:
        return ()
    r = [t[0]]
    for x in t[1:]:
        if x > r[-1]:
            r.append(x)
        else:
            break
    return tuple(r)

def interschimba(a, b):
    a, b = b, a
    return a, b

def grupeaza(t):
    d = {}
    for cheie, valoare in t:
        d.setdefault(cheie, []).append(valoare)
    return d

def patrate_pozitive(t):
    return tuple(x * x for x in t if x > 0)

def prima_peste_medie(t):
    if not t:
        return -1
    media = sum(t) / len(t)
    for i, x in enumerate(t):
        if x > media:
            return i
    return -1

def diagonala(m):
    if not m or any(len(linie) != len(m) for linie in m):
        return ()
    return tuple(m[i][i] for i in range(len(m)))

def comune(a, b):
    return set(a) & set(b)

def repetate(a):
    f = {}
    for x in a:
        f[x] = f.get(x, 0) + 1
    return {x for x, nr in f.items() if nr >= 2}

def exact_doua(a, b, c):
    return ((a & b) | (a & c) | (b & c)) - (a & b & c)

def submultime_stricta(a, b):
    return a < b

def diferenta(a, b):
    return a - b

def litere_comune(cuvinte):
    if not cuvinte:
        return set()
    r = set(cuvinte[0].lower())
    for c in cuvinte[1:]:
        r &= set(c.lower())
    return r

def aceleasi_valori(a, b):
    return set(a) == set(b)

def perechi_suma(s, k):
    r = set()
    for x in s:
        y = k - x
        if y in s and x != y:
            r.add(tuple(sorted((x, y))))
    return r

def intersectie_totala(lista):
    if not lista:
        return set()
    r = set(lista[0])
    for s in lista[1:]:
        r &= s
    return r

def numar_distincte(a):
    return len(set(a))

def disjuncte(a, b):
    return a.isdisjoint(b)

def reuniune_fara_comune(a, b):
    return a ^ b

def litere_distincte(cuvinte):
    return {c for c in cuvinte if len(set(c.lower())) == len(c) }

def sume_doua(s):
    return {x + y for x in s for y in s if x != y}

def comune_jumatati(a):
    m = len(a) // 2
    return set(a[:m]) & set(a[m:])

def contine_multipli(s):
    return (any(x % 3 == 0 for x in s)
            and any(x % 5 == 0 for x in s)
            and any(x % 7 == 0 for x in s))

def in_cel_putin_doua(a, b, c):
    A, B, C = map(set, (a, b, c))
    return (A & B) | (A & C) | (B & C)

def unice(a):
    f = {}
    for x in a:
        f[x] = f.get(x, 0) + 1
    return {x for x in f if f[x] == 1}

def diferenta_maxima(s):
    if len(s) < 2:
        return 0
    return max(s) - min(s)

def operatii(a, b):
    return a & b, a | b, a - b

def toate_clasele(a):
    resturi = {x % 3 for x in a}
    return resturi == {0, 1, 2}

def frecvente(a):
    d = {}
    for x in a:
        d[x] = d.get(x, 0) + 1
    return d

def nota_maxima(note):
    return max(note, key=note.get)

def inverseaza(d):
    r = {}
    for k, v in d.items():
        r.setdefault(v, []).append(k)
    return r

def uneste(a, b):
    r = a.copy()
    for k, v in b.items():
        r[k] = r.get(k, 0) + v
    return r

def peste_medie(d):
    if not d:
        return []
    media = sum(d.values()) / len(d)
    return [k for k, v in d.items() if v > media]

def frecvente_litere(s):
    d = {}
    for c in s.lower():
        if c.isalpha():
            d[c] = d.get(c, 0) + 1
    return d

def grupeaza_lungime(cuvinte):
    d = {}
    for c in cuvinte:
        d.setdefault(len(c), []).append(c)
    return d

def cheie_suma_maxima(d):
    return max(d, key=lambda k: sum(d[k]))

def fara_negative(d):
    return {k: v for k, v in d.items() if v >= 0}

def frecvente_cuvinte(text):
    d = {}
    for cuvant in text.lower().split():
        d[cuvant] = d.get(cuvant, 0) + 1
    return d

def medii(elevi):
    return {nume: sum(note) / len(note) for nume, note in elevi.items() if note}

def top_k(d, k):
    return sorted(d, key=d.get, reverse=True)[:k]

def frecvente_chei(perechi):
    d = {}
    for k, _ in perechi:
        d[k] = d.get(k, 0) + 1
    return d

def aceleasi_chei(a, b):
    return set(a) == set(b)

def combina_liste(a, b):
    r = {k: v[:] for k, v in a.items()}
    for k, v in b.items():
        r.setdefault(k, []).extend(v)
    return r

def patrate(a):
    return {x: x * x for x in set(a)}

def solduri(tranzactii):
    d = {}
    for persoana, suma, tip in tranzactii:
        d[persoana] = d.get(persoana, 0)
        d[persoana] += suma if tip == "incasare" else -suma
    return d

def chei_maxime(d):
    if not d:
        return []
    m = max(d.values())
    return [k for k, v in d.items() if v == m]

def dupa_initiala(cuvinte):
    d = {}
    for c in cuvinte:
        if c:
            d.setdefault(c[0].lower(), []).append(c)
    return d

def nr_muchii(graf):
    return sum(len(vecini) for vecini in graf.values()) // 2

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n - 1)

def suma(n):
    if n == 0:
        return 0
    return n + suma(n - 1)

def numar_cifre(n):
    if n < 10:
        return 1
    return 1 + numar_cifre(n // 10)

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

def palindrom(s):
    if len(s) <= 1:
        return True
    return s[0] == s[-1] and palindrom(s[1:-1])

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

def putere(a, n):
    if n == 0:
        return 1
    return a * putere(a, n - 1)

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

def numara_pare(a, i=0):
    if i == len(a):
        return 0
    return (a[i] % 2 == 0) + numara_pare(a, i + 1)

def maxim(a, i=0):
    if i == len(a) - 1:
        return a[i]
    return max(a[i], maxim(a, i + 1))

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

def aparitii(a, x, i=0):
    if i == len(a):
        return 0
    return (a[i] == x) + aparitii(a, x, i + 1)

def elimina(a, x):
    if not a:
        return []
    rest = elimina(a[1:], x)
    return rest if a[0] == x else [a[0]] + rest

def invers(s):
    if len(s) <= 1:
        return s
    return invers(s[1:]) + s[0]

def aparitii_cifra(n, c):
    if n == 0:
        return 0
    return (n % 10 == c) + aparitii_cifra(n // 10, c)

def toate_pozitive(a, i=0):
    if i == len(a):
        return True
    return a[i] > 0 and toate_pozitive(a, i + 1)

def suma_impare(n):
    if n <= 0:
        return 0
    return (n if n % 2 else 0) + suma_impare(n - 1)

def prima_pozitie(a, x, i=0):
    if i == len(a):
        return -1
    if a[i] == x:
        return i
    return prima_pozitie(a, x, i + 1)

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

def binare(n, prefix=""):
    if n == 0:
        return [prefix]
    return binare(n - 1, prefix + "0") + binare(n - 1, prefix + "1")

def analiza(a):
    return {
        "suma": sum(a),
        "minim": min(a),
        "maxim": max(a),
        "distincte": len(set(a))
    }

def ordonare_frecventa(a):
    f = {}
    for x in a:
        f[x] = f.get(x, 0) + 1
    return sorted(f, key=lambda x: (-f[x], x))

def exact_doua_litere(s):
    f = {}
    for c in s.lower():
        if c.isalpha():
            f[c] = f.get(c, 0) + 1
    return {c for c, nr in f.items() if nr == 2}

def medie_note(perechi):
    note = dict(perechi)
    return sum(note.values()) / len(note) if note else 0

def compara(a, b):
    A, B = set(a), set(b)
    return A & B, A ^ B, A | B

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

def frecvente_tuplu(t):
    d = {}
    for x in t:
        d[x] = d.get(x, 0) + 1
    return d

def top_trei(cuvinte):
    distincte = set(cuvinte)
    return tuple((c, len(c)) for c in sorted(distincte, key=lambda x: (-len(x), x))[:3])

def diagonala_si_frecvente(m):
    t = tuple(m[i][i] for i in range(min(len(m), len(m[0]))))
    f = {}
    for x in t:
        f[x] = f.get(x, 0) + 1
    return set(t), f

def crescatoare(a, i=1):
    if i == len(a):
        return True
    return a[i-1] < a[i] and crescatoare(a, i + 1)

def pozitii(a):
    d = {}
    for i, x in enumerate(a):
        if x not in d:
            d[x] = [i, i]
        else:
            d[x][1] = i
    return {x: tuple(p) for x, p in d.items()}

def statistica_comuna(a, b):
    c = set(a) & set(b)
    return sum(c), len(c)

def grupeaza_litere(cuvinte):
    d = {}
    for c in cuvinte:
        cheie = tuple(sorted(set(c.lower())))
        d.setdefault(cheie, []).append(c)
    return d

def statistici_cifre(n):
    def cifre(x):
        if x < 10:
            return 1, x
        nr, s = cifre(x // 10)
        return nr + 1, s + x % 10
    return cifre(abs(n))

def categorii(a):
    return {
        "pare": {x for x in a if x % 2 == 0},
        "impare": {x for x in a if x % 2 != 0},
        "negative": {x for x in a if x < 0}
    }

def agregare(perechi):
    d = {}
    for k, v in perechi:
        d[k] = d.get(k, 0) + v
    return d

def cifre_tuplu(n):
    if n < 10:
        return (n,)
    return cifre_tuplu(n // 10) + (n % 10,)

def analiza_lista(a):
    f = {}
    for x in a:
        f[x] = f.get(x, 0) + 1
    distincte = set(a)
    duplicate = {x for x in distincte if f[x] > 1}
    return distincte, duplicate, f

def cheie_medie_maxima(d):
    medii = {k: sum(v) / len(v) for k, v in d.items() if v}
    return min(medii, key=lambda k: (-medii[k], k))

def moduri(n):
    if n == 0:
        return 1
    if n < 0:
        return 0
    return moduri(n - 1) + moduri(n - 2) + moduri(n - 5)