Guide : Exercices Corrigés d’Algorithme

Ce guide propose une série d’exercices d’algorithme corrigés pour renforcer vos compétences en logique, programmation et résolution de problèmes. Les exercices couvrent des concepts de base et avancés, adaptés pour les débutants et les niveaux intermédiaires.

1. Calcul de la Somme des N Premiers Entiers

Enoncé :

Écrivez un algorithme qui calcule la somme des N premiers entiers positifs. N est donné par l’utilisateur.

Pseudo-code :

1. Initialisez une variable somme à 0.
2. Demandez à l’utilisateur d’entrer un nombre entier N.
3. Parcourez les entiers de 1 à N et ajoutez-les à somme.
4. Affichez le résultat.

Exemple :

• Entrée : N = 5
• Sortie : 15 (1 + 2 + 3 + 4 + 5)

Solution (Python) :

def somme_entiers(N):
    somme = 0
    for i in range(1, N + 1):
        somme += i
    return somme

# Exemple d'utilisation
N = int(input("Entrez un entier N : "))
print("La somme des", N, "premiers entiers est :", somme_entiers(N))

2. Vérifier si un Nombre est Pair ou Impair

Enoncé :

Écrivez un algorithme qui vérifie si un nombre donné est pair ou impair.

Pseudo-code :

1. Demandez à l’utilisateur d’entrer un nombre entier.
2. Si le reste de la division du nombre par 2 est 0, affichez “Pair”.
3. Sinon, affichez “Impair”.

Exemple :

• Entrée : 7
• Sortie : “Impair”

Solution (Python) :

def verifier_pair_impair(nombre):
    if nombre % 2 == 0:
        return "Pair"
    else:
        return "Impair"

# Exemple d'utilisation
nombre = int(input("Entrez un nombre : "))
print("Le nombre est :", verifier_pair_impair(nombre))

3. Trouver le Plus Grand de Trois Nombres

Enoncé :

Écrivez un algorithme qui trouve le plus grand de trois nombres donnés.

Pseudo-code :

1. Demandez à l’utilisateur d’entrer trois nombres.
2. Comparez les nombres pour déterminer le plus grand.
3. Affichez le plus grand nombre.

Exemple :

• Entrée : 4, 9, 2
• Sortie : 9

Solution (Python) :

def plus_grand(a, b, c):
    if a >= b and a >= c:
        return a
    elif b >= a and b >= c:
        return b
    else:
        return c

# Exemple d'utilisation
a = int(input("Entrez le premier nombre : "))
b = int(input("Entrez le deuxième nombre : "))
c = int(input("Entrez le troisième nombre : "))
print("Le plus grand nombre est :", plus_grand(a, b, c))

4. Générer la Table de Multiplication d’un Nombre

Enoncé :

Écrivez un algorithme qui affiche la table de multiplication d’un nombre donné jusqu’à 10.

Pseudo-code :

1. Demandez à l’utilisateur d’entrer un nombre.
2. Pour chaque entier de 1 à 10, affichez le produit du nombre par cet entier.

Exemple :

• Entrée : 3
• Sortie : 3 x 1 = 3, 3 x 2 = 6, …, 3 x 10 = 30

Solution (Python) :

def table_multiplication(nombre):
    for i in range(1, 11):
        print(f"{nombre} x {i} = {nombre * i}")

# Exemple d'utilisation
nombre = int(input("Entrez un nombre : "))
table_multiplication(nombre)

5. Vérifier si une Chaîne est un Palindrome

Enoncé :

Écrivez un algorithme qui vérifie si une chaîne donnée est un palindrome (elle se lit de la même façon à l’endroit et à l’envers).

Pseudo-code :

1. Demandez à l’utilisateur d’entrer une chaîne de caractères.
2. Inversez la chaîne.
3. Comparez la chaîne originale avec la chaîne inversée.
4. Si elles sont identiques, affichez “Palindrome”, sinon “Pas un palindrome”.

Exemple :

• Entrée : “radar”
• Sortie : “Palindrome”

Solution (Python) :

def est_palindrome(chaine):
    return chaine == chaine[::-1]

# Exemple d'utilisation
chaine = input("Entrez une chaîne : ").lower()
if est_palindrome(chaine):
    print("C'est un palindrome.")
else:
    print("Ce n'est pas un palindrome.")

