🏋️ Exercices supplémentaires

Sur cette page se trouvent des exercices supplémentaires pour vous entraîner. Ils sont classés par niveau de difficulté :

  • Facile : 🍀
  • Moyen : ⚖️
  • Difficile : 🌶️

🍀 Exercice 19 : Évaluation des notes d’une classe

Remplissez un fichier texte (notes.txt) avec les notes obtenues par des étudiants dans différentes Unités d'Enseignement (UE). Chaque ligne du fichier représente les notes d’un étudiant et chaque colonne les notes des différentes UE qu’il a suivies, séparées par des espaces.

Consignes :

Calculer les statistiques individuelles pour chaque Ă©tudiant :

  • La moyenne gĂ©nĂ©rale des notes.
  • La note minimale nĂ©cessaire au prochain examen pour que l'Ă©tudiant atteigne une moyenne de 10/20.
  • Le nombre d'UE validĂ©es (une UE est validĂ©e si la note obtenue est supĂ©rieure ou Ă©gale Ă  10/20).

Calculer les statistiques globales de la classe :

  • La moyenne gĂ©nĂ©rale de la classe.
  • L'Ă©cart type des moyennes des Ă©tudiants.

Afficher les résultats de manière structurée, en précisant :

  • Les statistiques pour chaque Ă©tudiant :
    • Moyenne gĂ©nĂ©rale.
    • Note nĂ©cessaire au prochain examen.
    • Nombre d'UE validĂ©es.
  • Les statistiques globales de la classe :
    • Moyenne gĂ©nĂ©rale.
    • Écart type des moyennes.

Astuces :

Exemple d'un fichier notes.txt :

12 8 14 10 11
9 11 10 12 13
8 7 6 10 11
10 11 12 13 14
12 13 14 15 16

Exemple de résultat attendu :

>> Statistiques par Ă©tudiant :
>> Étudiant 1 : Moyenne = 11.0, Note nécessaire = Néant (moyenne déjà atteinte), UE validées = 4
>> Étudiant 2 : Moyenne = 11.0, Note nécessaire = Néant (moyenne déjà atteinte), UE validées = 4
>> Étudiant 3 : Moyenne = 8.4, Note nécessaire = 18.0, UE validées = 2

>> Statistiques de la classe :
>> Moyenne générale de la classe : 10.13
>> Écart type des moyennes : 1.23

⚖️ Exercice 20 : Jeu du pendu amélioré

Dans cet exercice, vous allez développer une version avancée du jeu du pendu. Le programme sera divisé en plusieurs modules pour garantir une structure claire et organisée.

Objectifs :

  1. Deviner un mot parmi une liste stockée dans un fichier.
  2. GĂ©rer les scores des joueurs en fonction des tentatives restantes.
  3. Ajouter des niveaux de difficulté :
    • Facile : Plus de tentatives, mots courts.
    • Difficile : Moins de tentatives, mots longs.
  4. Enrichir l'expérience avec des illustrations ASCII du pendu pour chaque tentative incorrecte.

Consignes :

Fichier principal (main.py) :

  • Coordonne les diffĂ©rents modules du programme.
  • Affiche un menu principal permettant :
    • De choisir un niveau de difficultĂ©.
    • De lancer une nouvelle partie.
    • D'afficher les scores des joueurs.
  • Demande le nom du joueur au dĂ©but.
  • Affiche le score final une fois la partie terminĂ©e.

Fichier de gestion des données (data.py) :

Ce fichier contient les fonctions pour :

  • Charger les mots : Lire une liste de mots depuis un fichier texte (mots.txt).
    • Mots courts (3 Ă  5 lettres) pour le niveau facile.
    • Mots longs (6 lettres ou plus) pour le niveau difficile.
  • Sauvegarder les scores : Enregistrer les scores dans un fichier texte (scores.txt).

Fichier des fonctions du jeu (jeu.py) :

Ce fichier contient les fonctions principales du jeu du pendu :

  1. Sélectionner un mot : En fonction du niveau de difficulté.
  2. Affichage progressif : Montrer les lettres découvertes et masquer les autres par `_`.
  3. Gestion des entrées : Valider les lettres proposées par le joueur.
  4. Gestion des erreurs : Diminuer les tentatives restantes pour chaque erreur.
  5. Illustrations ASCII : Afficher une représentation graphique du pendu à chaque étape.

Fichier de gestion des scores (score.py) :

