GoupillWiki

Outils pour utilisateurs

Outils du site

Piste :
nsi:jeu:puissance4

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
Prochaine révision		Révision précédente
nsi:jeu:puissance4 [2021/10/22 23:35] – ↷ Page déplacée de nsi:tds:serveur_web20:nsi:jeu:puissance4 à nsi:jeu:puissance4 goupillwikinsi:jeu:puissance4 [2022/12/09 12:14] (Version actuelle) – goupillwiki
Ligne 73: Ligne 73:
  
 //Bien que j'ai noté ce tableau sur plusieurs lignes, il s'agit bien d'un tableau à une dimension puisqu'il n'y a qu'une paire de crochets.// //Bien que j'ai noté ce tableau sur plusieurs lignes, il s'agit bien d'un tableau à une dimension puisqu'il n'y a qu'une paire de crochets.//
 +
 +<code python>
 +# c'est exactement le même tableau du point de vue de Python :
 +[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 1, 2, 0, 0, 0, 1, 2, 2, 1, 0, 0, 2, 1, 1, 1, 2, 2, 0]
 +</code>
  
 === Créer une grille vide === === Créer une grille vide ===
  
 <code python linenums:9> <code python linenums:9>
-def make_empty_grid():+def make_empty_grid() -> list:
     """     """
     Renvoie un tableau de LIGNES * COLS cases et ne contenant que des 0     Renvoie un tableau de LIGNES * COLS cases et ne contenant que des 0
Ligne 87: Ligne 92:
  
 <code python linenums:15> <code python linenums:15>
-def read(grid, lig, col):+def read(grid:list, lig:int, col:int) -> int:
     """     """
     grid: tableau de LIGNES * COLS éléments     grid: tableau de LIGNES * COLS éléments
Ligne 109: Ligne 114:
 # SYMBOLS[0] correspond à une case vide. # SYMBOLS[0] correspond à une case vide.
  
-def display(grid):+def grid_to_str(grid:list) -> str:
     """     """
     grid: tableau de LIGNES * COLS éléments     grid: tableau de LIGNES * COLS éléments
-    affiche la grille en mode texte dans la console.+    renvoie une version texte de la grille.
     """     """
     # création d'une grille avec les symboles au lieu des numéros     # création d'une grille avec les symboles au lieu des numéros
Ligne 134: Ligne 139:
  
 <code python linenums:41> <code python linenums:41>
-def col_is_full(grid, col):+def col_is_full(grid:list, col:int) -> bool:
     """     """
     grid: tableau de LIGNES * COLS éléments     grid: tableau de LIGNES * COLS éléments
Ligne 148: Ligne 153:
  
 <code python linenums:49> <code python linenums:49>
-def grid_is_full(grid):+def grid_is_full(grid:list) -> bool:
     """     """
     grid: tableau de LIGNES * COLS éléments     grid: tableau de LIGNES * COLS éléments
Ligne 161: Ligne 166:
  
 <code python linenums:56> <code python linenums:56>
-def insert(grid, col, player):+def insert(grid:list, col:int, player:int):
     """     """
     grid: tableau de LIGNES * COLS éléments     grid: tableau de LIGNES * COLS éléments
Ligne 171: Ligne 176:
 </code>     </code>    
  
-=== Vérifier une victoire ===+=== Vérifier un alignement ===
  
-Cette partie est plus difficile. L'humain reconnaît d'un coup d’œil la présence ou l'absence d'alignement. Je vous propose l'approche suivante :+Cette partie est plus difficile. L'humain reconnaît d'un coup d'œil la présence ou l'absence d'alignement. Je vous propose l'approche suivante :
  
   * On choisit une orientation -- diagonale ↘, diagonale ↗, verticale, horizontale   * On choisit une orientation -- diagonale ↘, diagonale ↗, verticale, horizontale
   * On choisit un point de départ, par exemple le coin supérieur gauche   * On choisit un point de départ, par exemple le coin supérieur gauche
-  * On parcours la grille depuis ce point de départ dans la direction donnée et on compte les symboles rencontrés. Pour cela, on mémorise le contenu de la case précédente et quand la nouvelle case est identique on ajoute 1 à un compteur. Comme on ne veut pas compter les cases vides, on n'ajoute 1 que si la nouvelle case n'est pas une case vide. +  * On parcourt cet alignement du point de départ jusqu'à atteindre un bord. On relève les valeurs rencontrées.
-  * Quand on en rencontre une quantité suffisante pour faire un alignement on répond que la fonction a trouvé un alignement. +
-  * Si on atteint un bord sans trouver d'alignement, la fonction répond qu'elle n'a pas trouvé d'alignement. +
- +
-Voici un algorithme possible+
  
 <code lang-none> <code lang-none>
 +FONCTION get_line
 ENTRÉES ENTRÉES
