Python pour Jessy

Exercices sur les chaines de caractères

Exercice 1 — Inverser une chaîne

Écris un programme qui demande une phrase à l’utilisateur et l’affiche à l’envers.

Exemple : "Bonjour" → "ruojnoB"

Exercice 2 — Vérifier si un mot est un palindrome

Écris un programme qui vérifie si un mot saisi par l’utilisateur se lit pareil dans les deux sens.

Exemple : "kayak" → "C'est un palindrome" / "chat" → "Ce n'est pas un palindrome"

Exercice 3 — Censurer un mot dans une phrase

Écris un programme qui demande une phrase et un mot à censurer, puis remplace chaque lettre de ce mot par une étoile *.

Exemple : phrase "le chat mange la souris", mot "chat" → "le **** mange la souris"

Exercice 4 — Compter les mots d’une phrase

Écris un programme qui demande une phrase et affiche le nombre de mots qu’elle contient, ainsi que le mot le plus long.

Exemple : "Le petit chat est content" → 5 mots, mot le plus long : content

Exercice 5 — Encoder une phrase en ROT13

Écris un programme qui encode une phrase en décalant chaque lettre de 13 positions dans l’alphabet (a→n, b→o, etc.). Les espaces et la ponctuation ne changent pas.

Exemple : "Bonjour" → "Obawbhe"

INDICE pour l’exercice 5 :

  • fonction modulo %
  • fonction index sur chaine de caractère

TRAVAIL SUR LES STRUCTURES DE DONNES (tableaux, appelé liste en python)

Exercice 1 : Gestion de l’inventaire

Tu travailles pour un primeur. Il a une liste de fruits en stock : ["Pomme", "Banane", "Orange"].

  1. Affiche le deuxième fruit de la liste.
  2. Le stock de bananes est épuisé, remplace « Banane » par « Fraise« .
  3. Le primeur reçoit une livraison : ajoute « Kiwi » à la fin de la liste.
  4. Affiche la phrase : « Le magasin possède X types de fruits », où X est la taille de la liste.

Exercice 2 : Coordonnées GPS

On représente une carte simplifiée par une liste de listes (un tableau 2D). Chaque sous-liste est une ligne de la carte : carte = [[10, 20, 30], [40, 50, 60]]

  1. Quelle commande permet d’afficher spécifiquement le nombre 50 ?
  2. Utilise une boucle for pour afficher chaque ligne de la carte l’une après l’autre.

Exercice 3 : Le Calculateur de Notes

Voici tes notes du trimestre : [12, 15, 8, 19, 11].

  1. Crée une variable somme qui commence à 0.
  2. Utilise une boucle for pour parcourir tes notes et les ajouter à somme.
  3. Calcule et affiche la moyenne (somme divisée par le nombre de notes).
  4. Défi : Affiche uniquement les notes qui sont strictement supérieures à 10.

Exercice 4 : Station Météo

On a relevé les températures sur 3 jours (matin, midi, soir) : releves = [[12, 15, 14], [10, 11, 12], [18, 20, 19]]

  1. À l’aide de boucles imbriquées (une boucle dans une boucle), affiche toutes les températures les unes après les autres.
  2. Trouve et affiche la température maximale enregistrée sur toute la période.

Exercice 5 : Le Créateur de Grille (Expert)

  1. Crée un script qui génère automatiquement un tableau de 3×3 rempli de chiffres 0.
  2. Modifie ton code pour que les chiffres sur la diagonale (en haut à gauche jusqu’en bas à droite) soient des 1. Indice : Sur la diagonale, l’indice de la ligne est égal à l’indice de la colonne.

EXERCICE 6 :

Nouvel Énoncé : Le Calculateur Dynamique

Objectif : Créer un programme interactif qui calcule la moyenne d’une classe, peu importe le nombre d’élèves.

Consignes :

  1. Demande à l’utilisateur de saisir une note.
  2. Si l’utilisateur saisit un nombre négatif (par exemple -1), le programme s’arrête.
  3. Chaque note valide doit être ajoutée à une liste nommée tableau_notes.
  4. Une fois la saisie terminée :
    • Affiche le nombre total de notes saisies.
    • Calcule et affiche la moyenne de la liste.
    • Affiche la note la plus haute et la plus basse (Indice : utilise max() et min()).

Exercice 7 :

Énoncé : Le Registre de Classe Interactif

Objectif : Créer un répertoire complet de la classe et calculer les statistiques finales.

Le programme permet d’ajouter des éléves et d’ajouter leurs notes respectives

Consignes :

  1. Crée une liste vide nommée registre.
  2. Utilise une boucle pour demander à l’utilisateur :
    • Le nom de l’élève (si l’utilisateur tape « fin », on arrête la saisie).
    • La note de cet élève.
  3. Chaque élève doit être enregistré dans le registre sous forme de liste : [nom, note].
  4. À la fin de la saisie :
    • Affiche la liste complète des élèves et leurs notes respectives.
    • Calcule la moyenne de la classe.
    • Défi : Affiche le nom de l’élève qui a eu la meilleure note.

🗺️ Projet : Générateur de Mondes Virtuels (Procedural Map)

Contexte

L’objectif est de créer un programme capable de générer des cartes de jeux vidéo de manière aléatoire mais cohérente (créer des continents, pas juste des points au hasard). Nous allons utiliser la technique du lissage par voisinage.

