Exercices corrigés Python (Série 4)

n = int(input("saisir un entier: "))
etat = True

if n > 0:
    ch = str(n)
    for lettre in ch:
        if ch.count(lettre) > 1:
            etat = False
            break
    
    if etat:
        print(n, "est distinct")
    else:
        print(n, "est non distinct")
else:
    print("saisir un entier positif")


# Version alternative avec un ensemble
def est_distinct(n):
    """Vérifie si n est un nombre distinct en utilisant un ensemble."""
    ch = str(n)
    return len(set(ch)) == len(ch)


print(f"1273 est distinct ? {est_distinct(1273)}")
print(f"1565 est distinct ? {est_distinct(1565)}")

print("Nombres de 3 chiffres dont la somme des chiffres divise le produit :")

for i in range(100, 1000):
    ch = str(i)
    c, d, u = int(ch[0]), int(ch[1]), int(ch[2])
    somme = c + d + u
    produit = c * d * u
    
    if produit % somme == 0:
        print(i, end=" ")

print("\n\nVersion avec liste :")
resultats = [i for i in range(100, 1000) 
             if (lambda x: (int(str(x)[0])*int(str(x)[1])*int(str(x)[2])) % 
                 (int(str(x)[0])+int(str(x)[1])+int(str(x)[2])) == 0)(i)]
print(resultats)

def somme_chiffres(x):
    """Retourne la somme des chiffres de x."""
    return sum(int(d) for d in str(x))

def est_auto_nombre(N):
    """
    Vérifie si N est un auto-nombre.
    Un auto-nombre ne peut pas s'écrire comme M + somme_chiffres(M).
    """
    for M in range(1, N):
        if M + somme_chiffres(M) == N:
            return False
    return True


def auto_nombre_v2(N):
    """
    Version optimisée : on ne teste que les valeurs de M susceptibles de donner N.
    Sachant que M + somme_chiffres(M) ≤ M + 9*len(str(M)), on peut borner la recherche.
    """
    debut = max(1, N - 9 * len(str(N)))
    for M in range(debut, N):
        if M + somme_chiffres(M) == N:
            return False
    return True


# Tests
print(f"21 est auto-nombre ? {est_auto_nombre(21)}")
print(f"20 est auto-nombre ? {est_auto_nombre(20)}")

# Générer les premiers auto-nombres
print("\nPremiers auto-nombres :")
auto_nombres = [n for n in range(1, 100) if est_auto_nombre(n)]
print(auto_nombres)

def verifie_propriete(N):
    """
    Vérifie si N (4 chiffres) peut s'écrire comme somme des chiffres à une puissance K
    pour K entre 1 et 5.
    Retourne (True, K) si trouvé, (False, None) sinon.
    """
    if N < 1000 or N > 9999:
        print("Le nombre doit contenir 4 chiffres")
        return (False, None)
    
    chiffres = [int(c) for c in str(N)]
    
    for K in range(1, 6):
        somme = sum(c ** K for c in chiffres)
        if somme == N:
            return (True, K)
    
    return (False, None)


def affiche_resultat(N):
    """Affiche le résultat de la vérification."""
    trouve, K = verifie_propriete(N)
    if trouve:
        print(f"N = {N} vérifie la propriété avec K = {K}")
    else:
        print(f"N = {N} ne vérifie pas la propriété")


# Tests
affiche_resultat(1634)
affiche_resultat(2114)
affiche_resultat(9474)  # 9⁴+4⁴+7⁴+4⁴ = 6561+256+2401+256 = 9474

# Recherche de tous les nombres à 4 chiffres vérifiant la propriété
print("\nTous les nombres à 4 chiffres vérifiant la propriété :")
resultats = []
for n in range(1000, 10000):
    trouve, K = verifie_propriete(n)
    if trouve:
        resultats.append((n, K))
        print(f"{n} (K={K})")
print(f"Total: {len(resultats)} nombres")

import math as mt

def est_premier(n):
    """Test de primalité optimisé."""
    if n < 2:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    
    for i in range(3, int(mt.sqrt(n)) + 2, 2):
        if n % i == 0:
            return False
    return True