-  grille +    grille 
-  pas: déplacement à faire d'un case à l'autre +    pas: déplacement à faire d'un case à l'autre 
-  départ: position de départ+    depart: position de départ 
 +SORTIE: une chaîne de caractères line valeurs de l'alignement
 DÉBUT DÉBUT
-  soit position en cours définie par la position de départ +    soit position en cours définie par la position de depart 
-  soit 0 le contenu en cours +    soit line une chaine vide 
-  soit 0 la valeur du compteur +    TANT QUE position en cours à l'intérieur de la grille RÉPÉTER 
-  TANT QUE position en cours à l'intérieur de la grille RÉPÉTER +        lire le contenu de la grille en position, 
-    soit j le contenu de la grille à la position en cours +        ajouter ce qui a été lu au bout de line 
-    SI j == 0 ALORS +        modifier position selon le pas
-      mettre compteur à 0 et contenu en cours à 0 +
-    SINON SI j == contenu en cours ALORS +
-      augmenter le compteur de 1 +
-    SINON +
-      contenu en cours devient égal à j +
-      Le compteur passe à 1+
     FIN     FIN
-    SI compteur >= quantité nécessaire pour gagner ALORS +    RENVOYER line
-      RENVOYER VRAI +
-    FIN +
-    changer la position courante selon le pas +
-  FIN +
-  RENVOYER FAUX+
 FIN FIN
 </code> </code>
-     
-Traduisez cet algorithme en fonction. 
  
-<code python linenums:65> +//Exemple :// 
-def line_has_victory(grid, step, start): +<code lang-none> 
-    """ +0000000 
-    grid: grille de jeu +0000000 
-    step: paire (step_lig,step_col) indiquant le déplacement d'une case à la suivante +0010000 
-    start: paire (start_lig, start_col) indiquant la position de départ +0022200 
-    renvoie True si un alignement gagnant a été trouvé, False sinon +0012120 
-    """ +1121211
-    # À vous !+
 </code> </code>
-    +Si on se donne ''depart= (0,0)'', cela désigne le coin supérieur gauche. ''pas = (1,1)'' fait se déplacer en diagonale ↘. L'appel ''get_line(grille, pas, depart)'' doit renvoyer ''%%"001211"%%''. 
 Exemple d'utilisation : Exemple d'utilisation :
-  * ''%%line_has_victory(grid, (1,1), (0,0))%%'' recherche une victoire dans la diagonale ↘ partant du coin supérieur droit, +  * ''%%get_line(grid, (1,1), (0,0))%%'' renvoie la diagonale ↘ partant du coin supérieur droit, 
-  * ''%%line_has_victory(grid, (1,1), (0,1))%%'' recherche une victoire dans la diagonale ↘ partant de la deuxième case de la première ligne, +  * ''%%get_line(grid, (1,1), (0,1))%%'' renvoie la diagonale ↘ partant de la deuxième case de la première ligne, 
-  * ''%%line_has_victory(grid, (-1,1), (0,3))%%'' recherche une victoire dans la diagonale ↙ partant de la quatrième case de la première ligne, +  * ''%%get_line(grid, (-1,1), (0,3))%%'' renvoie la diagonale ↙ partant de la quatrième case de la première ligne, 
-  * ''%%line_has_victory(grid, (0,1), (0,3))%%'' recherche une victoire dans la colonne partant de la quatrième case de la première ligne, +  * ''%%get_line(grid, (0,1), (0,3))%%'' renvoie la colonne partant de la quatrième case de la première ligne, 
-  * ''%%line_has_victory(grid, (1,0), (2,0))%%'' recherche une victoire dans la troisième ligne.+  * ''%%get_line(grid, (1,0), (2,0))%%'' renvoie la troisième ligne. 
 + 
 +On ajoute une deuxième fonction pour compter le nombre max de répétitions d'un symbole : 
 + 
 +<code python> 
 +def line_has_victory(line:str, valeur:int) -> bool: 
 +    ''' 
 +    line: chaîne représentant un alignement. ex : "012111" 
 +    valeur: valeur recherchée. ex : 1 
 +    renvoie True si line contient un alignement assez long 
 +      ex: ici non, il n'y a que 3 fois le 1 à la suite 
 +    ''' 
 +</code>
  
 Et maintenant vous pouvez envisager une fonction qui parcours toutes les lignes possibles à la recherche d'une victoire. Et maintenant vous pouvez envisager une fonction qui parcours toutes les lignes possibles à la recherche d'une victoire.
  
 <code python linenums:74> <code python linenums:74>
-def grid_has_victory(grid):+def grid_has_victory(grid:list) -> bool:
     """     """
     grid: grille de jeu     grid: grille de jeu
Ligne 255: Ligne 257:
 TO_WIN = 4 # Nombre de jetons à aligner pour gagner TO_WIN = 4 # Nombre de jetons à aligner pour gagner
  
-def make_empty_grid():+def make_empty_grid() -> list:
     """     """
     Renvoie un tableau de LIGNES * COLS cases et ne contenant que des 0     Renvoie un tableau de LIGNES * COLS cases et ne contenant que des 0