Ce fichier contient les fonctions pour :

  1. Ajouter un score pour un joueur après une partie.
  2. Afficher les scores classés par ordre décroissant.
  3. GĂ©rer les statistiques globales de la classe, par exemple :
    • Score moyen.
    • Joueur avec le meilleur score.

Règles du jeu :

  • Objectif : Deviner un mot en proposant des lettres une par une.
  • Le joueur a un nombre limitĂ© de tentatives :
    • Niveau facile : 10 tentatives.
    • Niveau difficile : 6 tentatives.
  • Chaque tentative incorrecte rĂ©duit le nombre de coups restants.
  • Si le mot est devinĂ© avant que toutes les tentatives soient utilisĂ©es, le joueur gagne des points :
    • Score : Nombre de coups restants Ă  la fin.
  • Le score est sauvegardĂ© dans scores.txt.

Organisation des fichiers :

  1. main.py : Gestion principale et menu interactif.
  2. data.py : Gestion des fichiers (mots.txt et scores.txt).
  3. jeu.py : Logique du jeu (affichage, vérification des lettres, etc.).
  4. score.py : Gestion des scores et des statistiques.

Exemple de résultat attendu :

>> === Jeu du Pendu === 
>> 1. Nouvelle Partie
>> 2. Afficher les Scores
>> 3. Quitter
>> Choix : 1 
>> Entrez votre nom : Alice 
>> Choisissez un niveau de difficulté : 
>> 1. Facile 
>> 2. Difficile
>> Choix : 1 
>> Mot Ă  deviner : _ _ _ _ _ 
>> Entrez une lettre : a 
>> Mot Ă  deviner : a _ _ _ _ 
>> Nombre de tentatives restantes : 9 

# ... (Suite du jeu) 

>> === Fin de la Partie === Alice, votre score est : 6

⚖️ Exercice 21 : Recherche avancée - Recherche par interpolation

Objectifs :

Écrire un programme Python qui permet de :

  • Faire une recherche par interpolation pour trouver un Ă©lĂ©ment donnĂ© dans une liste triĂ©e.
  • Charger les donnĂ©es Ă  partir d'un fichier texte contenant une liste triĂ©e de nombres.
  • Écrire le rĂ©sultat de la recherche dans un autre fichier texte.

Consignes :

Création des fichiers

  • CrĂ©ez un fichier texte nommĂ© data.txt contenant une liste triĂ©e de nombres sĂ©parĂ©s par des virgules. Par exemple : 1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31
  • Si le fichier data.txt n'existe pas, votre programme devra le crĂ©er avec un contenu par dĂ©faut (par exemple, une liste triĂ©e de nombres entre 1 et 100).

Lecture des données

  • Écrivez une fonction charger_liste() qui lit les nombres depuis le fichier data.txt, les convertit en une liste d'entiers et les retourne.

Recherche par interpolation

  • ImplĂ©mentez deux fonctions :
    • recherche_interpolation(liste, valeur) : RĂ©alise une recherche par interpolation.
    • recherche_dichotomique(liste, valeur) : RĂ©alise une recherche dichotomique.
  • Chaque fonction devra retourner :
    • L'index de l'Ă©lĂ©ment cherchĂ© (ou -1 s'il n'existe pas).
    • Le nombre d'itĂ©rations nĂ©cessaires.

Saisie utilisateur

  • Demandez Ă  l'utilisateur de saisir le nombre Ă  rechercher.

Comparaison des algorithmes

  • Enregistrez dans un fichier resultat.txt :
    • La position du nombre trouvĂ© ou un message indiquant qu'il n'existe pas.
    • Le nombre d'itĂ©rations utilisĂ©es par chaque mĂ©thode.

Exemple de cas démonstratif

  • Fournissez un exemple de liste triĂ©e oĂą la recherche par interpolation est plus efficace que la recherche dichotomique. Par exemple, une liste avec des valeurs fortement dispersĂ©es :
    1, 10, 100, 1000, 10000, 100000
  • Expliquez pourquoi, pour chercher un nombre proche de la fin de la liste, la recherche par interpolation est plus rapide. Expliquer aussi dans quel cas la recherche par dichotomie est plus efficace.