def rotations(n):
    """Génère toutes les rotations circulaires d'un nombre."""
    s = str(n)
    return [int(s[i:] + s[:i]) for i in range(len(s))]


def est_circulaire(n):
    """Vérifie si n est un nombre premier circulaire."""
    if not est_premier(n):
        return False
    
    for rot in rotations(n):
        if not est_premier(rot):
            return False
    return True


def circulaire(p, q):
    """Affiche tous les nombres premiers circulaires entre p et q."""
    print(f"Nombres premiers circulaires entre {p} et {q} :")
    trouve = False
    
    for i in range(p, q + 1):
        if est_circulaire(i):
            print(f"  {i}")
            trouve = True
    
    if not trouve:
        print("  Aucun nombre trouvé")


# Test
print("Test avec 719 :", est_circulaire(719))
print("Test avec 23 :", est_circulaire(23))
print()

circulaire(100, 300)


# Version plus détaillée avec affichage des rotations
def circulaire_detail(p, q):
    """Version détaillée avec affichage des rotations."""
    for i in range(p, q + 1):
        if est_circulaire(i):
            rots = rotations(i)
            print(f"{i} : rotations = {rots} (tous premiers)")

def poids(chaine):
    """
    Calcule le poids d'une chaîne selon la définition donnée.
    """
    # S'assurer que la chaîne est en majuscules
    chaine = chaine.upper()
    
    # Dictionnaire des rangs des voyelles
    rangs = {'A': 1, 'E': 5, 'I': 9, 'O': 15, 'U': 21, 'Y': 25}
    
    poids_total = 0
    
    for position, lettre in enumerate(chaine, 1):  # position commence à 1
        if lettre in rangs:
            poids_total += position * rangs[lettre]
    
    return poids_total


# Version avec gestion des minuscules et validation
def poids_avec_validation(chaine):
    """
    Version avec validation que la chaîne ne contient que des lettres.
    """
    if not chaine or not chaine.isalpha():
        raise ValueError("La chaîne doit être non vide et composée uniquement de lettres")
    
    chaine = chaine.upper()
    rangs = {'A': 1, 'E': 5, 'I': 9, 'O': 15, 'U': 21, 'Y': 25}
    
    return sum(pos * rangs[lettre] 
               for pos, lettre in enumerate(chaine, 1) 
               if lettre in rangs)


# Tests
print(f"Poids de 'BONNE' : {poids('BONNE')}")
print(f"Poids de 'CHANCE' : {poids('CHANCE')}")
print(f"Poids de 'PYTHON' : {poids('PYTHON')}")  # Y est une voyelle ici
print(f"Poids de 'BCD' : {poids('BCD')}")        # Pas de voyelle

# Test avec une phrase
phrase = "BONJOUR"
print(f"Poids de '{phrase}' : {poids(phrase)}")

def somme_chiffres(n):
    """Retourne la somme des chiffres de n."""
    return sum(int(d) for d in str(n))

def somme_chiffres_recursive(n):
    """Somme des chiffres jusqu'à obtenir un seul chiffre."""
    while n > 9:
        n = somme_chiffres(n)
    return n

def code_nombre(n):
    """
    Génère le code d'un nombre selon la règle donnée.
    """
    if n <= 100:
        return "N doit être > 100"
    
    somme = somme_chiffres_recursive(n)
    return int(str(somme) + str(n))


def code_nombre_detail(n):
    """
    Version détaillée avec affichage des étapes.
    """
    if n <= 100:
        return "N doit être > 100"
    
    print(f"Traitement de N = {n}")
    courant = n
    etape = 1
    
    while courant > 9:
        somme = somme_chiffres(courant)
        print(f"  Étape {etape}: somme des chiffres de {courant} = {somme}")
        courant = somme
        etape += 1
    
    print(f"Somme finale = {courant}")
    code = int(str(courant) + str(n))
    print(f"Code = {courant} + {n} = {code}")
    return code


# Tests
print(f"Code de 9867 : {code_nombre(9867)}")
print()

print("Détail pour 9867 :")
code_nombre_detail(9867)
print()

print(f"Code de 12345 : {code_nombre(12345)}")
print(f"Code de 9999 : {code_nombre(9999)}")  # 9+9+9+9=36, 3+6=9 → 99999