Exercices corrigés Python (Série 7)

import re

def remplireAtome(N):
    """Saisit N atomes avec validation et les écrit dans Atomes.txt."""
    with open('Atomes.txt', 'a') as f:
        for _ in range(N):
            symbole = input("Symbole de l'atome   : ").strip()
            masse   = input("Masse atomique (g/mol) : ").strip()
            f.write(f"{symbole} * {masse}\n")


def dictionnaire(fichier):
    """Construit un dict {symbole: masse_float} depuis Atomes.txt."""
    dic = {}
    with open(fichier) as f:
        for ligne in f:
            parties = ligne.strip().split(' * ')
            if len(parties) == 2:
                dic[parties[0]] = float(parties[1])
    return dic


def parser_formule(formule):
    """
    Parse une formule chimique (ex: 'K2Cr2O7') et retourne
    une liste de tuples (symbole, nombre) : [('K',2),('Cr',2),('O',7)].
    Utilise une expression régulière.
    """
    # Motif : une majuscule + minuscule(s) optionnelle(s) + chiffre(s)
    return [(m[0], int(m[1]) if m[1] else 1)
            for m in re.findall(r'([A-Z][a-z]*)(\d*)', formule) if m[0]]


def massAtome():
    """Calcule la masse molaire de chaque molécule."""
    dic = dictionnaire('Atomes.txt')

    with open('Molecules.txt') as source, open('Resultats.txt', 'w') as dest:
        for ligne in source:
            parties  = ligne.strip().split('*')
            nom      = parties[0].strip()
            formule  = parties[1].strip()
            atomes   = parser_formule(formule)
            masse    = sum(n * dic.get(sym, 0) for sym, n in atomes)
            dest.write(f"{nom} ({formule}) : {masse:.1f} g/mol\n")
            print(f"{nom:30} → {masse:.1f} g/mol")


massAtome()

from math import isqrt

def premier(n):
    """
    Teste si n est premier — O(√n).
    Nettement plus efficace pour les grands nombres.
    """
    if n < 2: return False
    if n == 2: return True
    if n % 2 == 0: return False
    for i in range(3, isqrt(n) + 1, 2):   # seulement les impairs jusqu'à √n
        if n % i == 0:
            return False
    return True


def premier_fact(n):
    """
    Vérifie si n est un nombre premier factoriel (F! ± 1).
    Génère les factorielles : 1!, 2!, 3!, …
    """
    if not premier(n):
        return False

    f, ordre = 1, 1
    while f < n - 1:
        f *= ordre
        ordre += 1
        if f + 1 == n or f - 1 == n:
            print(f"  {n} = {ordre-1}! {'+ 1' if f+1==n else '- 1'}")
            return True
    return False


def primorielles():
    """Générateur infini de primorielles (P, P#)."""
    p, produit = 2, 1
    while True:
        produit *= p
        yield p, produit
        # Passer au premier suivant
        p += 1
        while not premier(p):
            p += 1


def premier_primoriel(n):
    """
    Vérifie si n est un nombre premier primoriel (P# ± 1).
    Utilise un générateur de primorielles.
    """
    if not premier(n):
        return False

    for p, s in primorielles():
        if s + 1 == n:
            print(f"  {n} = {p}# + 1  ({p}# = {s})")
            return True
        if s - 1 == n:
            print(f"  {n} = {p}# - 1  ({p}# = {s})")
            return True
        if s > n:
            break
    return False


# Tests avec explications
print("=== Premiers factoriels ===")
for x in [5, 7, 23, 119, 720, 719, 721]:
    print(f"{x:6} → {premier_fact(x)}")

print("\n=== Premiers primoriel ===")
for x in [2, 3, 5, 7, 29, 211, 30029, 100]:
    print(f"{x:6} → {premier_primoriel(x)}")