Ligne 261: Ligne 263:
     # à vous de compléter     # à vous de compléter
          
-def read(grid, lig, col):+def read(grid:list, lig:int, col:int) -> int:
     """     """
     grid: tableau de LIGNES * COLS éléments     grid: tableau de LIGNES * COLS éléments
Ligne 276: Ligne 278:
 # SYMBOLS[0] correspond à une case vide. # SYMBOLS[0] correspond à une case vide.
  
-def display(grid):+def grid_to_str(grid:list) -> str:
     """     """
     grid: tableau de LIGNES * COLS éléments     grid: tableau de LIGNES * COLS éléments
-    affiche la grille en mode texte dans la console.+    renvoie une version texte de la grille.
     """     """
     # création d'une grille avec les symboles au lieu des numéros     # création d'une grille avec les symboles au lieu des numéros
Ligne 287: Ligne 289:
     return "\n".join(symb_lignes)     return "\n".join(symb_lignes)
  
-def col_is_full(grid, col):+def col_is_full(grid:list, col:int) -> bool:
     """     """
     grid: tableau de LIGNES * COLS éléments     grid: tableau de LIGNES * COLS éléments
Ligne 295: Ligne 297:
     # à vous...     # à vous...
  
-def grid_is_full(grid):+def grid_is_full(grid:list) -> bool:
     """     """
     grid: tableau de LIGNES * COLS éléments     grid: tableau de LIGNES * COLS éléments
Ligne 302: Ligne 304:
     # à vous...     # à vous...
  
-def insert(grid, col, player):+def insert(grid:list, col:int, player:int):
     """     """
     grid: tableau de LIGNES * COLS éléments     grid: tableau de LIGNES * COLS éléments
Ligne 311: Ligne 313:
     # À vous !     # À vous !
  
-def line_has_victory(grid, step, start):+def get_line(grid:list, step:tuple, start:tuple) -> str:
     """     """
     grid: grille de jeu     grid: grille de jeu
     step: paire (step_lig,step_col) indiquant le déplacement d'une case à la suivante     step: paire (step_lig,step_col) indiquant le déplacement d'une case à la suivante
     start: paire (start_lig, start_col) indiquant la position de départ     start: paire (start_lig, start_col) indiquant la position de départ
-    renvoie True si un alignement gagnant a été trouvé, False sinon+    renvoie une chaîne correspondant à l'alignement demandé
     """     """
     # À vous !     # À vous !
  
-def grid_has_victory(grid):+def line_has_victory(line:str, valeur:int) -> bool: 
 +    ''' 
 +    line: chaîne représentant un alignement. ex : "012111" 
 +    valeur: valeur recherchée. ex : 1 
 +    renvoie True si line contient un alignement assez long 
 +      ex: ici non, il n'y a que 3 fois le 1 à la suite 
 +    ''' 
 + 
 +def grid_has_victory(grid:list) -> bool:
     """     """
     grid: grille de jeu     grid: grille de jeu
Ligne 333: Ligne 343:
  
 <code python linenums> <code python linenums>
-""" +# main.py
-module: main +
-"""+
  
 from fonctionspuissance4 import * from fonctionspuissance4 import *
Ligne 342: Ligne 350:
 Ensuite le jeu suit l'algorithme suivant : Ensuite le jeu suit l'algorithme suivant :
  
-<code lang:none linenums>+<code lang-none>
 DÉBUT DÉBUT
-  créer une grille vide +    créer une grille vide
-  afficher la grille +
-  joueur en cours est 1 +
-  partie_finie est faux +
-  TANT QUE partie finie est faux RÉPÉTER +
-    demander au joueur en quelle colonne il souhaite jouer +
-    jouer le coup pour le joueur en cours+
     afficher la grille     afficher la grille
-    SI la grille contient une victoire ALORS +    joueur en cours est 1 
-      partie_finie passe à vrai +    partie_finie est faux 
-      afficher un message indiquant la victoire du joueur +    TANT QUE partie finie est faux RÉPÉTER 
-    SINON SI la grille est pleine ALORS +        demander au joueur en quelle colonne il souhaite jouer 
-      partie_finie passe à vrai +        jouer le coup pour le joueur en cours 
-      afficher un message indiquant le match nul+        afficher la grille 
 +        SI la grille contient une victoire ALORS 
 +            partie_finie passe à vrai 
 +            afficher un message indiquant la victoire du joueur 
 +        SINON SI la grille est pleine ALORS 
 +            partie_finie passe à vrai 
 +            afficher un message indiquant le match nul 
 +        SINON 
 +            changer de joueur 
 +        FIN
     FIN     FIN
-  FIN 
 FIN FIN
 </code> </code>
  
 À vous de compléter le fichier ''main.py'' À vous de compléter le fichier ''main.py''
nsi/jeu/puissance4.1634938522.txt.gz · Dernière modification : de goupillwiki