6. Calculer le Factoriel d’un Nombre

Enoncé :

Écrivez un algorithme qui calcule le factoriel d’un nombre entier non négatif donné.

Pseudo-code :

1. Initialisez une variable factoriel à 1.
2. Parcourez tous les entiers de 1 à N et multipliez-les.
3. Affichez le résultat.

Exemple :

• Entrée : 5
• Sortie : 120 (5! = 5 × 4 × 3 × 2 × 1)

Solution (Python) :

def factoriel(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Exemple d'utilisation
n = int(input("Entrez un nombre entier : "))
print(f"Le factoriel de {n} est :", factoriel(n))

7. Trouver Tous les Nombres Premiers dans un Intervalle

Enoncé :

Écrivez un algorithme qui trouve tous les nombres premiers entre 1 et N.

Pseudo-code :

1. Parcourez les nombres de 2 à N.
2. Pour chaque nombre, vérifiez s’il n’est divisible par aucun nombre entre 2 et sa racine carrée.
3. Affichez les nombres premiers.

Exemple :

• Entrée : 10
• Sortie : 2, 3, 5, 7

Solution (Python) :

def nombres_premiers(n):
    premiers = []
    for i in range(2, n + 1):
        est_premier = True
        for j in range(2, int(i ** 0.5) + 1):
            if i % j == 0:
                est_premier = False
                break
        if est_premier:
            premiers.append(i)
    return premiers

# Exemple d'utilisation
n = int(input("Entrez une borne supérieure : "))
print("Les nombres premiers jusqu'à", n, "sont :", nombres_premiers(n))

8. Trier une Liste de Nombres

Enoncé :

Écrivez un algorithme qui trie une liste de nombres dans l’ordre croissant.

Pseudo-code :

1. Prenez une liste de nombres.
2. Utilisez une méthode de tri (ex. Tri par sélection ou Tri intégré).
3. Affichez la liste triée.

Exemple :

• Entrée : [5, 2, 9, 1, 5]
• Sortie : [1, 2, 5, 5, 9]

Solution (Python) :

def trier_liste(liste):
    return sorted(liste)

# Exemple d'utilisation
liste = [5, 2, 9, 1, 5]
print("Liste triée :", trier_liste(liste))

Ces exercices couvrent différents concepts d’algorithme : logique conditionnelle, boucles, manipulations de chaînes, calculs mathématiques, et gestion de tableaux. Ils vous aideront à consolider vos bases et à développer des solutions efficaces.

Exercice : Calculer la Somme des Multiples d’un Nombre dans un Intervalle

Enoncé :

Écrivez un algorithme qui calcule la somme de tous les multiples d’un nombre donné, compris dans un intervalle spécifié par l’utilisateur.

Instructions :

1. Demandez à l’utilisateur :
   • Un nombre entier N dont on doit calculer les multiples.
   • Une borne inférieure borne_inf.
   • Une borne supérieure borne_sup.
2. Parcourez tous les entiers de la borne inférieure à la borne supérieure.
3. Ajoutez à une variable somme chaque nombre divisible par N.
4. Affichez la somme totale des multiples trouvés.

Exemple :

• Entrée :
  • Nombre N : 3
  • Borne inférieure : 1
  • Borne supérieure : 10
• Sortie : 18 (3 + 6 + 9)

Pseudo-code :

1. Initialisez somme à 0.
2. Pour chaque nombre dans l’intervalle de borne_inf à borne_sup :
   • Si le nombre est divisible par N, ajoutez-le à somme.
3. Affichez la valeur finale de somme.

Solution (Python) :

def somme_multiples(N, borne_inf, borne_sup):
    somme = 0
    for i in range(borne_inf, borne_sup + 1):
        if i % N == 0:
            somme += i
    return somme

# Exemple d'utilisation
N = int(input("Entrez un nombre entier N : "))
borne_inf = int(input("Entrez la borne inférieure : "))
borne_sup = int(input("Entrez la borne supérieure : "))

resultat = somme_multiples(N, borne_inf, borne_sup)
print(f"La somme des multiples de {N} entre {borne_inf} et {borne_sup} est : {resultat}")

Variantes :

1. Trouver les multiples : Modifiez l’algorithme pour afficher uniquement les multiples trouvés, sans les additionner.
2. Choix de l’intervalle : Ajoutez une vérification pour vous assurer que borne_inf < borne_sup, sinon demandez à l’utilisateur de ressaisir les bornes.

Exercice Amélioré :

Ajoutez une condition pour que l’algorithme ignore les nombres négatifs dans l’intervalle ou les traite différemment (par exemple, afficher un avertissement si un intervalle contient des nombres négatifs).

Exercice : Créer une Fonction pour Vérifier un Nombre Premier

Enoncé :

Écrivez une fonction appelée est_premier qui détermine si un nombre donné est un nombre premier. Un nombre premier est un entier supérieur à 1 qui n’est divisible que par 1 et lui-même.

Ensuite, utilisez cette fonction pour afficher tous les nombres premiers dans un intervalle donné par l’utilisateur.

Instructions :

1. Créez une fonction nommée est_premier(n) :
   • Retourne True si n est un nombre premier.
   • Retourne False sinon.
2. Demandez à l’utilisateur de saisir une borne inférieure et une borne supérieure pour définir un intervalle.
3. Parcourez tous les nombres dans cet intervalle et utilisez la fonction est_premier pour identifier les nombres premiers.
4. Affichez les nombres premiers trouvés.

Exemple :

• Entrée :
  • Borne inférieure : 10
  • Borne supérieure : 20
• Sortie : 11, 13, 17, 19

Pseudo-code :

1. Définissez une fonction est_premier :
   • Si le nombre est inférieur ou égal à 1, il n’est pas premier.
   • Pour chaque entier i entre 2 et la racine carrée de n :
     • Si n est divisible par i, il n’est pas premier.
   • Sinon, il est premier.
2. Demandez les bornes à l’utilisateur.
3. Parcourez tous les nombres de l’intervalle et utilisez la fonction pour vérifier s’ils sont premiers.
4. Affichez les résultats.

Solution (Python) :

def est_premier(n):
    """Vérifie si un nombre est premier."""
    if n <= 1:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

def nombres_premiers_dans_intervalle(borne_inf, borne_sup):
    """Trouve tous les nombres premiers dans un intervalle donné."""
    premiers = []
    for i in range(borne_inf, borne_sup + 1):
        if est_premier(i):
            premiers.append(i)
    return premiers

# Exemple d'utilisation
borne_inf = int(input("Entrez la borne inférieure : "))
borne_sup = int(input("Entrez la borne supérieure : "))

resultat = nombres_premiers_dans_intervalle(borne_inf, borne_sup)
print(f"Les nombres premiers entre {borne_inf} et {borne_sup} sont : {resultat}")

Explication :

1. Fonction est_premier(n) :
   • Vérifie si le nombre est premier en testant la divisibilité jusqu’à la racine carrée.
   • Si une division est exacte, retourne False.
2. Fonction nombres_premiers_dans_intervalle :
   • Parcourt chaque nombre de l’intervalle et utilise est_premier pour vérifier.
   • Ajoute les nombres premiers dans une liste.

Variantes :

1. Amélioration de la Lisibilité : Retournez les résultats sous forme de chaîne formatée (ex. : “11, 13, 17”).
2. Extension : Ajoutez un compteur pour afficher combien de nombres premiers ont été trouvés.
3. Optimisation : Ajoutez une vérification pour gérer les cas où la borne supérieure est inférieure à la borne inférieure.

Exercice Amélioré : Fonction pour le k-ième Nombre Premier

Demandez à l’utilisateur de spécifier la position k, puis modifiez la fonction pour trouver et afficher le k-ième nombre premier. Par exemple :

• Entrée : k = 5
• Sortie : Le 5ᵉ nombre premier est 11.

Exercice : Calculer la Moyenne et Trouver la Valeur Maximale d’un Tableau

Enoncé :

Écrivez un programme qui permet de :

1. Demander à l’utilisateur d’entrer les valeurs d’un tableau (liste de nombres).
2. Calculer la moyenne des valeurs du tableau.
3. Trouver la valeur maximale du tableau.
4. Afficher la moyenne et la valeur maximale.

Instructions :

1. Demandez à l’utilisateur d’entrer la taille du tableau.
2. Permettez à l’utilisateur d’entrer les valeurs une par une.
3. Parcourez le tableau pour :
   • Calculer la somme des valeurs et en déduire la moyenne.
   • Trouver la valeur maximale.
4. Affichez les résultats de manière claire.

Exemple :

• Entrée :
  • Taille du tableau : 5
  • Valeurs : 10, 20, 30, 40, 50
• Sortie :
  • Moyenne : 30.0
  • Valeur maximale : 50

Pseudo-code :

1. Initialisez un tableau vide tableau.
2. Demandez la taille du tableau (taille).
3. Pour chaque valeur de 1 à taille :
   • Demandez à l’utilisateur d’entrer un nombre.
   • Ajoutez le nombre au tableau.
4. Calculez la moyenne :
   • Sommez toutes les valeurs.
   • Divisez la somme par la taille du tableau.
5. Trouvez la valeur maximale :
   • Initialisez max_val avec la première valeur.
   • Parcourez le tableau pour trouver le maximum.
6. Affichez la moyenne et la valeur maximale.

Solution (Python) :

def calculer_moyenne(tableau):
    """Calcule la moyenne des valeurs d'un tableau."""
    return sum(tableau) / len(tableau)

def trouver_maximum(tableau):
    """Trouve la valeur maximale dans un tableau."""
    max_val = tableau[0]
    for valeur in tableau:
        if valeur > max_val:
            max_val = valeur
    return max_val

# Programme principal
taille = int(input("Entrez la taille du tableau : "))
tableau = []

# Entrée des valeurs
for i in range(taille):
    valeur = float(input(f"Entrez la valeur {i + 1} : "))
    tableau.append(valeur)

# Calcul de la moyenne et du maximum
moyenne = calculer_moyenne(tableau)
maximum = trouver_maximum(tableau)

# Affichage des résultats
print(f"La moyenne des valeurs est : {moyenne:.2f}")
print(f"La valeur maximale est : {maximum}")

Explication :

1. Entrée des valeurs :
   • L’utilisateur entre une série de valeurs qui sont stockées dans une liste.
2. Calcul de la moyenne :
   • La fonction sum() additionne toutes les valeurs, et on divise par la longueur du tableau pour obtenir la moyenne.
3. Recherche de la valeur maximale :
   • Une boucle compare chaque élément avec le maximum actuel.
4. Affichage :
   • Les résultats sont affichés avec un formatage clair (par ex., deux décimales pour la moyenne).

Variantes :

1. Ajouter la Valeur Minimale :
   • Implémentez une fonction pour trouver le minimum dans le tableau.
2. Filtrer les Valeurs :
   • Affichez uniquement les valeurs supérieures à la moyenne.
3. Gestion des Erreurs :
   • Vérifiez que l’utilisateur entre bien des nombres valides.

Exercice Amélioré : Compter les Valeurs Supérieures à une Limite

• Ajoutez une fonctionnalité :
  • Demandez à l’utilisateur d’entrer une limite.
  • Comptez et affichez le nombre de valeurs dans le tableau qui sont supérieures à cette limite.

Cet exercice vous permet de pratiquer la manipulation des tableaux (listes) dans un contexte réaliste et utile. Vous pouvez enrichir l’exercice en ajoutant des calculs ou des vérifications supplémentaires pour approfondir vos compétences.

Exercice : Gérer un Annuaire Téléphonique avec un Dictionnaire

Enoncé :

Écrivez un programme qui gère un annuaire téléphonique en utilisant un dictionnaire. Le programme doit permettre de :

1. Ajouter un contact (nom et numéro de téléphone).
2. Rechercher le numéro de téléphone d’un contact.
3. Supprimer un contact.
4. Afficher tous les contacts de l’annuaire.

Instructions :

1. Initialisez un dictionnaire vide appelé annuaire.
2. Proposez un menu à l’utilisateur avec les options suivantes :
   • 1 : Ajouter un contact.
   • 2 : Rechercher un numéro de téléphone.
   • 3 : Supprimer un contact.
   • 4 : Afficher tous les contacts.
   • 5 : Quitter le programme.
3. Implémentez chaque fonctionnalité en manipulant le dictionnaire.

Exemple d’Exécution :

• Menu : 1. Ajouter un contact 2. Rechercher un numéro 3. Supprimer un contact 4. Afficher tous les contacts 5. Quitter
• Scénario :
  • Entrée : 1 (Ajouter un contact)
    • Nom : Alice
    • Numéro : 123456789
  • Entrée : 2 (Rechercher un numéro)
    • Nom : Alice
    • Sortie : Numéro de Alice : 123456789
  • Entrée : 4 (Afficher tous les contacts)
    • Sortie : {'Alice': '123456789'}
  • Entrée : 3 (Supprimer un contact)
    • Nom : Alice
  • Entrée : 4 (Afficher tous les contacts)
    • Sortie : {}

Pseudo-code :

1. Initialisez annuaire comme un dictionnaire vide.
2. Affichez le menu principal.
3. Selon l’option choisie :
   • 1 : Ajouter un contact :
     • Demandez le nom et le numéro, puis ajoutez-les au dictionnaire.
   • 2 : Rechercher un numéro :
     • Demandez le nom, recherchez-le dans le dictionnaire et affichez le numéro correspondant.
   • 3 : Supprimer un contact :
     • Demandez le nom, puis supprimez-le du dictionnaire s’il existe.
   • 4 : Afficher tous les contacts :
     • Affichez le contenu du dictionnaire.
   • 5 : Quitter :
     • Terminez le programme.
4. Répétez jusqu’à ce que l’utilisateur quitte.

Solution (Python) :

def afficher_menu():
    print("\nMenu :")
    print("1. Ajouter un contact")
    print("2. Rechercher un numéro")
    print("3. Supprimer un contact")
    print("4. Afficher tous les contacts")
    print("5. Quitter")

def ajouter_contact(annuaire):
    nom = input("Entrez le nom : ")
    numero = input("Entrez le numéro : ")
    annuaire[nom] = numero
    print(f"Contact ajouté : {nom} -> {numero}")

def rechercher_contact(annuaire):
    nom = input("Entrez le nom à rechercher : ")
    if nom in annuaire:
        print(f"Numéro de {nom} : {annuaire[nom]}")
    else:
        print(f"{nom} n'est pas dans l'annuaire.")

def supprimer_contact(annuaire):
    nom = input("Entrez le nom à supprimer : ")
    if nom in annuaire:
        del annuaire[nom]
        print(f"{nom} a été supprimé.")
    else:
        print(f"{nom} n'existe pas dans l'annuaire.")

def afficher_contacts(annuaire):
    if annuaire:
        print("\nContacts :")
        for nom, numero in annuaire.items():
            print(f"{nom} : {numero}")
    else:
        print("L'annuaire est vide.")

# Programme principal
annuaire = {}
while True:
    afficher_menu()
    choix = input("Choisissez une option : ")
    if choix == "1":
        ajouter_contact(annuaire)
    elif choix == "2":
        rechercher_contact(annuaire)
    elif choix == "3":
        supprimer_contact(annuaire)
    elif choix == "4":
        afficher_contacts(annuaire)
    elif choix == "5":
        print("Au revoir !")
        break
    else:
        print("Option invalide. Veuillez réessayer.")

Explication :

1. Dictionnaire annuaire :
   • Les noms sont les clés, et les numéros sont les valeurs.
2. Ajouter un contact :
   • Utilisez annuaire[nom] = numero pour ajouter une entrée.
3. Rechercher un contact :
   • Vérifiez si le nom existe dans le dictionnaire avec if nom in annuaire.
4. Supprimer un contact :
   • Supprimez une clé avec del annuaire[nom].
5. Afficher les contacts :
   • Parcourez le dictionnaire avec for nom, numero in annuaire.items().

Variantes :

1. Validation des Données :
   • Vérifiez que le numéro contient uniquement des chiffres.
2. Modification d’un Contact :
   • Ajoutez une option pour mettre à jour le numéro d’un contact existant.
3. Recherche Partielle :
   • Permettez à l’utilisateur de rechercher des contacts dont le nom contient une chaîne donnée (ex. : “Ali” trouve “Alice”).

Cet exercice permet de pratiquer la manipulation des dictionnaires en Python dans un contexte réaliste.

Autres articles

Exercices Corrigés sur les Algorithmes

Les algorithmes sont au cœur de l'informatique et des mathématiques...

Read more

Cours Algorithme PDF : la base de...

Dans ce cours algorithme, nous présentons différentes notions d'algorithme afin...

Read more

Tutos algorithme : des exemples d'algorithmes pour...

Dans ce tutoirel algorithme, nous exposons des exemples des algorithmes...

Read more