Phase 1 : La structure de base

  1. Variables de configuration : Définis une taille de grille (ex: TAILLE = 20).
  2. Génération : Crée une liste de listes contenant des nombres entiers aléatoires entre 0 et 9.
  3. Affichage simple : Parcours la grille avec deux boucles for pour afficher un symbole selon la valeur (ex: ~ si < 5, # sinon).

Phase 2 : L’algorithme de lissage

Le but est d’éviter l’aspect « neige de télévision ».

  1. Crée une deuxième grille vide.
  2. Pour chaque case de la première grille, calcule la moyenne de sa valeur avec celle de ses voisins (Haut, Bas, Gauche, Droite).
    • Attention : Vérifie bien que tu ne sors pas de la grille avec des if avant d’accéder à un voisin !
  3. Stocke cette moyenne dans la deuxième grille.
  4. Remplace la grille principale par cette nouvelle grille lissée.

Phase 3 : L’évolution (Itérations)

  1. Englobe tout ton code de lissage dans une boucle pour pouvoir lisser la carte plusieurs fois (ex: 5 ou 10 fois).
  2. Observe comment les « taches » de terrain s’agrandissent à chaque passage.

Phase 4 : Rendu visuel « Premium »

  1. Couleurs ou Emojis : Remplace l’affichage simple par un affichage utilisant soit des codes couleurs ANSI, soit des emojis (🟦, 🏖️, 🌲, 🏔️).
  2. Seuils de terrain : Ajuste tes conditions if/elif pour définir où commence l’eau, le sable, la forêt et la montagne.

💡 Défis Bonus pour les experts :

  • Le niveau de la mer : Ajoute une variable NIVEAU_MER. Si l’utilisateur l’augmente, plus de cases deviennent de l’eau.
  • L’Explorateur : Place un personnage P au milieu de la carte.
  • Exportation : Arriverais-tu à sauvegarder le résultat final dans un fichier texte nommé carte.txt ?

Consignes techniques :

  • Utilise uniquement la bibliothèque random.
  • Ton code doit être commenté pour expliquer chaque étape.
  • Fais attention à l’ordre des variables pour éviter les erreurs NameError.

Lien pour initiation Programmation Orientée Objet

https://blog.stephane-robert.info/docs/developper/programmation/python/poo-base

Défi Python : Crée ton propre Donjon Roguelike en POO !

Objectif : Utiliser la Programmation Orientée Objet (POO) pour coder un jeu de rôle (RPG) textuel où un héros affronte des monstres de plus en plus puissants dans un donjon infini. Après chaque victoire, tu devras gérer un système d’amélioration (le côté « Roguelike »).

🛠️ Étape 1 : Le « Moule » du Personnage (La Classe)

Crée une classe nommée Personnage. Chaque personnage (le joueur comme le monstre) doit posséder :

  • Des attributs (ses caractéristiques) :
    • nom (chaîne de caractères).
    • vie_max (un nombre entier qui stocke ses PV maximum).
    • vie (ses PV actuels, qui commencent égaux à sa vie_max).
    • attaque (sa puissance de base).
  • Des méthodes (ses actions) :
    • est_en_vie(self) : renvoie True si le personnage a encore des PV, False sinon.
    • soigner_completement(self) : remet l’attribut vie au niveau de vie_max.
    • attaquer(self, cible) :
      1. Génère un lancer de dé aléatoire entre 1 et 6 (utilise le module random).
      2. Calcule les dégâts totaux : $\text{attaque de base} + \text{résultat du dé}$.
      3. Enlève ces dégâts aux PV de la cible (attention, les PV de la cible ne doivent pas descendre en dessous de 0).
      4. Affiche dans la console le détail de l’action (le dé, les dégâts infligés et les PV restants de la cible).

🔄 Étape 2 : La Boucle Principale du Jeu (Le Gameplay)

Dans ton script principal, écris la logique du jeu en respectant l’enchaînement suivant :

  1. Initialisation : Demande son nom au joueur avec un input() et crée son personnage (ex: 100 PV max, 15 Attaque). Crée une variable etage qui commence à 1.
  2. La grande boucle : Tant que ton joueur est en vie, il entre dans un nouvel étage.
  3. Génération automatique du Monstre : À chaque étage, crée un nouvel objet Personnage (le monstre). Ses PV max et son attaque doivent augmenter automatiquement en fonction du numéro de l’étage pour que le jeu devienne de plus en plus difficile !
  4. La boucle de combat : Lance un combat au tour par tour (une boucle dans la boucle).
    • Le joueur appuie sur ENTRÉE pour attaquer le monstre.
    • Si le monstre survit, il attaque le joueur à son tour.
    • Le combat s’arrête dès qu’un des deux meurt.
  5. Fin du combat :
    • Si le joueur meurt : Affiche un message de Game Over avec l’étage maximal atteint, et le programme s’arrête.
    • Si le joueur gagne : Affiche un menu de récompense. Propose-lui de choisir entre :
      • Choix 1 : Se soigner complètement (Fontaine de jouvence).
      • Choix 2 : Augmenter définitivement son attaque de base de +5.
  6. Progression : Augmente l’étage de 1, et la grande boucle recommence !

💡 Indices pour t’aider :

  • N’oublie pas d’importer les modules nécessaires au tout début de ton fichier : import random pour le dé et import time si tu veux utiliser time.sleep() pour ralentir le texte et rendre les combats plus vivants.
  • Pense bien à utiliser le mot-clé self à l’intérieur de ta classe pour modifier les données spécifiques du personnage qui agit.
  • Prends une feuille et un stylo pour schématiser tes deux boucles while : la boucle globale du donjon, et la boucle locale du combat en cours !