Jeu de la vie, TP n°4

Utiliser le hasard (1)

  1. Afficher une série de 20 nombres entiers aléatoires compris entre 7 et 90.
    alea01.py [Cacher les numéros de ligne]
    1. import random
    2. for i in range(1,21) :
    3.     print i,":",int(random.random()*83)+7
  2. Écrire un programme qui remplit aléatoirement un tableau de 20 cases avec des espaces et des étoiles (*) en proportion 70%-30%, et qui les affiche ensuite à l'écran.
    alea02.py [Cacher les numéros de ligne]
    1. # -*- coding: utf-8 -*-
    2. import random                   # pour utiliser le hasard
    3. tableau=[]                      # création du tableau vide
    4. for i in range(0,20) :          # remplissage du tableau
    5.     if random.random()<0.7 :    # si tirage aléatoire dans la bonne proportion
    6.         tableau.append(" ")     # ajouter un espace
    7.     else :                      # sinon
    8.         tableau.append("*")     # ajouter une étoile
    9. for i in range(0,20) :          # afficher chaque case
    10.     print tableau[i],
    11. print                           # un dernier retour à la ligne
  3. Écrire un programme qui remplit aléatoirement un tableau de 15 lignes et 30 colonnes avec des espaces et des étoiles (*) en proportion 20%-80%, et qui les affiche ensuite à l'écran en utilisant curses, et en commençant à la 3ème ligne et à la 5ème colonne.
    alea03.py [Cacher les numéros de ligne]
    1. # -*- coding: utf-8 -*-
    2. import random,curses
    3. ###############################
    4. ####    INITIALISATIONS    ####
    5. ###############################
    6. ecran=curses.initscr()                  # créer l'écran graphique
    7. tableau=[]                              # création du tableau vide
    8. nblgn,nbcol=15,30                       # nombres de lignes et colonnes
    9. gauche,haut=2,5                         # décalages horizontal et vertical
    10. plein="*"                               # contenu d'une case pleine
    11. vide=" "                                # contenu d'une case vide
    12. proportion=0.2                          # proportion vide/plein
    13. ###########################
    14. ####    REMPLISSAGE    ####
    15. ###########################
    16. for l in range(0,nblgn) :               # pour chaque ligne
    17.     tableau.append([])                  # créer la ligne vide
    18.     for c in range(0,nbcol) :           # pour chaque colonne
    19.         if random.random()<proportion : # si tirage dans la bonne proportion
    20.             tableau[l].append(vide)     # ajouter un espace
    21.         else :                          # sinon
    22.             tableau[l].append(plein)    # ajouter une étoile
    23. #########################
    24. ####    AFFICHAGE    ####
    25. #########################
    26. for l in range(0,nblgn) :               # pour chaque ligne
    27.     for c in range(0,nbcol) :           # pour chaque colonne
    28.         # afficher la case correspondante au bon endroit
    29.         ecran.addstr(l+haut,c+gauche,tableau[l][c])
    30. ####################################
    31. ####    ATTENTE ET FERMETURE    ####
    32. ####################################
    33. ecran.getch()                           # attente d'une frappe clavier
    34. curses.endwin()                         # revenir à la console
  4. Transformer le programme précédent, en faisant boucler (affichage différent à chaque tour) jusqu'à ce qu'on appuie sur la touche « Q » (majuscule ou minuscule). Décomposer en fonctions. On changera la proportion espaces/étoiles au hasard à chaque tour.
    alea04.py [Cacher les numéros de ligne]
    1. # -*- coding: utf-8 -*-
    2. import random,curses
    3. ###################################
    4. ####    CRÉATION DU TABLEAU    ####
    5. ###################################
    6. def creation() :
    7.     global tableau
    8.     for l in range(nblgn) :                 # pour chaque ligne
    9.         tableau.append([vide]*nbcol)        # créer la ligne vide
    10. ######################################
    11. ####    REMPLISSAGE DU TABLEAU    ####
    12. ######################################
    13. def remplissage() :
    14.     global tableau
    15.     proportion=random.random()              # proportion espace/étoile
    16.     for l in range(0,nblgn) :               # pour chaque ligne
    17.         for c in range(0,nbcol) :           # pour chaque colonne
    18.             if random.random()>proportion : # si tirage dans la bonne proportion
    19.                 tableau[l][c]=vide          # ajouter un espace
    20.             else :                          # sinon
    21.                 tableau[l][c]=plein         # ajouter une étoile
    22. #########################
    23. ####    AFFICHAGE    ####
    24. #########################
    25. def affichage() :
    26.     for l in range(0,nblgn) :               # pour chaque ligne
    27.         for c in range(0,nbcol) :           # pour chaque colonne
    28.             # afficher la case correspondante au bon endroit
    29.             ecran.addstr(l+haut,c+gauche,tableau[l][c])
    30. ####################################
    31. ####    ATTENTE ET FERMETURE    ####
    32. ####################################
    33. def finir() :
    34.     curses.endwin()                         # revenir à la console
    35.  
    36. ###############################
    37. ####    INITIALISATIONS    ####
    38. ###############################
    39. ecran=curses.initscr()                      # créer l'écran graphique
    40. ecran.nodelay(1)                            # getch() non bloquant
    41. curses.curs_set(False)                      # pas d'affichage du curseur
    42. tableau=[]                                  # création du tableau vide
    43. nblgn=15                                    # nombre de lignes
    44. nbcol=30                                    # nombre de colonnes
    45. gauche=5                                    # décalage horizontal
    46. haut=3                                      # décalage vertical
    47. sortie=[ord('q'),ord('Q')]                  # touches pour finir
    48. plein="*"                                   # contenu d'une case pleine
    49. vide=" "                                    # contenu d'une case vide
    50. ##################################
    51. ####    CORPS DU PROGRAMME    ####
    52. ##################################
    53. creation()
    54. k=0                         # initialisation pour rentrer dans la boucle
    55. while k not in sortie :     # TQ on n'a pas appuyé sur une touche pour sortir
    56.     remplissage()           # remplissage du terrain
    57.     affichage()             # affichage du terrain
    58.     k=ecran.getch()         # récupérér la touche sur laquelle on a appuyé
    59. finir()                     # sortir de l'écran graphique
Dernière modification : 25/8/2016