Exemple de résultat attendu :

  1. Contenu de data.txt :
    • 1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31
  2. Entrée utilisateur :
    • Entrez le nombre Ă  rechercher : 19
  3. Contenu de resultat.txt après exécution :
    • RĂ©sultat de la recherche pour le nombre 19 :
      • Recherche par interpolation : trouvĂ© Ă  l'index 9 en 1 itĂ©ration.
      • Recherche dichotomique : trouvĂ© Ă  l'index 9 en 3 itĂ©rations.
  4. Explication avec la liste fortement dispersée :
    • Si la liste est : 1, 10, 100, 1000, 10000, 100000
    • Chercher 100000 donnera les rĂ©sultats suivants :
      • Recherche par interpolation : 1 itĂ©ration.
      • Recherche dichotomique : 3 itĂ©rations.

🌶️ Exercice 22 : Jeu de Nim

Implémentez un jeu interactif de Nim où deux joueurs (humains ou un humain contre l'ordinateur) s'affrontent. Pour cela, vous devrez implémenter plusieurs fonctionnalités :

  • Affichage du plateau : Le programme doit afficher l’état des piles Ă  chaque tour.
  • EntrĂ©e utilisateur : Chaque joueur doit pouvoir choisir une pile et le nombre d’objets Ă  retirer.
  • Tour de l'ordinateur : ImplĂ©mentez une stratĂ©gie pour l’ordinateur :
    • Une stratĂ©gie simple (ex : retirer un objet).
    • Une stratĂ©gie optimale (ex : paritĂ© binaire XOR).
  • Gestion des erreurs : VĂ©rifiez la validitĂ© des choix des joueurs (pile existante, non vide, etc.).
  • Fin du jeu : Le jeu se termine lorsqu’il n’y a plus d’objets. Le joueur qui devait jouer perd la partie.
  • Enregistrement des scores : Ă€ la fin de chaque partie, enregistrez les rĂ©sultats (gagnant, perdant, et nombre de tours) dans un fichier scores.txt. Ce fichier doit ĂŞtre mis Ă  jour Ă  chaque nouvelle partie.
  • Mode multijoueur : Permettez Ă  deux joueurs humains de jouer.
  • Rejouer ou changer de mode : Après chaque partie, offrez la possibilitĂ© de rejouer ou de choisir un mode diffĂ©rent.
  • Statistiques des parties : Affichez Ă  la fin de chaque partie les statistiques cumulĂ©es (nombre de victoires, dĂ©faites pour chaque joueur).
  • Affichage de l’historique : Ajoutez une option pour afficher l’historique complet des parties enregistrĂ©es dans scores.txt.

Exemple de résultat attendu :

>> Bienvenue au jeu de Nim !
>> Choisissez le mode de jeu : 1 (Joueur vs Joueur) ou 2 (Joueur vs Ordinateur) : 2
>> Choisissez la difficulté : 1 (Simple) ou 2 (Optimale) : 1

>> État actuel des piles :
>> Pile 1: ||||| (5)
>> Pile 2: ||||||| (7)
>> Pile 3: ||| (3)

>> C'est au tour du joueur 1.
>> Choisissez une pile (1, 2 ou 3) : 2
>> Combien d'objets voulez-vous retirer de la pile 2 ? 1

>> État actuel des piles :
>> Pile 1: ||||| (5)
>> Pile 2: |||||| (6)
>> Pile 3: ||| (3)

>> C'est au tour du joueur 2.
>> L'ordinateur retire 1 objets de la pile 1.

>> État actuel des piles :
>> Pile 1: |||| (4)
>> Pile 2: |||||| (6)
>> Pile 3: ||| (3)

>> C'est au tour du joueur 1.
>> Choisissez une pile (1, 2 ou 3) :

🌶️ Exercice 23 : Cryptage et Décryptage de messages avec Clés Multiples

Implémentez un programme qui permet de crypter et de décrypter des messages en utilisant différentes clés de chiffrement. Les messages cryptés et décryptés seront enregistrés dans des fichiers, et le programme proposera une gestion dynamique des clés utilisées. Le cryptage est un processus visant à rendre un message illisible afin de le protéger. Le décryptage permet de retrouver le message original grâce à une clé.

Dans cet exercice, vous utiliserez essentiellement le chiffrement par décalage ASCII, une méthode où chaque caractère est décalé d'un certain nombre de positions dans la table ASCII, déterminé par une clé. Par exemple, si la clé est 3, le caractère A devient D, et Z revient à C grâce à un effet circulaire.

Votre programme doit permettre à l’utilisateur d’interagir avec les messages et les clés, et d’enregistrer les résultats dans des fichiers spécifiques. Vous devrez gérer les clés via un fichier cles.txt, les messages cryptés dans message_crypte.txt et les messages décryptés dans message_decrypte.txt.

Le programme devra inclure les fonctionnalités suivantes :

  1. Choix de l'opération : Proposez à l'utilisateur un menu interactif lui permettant de choisir entre crypter ou décrypter un message.
  2. Gestion des clés : Gérez les clés de chiffrement/déchiffrement via un fichier cles.txt :
    • Permettez d’afficher les clĂ©s disponibles.
    • Ajoutez ou supprimez des clĂ©s dans ce fichier.
  3. Cryptage :
    • L'utilisateur doit pouvoir choisir une clĂ© pour crypter les messages contenus dans le fichier messages_a_crypter.txt.
    • Les messages cryptĂ©s seront enregistrĂ©s dans un fichier message_crypte.txt.
  4. DĂ©cryptage :
    • L'utilisateur doit pouvoir choisir une clĂ© pour dĂ©crypter un fichier message_crypte.txt.
    • Si la clĂ© utilisĂ©e est correcte, les messages originaux seront affichĂ©s et enregistrĂ©s dans message_decrypte.txt.
  5. Validation et gestion des erreurs :
    • VĂ©rifiez que les clĂ©s saisies existent et que les fichiers nĂ©cessaires sont disponibles.
  6. Fonctionnalités supplémentaires :
    • Proposez diffĂ©rents algorithmes de cryptage comme :
      • Chiffrement par substitution : chaque caractère est remplacĂ© par un autre selon une correspondance dĂ©finie.
      • Chiffrement par transposition : l'ordre des caractères dans le message est rĂ©organisĂ© selon une règle spĂ©cifique.
      • Chiffrement XOR : chaque caractère est transformĂ© en appliquant une opĂ©ration logique XOR avec une clĂ© binaire.
      • Chiffrement asymĂ©trique : utilisez une paire de clĂ©s (publique et privĂ©e) pour sĂ©curiser les communications.
    • Ajoutez une option pour afficher l’historique des messages cryptĂ©s et dĂ©cryptĂ©s.

Exemple de résultat attendu :

>> === MENU PRINCIPAL ===
>> 1. Afficher les clés disponibles
>> 2. Ajouter une clé
>> 3. Supprimer une clé
>> 4. Crypter un message
>> 5. DĂ©crypter un message
>> 6. Afficher l'historique
>> 7. Quitter
>> Entrez votre choix : 2
>> Entrez une nouvelle clé (nombre entier) : 3
>> Clé 3 ajoutée.

>> === MENU PRINCIPAL ===
>> 1. Afficher les clés disponibles
>> 2. Ajouter une clé
>> 3. Supprimer une clé
>> 4. Crypter un message
>> 5. DĂ©crypter un message
>> 6. Afficher l'historique
>> 7. Quitter
>> Entrez votre choix : 4

>> Messages disponibles Ă  crypter :
>> 1. Exemple de message Ă  crypter 1
>> 2. Exemple de message Ă  crypter 2
>> Entrez le numéro du message à crypter : 1

>> Clés disponibles :
>> 1. 3
>> 2. 5
>> 3. 3
>> Entrez le numéro de la clé à utiliser : 1

>> Choisissez le type de cryptage:
>> 1. Chiffrement par décalage ASCII
>> 2. Chiffrement par substitution
>> 3. Chiffrement par transposition
>> 4. Chiffrement XOR
>> 5. Chiffrement asymétrique
>> Entrez votre choix : 1
>> Message crypté enregistré dans message_crypte.txt.

>> === MENU PRINCIPAL ===
>> 1. Afficher les clés disponibles
>> 2. Ajouter une clé
>> 3. Supprimer une clé
>> 4. Crypter un message
>> 5. DĂ©crypter un message
>> 6. Afficher l'historique
>> 7. Quitter
>> Entrez votre choix : 5

>> Clés disponibles :
>> 1. 3
>> 2. 5
>> 3. 3
>> Entrez le numéro de la clé à utiliser : 1

>> Choisissez le type de décryptage:
>> 1. Chiffrement par décalage ASCII
>> 2. Chiffrement par substitution
>> 3. Chiffrement par transposition
>> 4. Chiffrement XOR
>> Entrez votre choix : 1
>> Message décrypté enregistré dans message_decrypte.txt.

>> === MENU PRINCIPAL ===
>> 1. Afficher les clés disponibles
>> 2. Ajouter une clé
>> 3. Supprimer une clé
>> 4. Crypter un message
>> 5. DĂ©crypter un message
>> 6. Afficher l'historique
>> 7. Quitter
>> Entrez votre choix : 7
>> Au revoir !