Inscription / Connexion Nouveau Sujet
Accueil l'île des mathématiques Forum de mathématiquesListe de tous les forums de mathématiques AutreForum traitant des mathématiques, un peu moins scolaires AlgorithmiqueForum consacré aux algorithme AutreTopics traitant de autre [tout]Lister tous les topics de mathématiques
Niveau algorithmique
Score de bowling algo
Posté par akanecrystal
bonjour
je doit faire cet exercice en algo avec python mais je n'y arrive pas auriez vous des idées ?
Une partie de bowling comporte 10 tours (frames en langage technique), chacun pouvant comporter 2 lancers,
dont le but est à chaque fois de faire tomber 10 quilles.
Si au premier lancer d'un tour les 10 quilles sont tombées, on appelle cela un strike et il n'y a pas de second
lancer. Si au premier lancer il reste des quilles debout, on procède à un deuxième lancer, et si les 10 quilles
sont tombées après le second lancer, on appelle cela un spare.
A chaque lancer réalisé, on note le nombre de quilles abattues dans un tableau à 2 dimensions (appelons-le
lancers) dont l'indice de colonne représente le tour et l'indice de ligne le lancer. Par exemple le résultat du
deuxième lancer du sixième tour gurera dans lancers[1][5].
Le score se calcule en additionnant tous les résultats des lancers . . . avec les subtilités suivantes :
? si à un tour on fait un spare, on ajoute au score de ce tour le résultat du lancer suivant
? si à un tour on fait un strike, on ajoute au score de ce tour les résultats des 2 lancers suivants.
Pour pouvoir appliquer cette règle jusqu'au bout, le joueur aura le droit à 1 lancer supplémentaire s'il fait
un spare au dixième tour, et à 2 lancers supplémentaires s'il y fait un strike. Notons que dans ce dernier cas
les 10 quilles sont remises en places s'il refait un strike au premier lancer supplémentaire.
Voici un exemple de calcul qui assure au joueur un score final de 149 :
tour 1 2 3 4 5 6 7 8 9 10 sup 1 sup 2
lancer 1 3 2 5 10 7 5 10 10 7 5 8
lancer 2 5 8 4 0 5 2 5
remarque spare strike spare strike strike spare
score 8 10+5 9 10+7+0 7 10+10 10+10+7 10+7+2 9 10+8
cumul 8 23 32 49 56 76 103 122 131 149
Concevoir et implémenter (sous le nom TP_05_2.py) un algorithme qui saisit les résultats des lancers puis
qui calcule le score du joueur. Au final, l'algorithme doit aficher le tableau de 5 lignes : le numéro du tour,
les résultats des lancers, les scores et le score cumulé ; puis qu'une phrase de conclusion avec le score final.
merci d'avance pour vos réponse 
voici de que j'ai fait pour l'instant mais je ne sait pas si c'est bon et je n'arrive pas a prendre le résultat de nombre de quille et a le mettre dans le tableaux
i = int
j = int
score1= [0,1,2,3,4,5,6,7,8,9,10]
from math import *
from random import *
i= [0,0,0,0,0,0,0,0,0,0]
j=[0,0,0,0,0,0,0,0,0,0]
for i in range(10) :
lancer1 = int(input("nombre de quilles tombé"))
if lancer1 == 10 :
print ("strike fin du tour")
else :
print ("vous pouvez relancer")
for j in range :
if lancer1 <10 :
lancer2 = int(input("nombre de quilles tombé"))
print ("fin du tour")
else :
print ("pas de lancer")
salut
Citation :
Voici un exemple de calcul qui assure au joueur un score final de 149 :
tour 1 2 3 4 5 6 7 8 9 10 sup 1 sup 2
lancer 1 3 2 5 10 7 5 10 10 7 5 8
lancer 2 5 8 4 0 5 2 5
remarque spare strike spare strike strike spare
score 8 10+5 9 10+7+0 7 10+10 10+10+7 10+7+2 9 10+8
cumul 8 23 32 49 56 76 103 122 131 149
pas clair du tout ... car illisible ...
Voici un exemple de calcul qui assure au joueur un score final de 149 :
tour 1 2 3 4 5 6 7 8 9 10 sup 1 sup 2
lancer 1 3 2 5 10 7 5 10 10 7 5 8
lancer 2 5 8 4 0 5 2 5
remarque spare strike spare strike strike spare
score 8 10+5 9 10+7+0 7 10+10 10+10+7 10+7+2 9 10+8
cumul 8 23 32 49 56 76 103 122 131 149
il y a deux étapes :
1/ dénombrer les points en incluant un éventuel strike ou spare au dixième tour
2/ les sommer
je considérerai probablement la liste Tour
avec Tour (i) = (a, b, u, v)
a = nombre de quilles au premier lancer
b = nombre de quilles au deuxième lancer (b = 0 si a = 10)
u et v des variables booléennes :
u est vrai si a = 10 (on fait un strike)
v est vrai si a + b = 10 (on fait un spare)
pour i de 1 à 10 on génère tour (i) + éventuellement tour 11
les variables booléennes permettent alors de calculer le score cumulé et total ...
peut-être même que tour (i) = (a, b, u, v, s) où s est le score cumulé après le tour i
mais attention s n'est pas forcément le bon cumul puisqu'un strike ou un spare nécessite d'avoir les résultats du coup d'après ...
Bonsoir.
Juste pour le fun, script à modifier à volonté....
#*******************************************************************************
# IMPORT ***********************************************************************
#*******************************************************************************
# module pour le système d'exploitation
import os
# module specifique pour le systeme
import sys
#*******************************************************************************
# CONSTANTES *******************************************************************
#*******************************************************************************
NOMBRE_TOURS_PAR_PARTIE = 10 + 2
INDEX_LANCER_1 = 0
INDEX_LANCER_2 = 1
INDEX_POINTS = 2
INDEX_CUMULS = 3
INDEX_STRIKE = 4
INDEX_SPARE = 5
#*******************************************************************************
# GLOBALES *********************************************************************
#*******************************************************************************
# tableau des resultats, vide par defaut
g_ll_tableau = [None] * NOMBRE_TOURS_PAR_PARTIE
#*******************************************************************************
# DEF **************************************************************************
#*******************************************************************************
# -- calculer_cumuls -----------------------------------------------------------
#
# Description : calcul des cumuls
#
# Parameters :
#
# Return :
#
# Notes :
#
def calculer_cumuls() :
# balayage des tours
for i in range(NOMBRE_TOURS_PAR_PARTIE) :
if i == 0 :
g_ll_tableau[i][INDEX_CUMULS] = g_ll_tableau[i][INDEX_POINTS]
else :
g_ll_tableau[i][INDEX_CUMULS] = g_ll_tableau[i-1][INDEX_CUMULS] + \
g_ll_tableau[i][INDEX_POINTS]
# -- calculer_points -----------------------------------------------------------
#
# Description : calcul des points
#
# Parameters :
#
# Return :
#
# Notes :
#
def calculer_points() :
# balayage des tours
for i in range(NOMBRE_TOURS_PAR_PARTIE - 2) :
# deux strike consecutifs ?
if g_ll_tableau[i][INDEX_STRIKE] is True and \
g_ll_tableau[i+1][INDEX_STRIKE] is True :
# oui : nombre de points = nombre des points du tour et des 2 lancers suivants
g_ll_tableau[i][INDEX_POINTS] = g_ll_tableau[i][INDEX_LANCER_1] + \
g_ll_tableau[i+1][INDEX_LANCER_1] + \
g_ll_tableau[i+2][INDEX_LANCER_1]
# non : un strike isole ?
elif g_ll_tableau[i][INDEX_STRIKE] is True and \
g_ll_tableau[i+1][INDEX_STRIKE] is False :
# oui : nombre de points = nombre des points du tour et des 2 lancers suivants
g_ll_tableau[i][INDEX_POINTS] = g_ll_tableau[i][INDEX_LANCER_1] + \
g_ll_tableau[i+1][INDEX_LANCER_1] + \
g_ll_tableau[i+1][INDEX_LANCER_2]
# non : un spare ?
elif g_ll_tableau[i][INDEX_SPARE] is True :
# oui : nombre de points = nombre des points du tour et du lancer suivant
g_ll_tableau[i][INDEX_POINTS] = g_ll_tableau[i][INDEX_LANCER_1] + \
g_ll_tableau[i][INDEX_LANCER_2] + \
g_ll_tableau[i+1][INDEX_LANCER_1]
else :
# non : nombre de points = nombre des points du tour
g_ll_tableau[i][INDEX_POINTS] = g_ll_tableau[i][INDEX_LANCER_1] + \
g_ll_tableau[i][INDEX_LANCER_2]
# -- afficher_resultats --------------------------------------------------------
#
# Description : affichage des resultats
#
# Parameters : - arg_numero_tour ~
#
# Return :
#
# Notes :
#
def afficher_resultats(arg_numero_tour) :
# effacement de l'ecran (facultatif)
os.system('cls')
print(" ")
# affichage de la 1ere ligne ------------------------------------------------
ligne = " ----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+----- "
print(ligne)
# affichage de la ligne des tours -------------------------------------------
ligne = " ! Tour ! 1 ! 2 ! 3 ! 4 ! 5 ! 6 ! 7 ! 8 ! 9 ! 10 ! S1 ! S2 !"
print(ligne)
ligne = " !----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----!"
print(ligne)
# affichage de la ligne des lancers 1 ---------------------------------------
ligne = " ! Lancer 1 !"
for i in range(NOMBRE_TOURS_PAR_PARTIE) :
if i <= arg_numero_tour :
if g_ll_tableau[i][INDEX_LANCER_1] < 10 :
ligne += " " + str(g_ll_tableau[i][INDEX_LANCER_1]) + " !"
else :
ligne += " " + str(g_ll_tableau[i][INDEX_LANCER_1]) + " !"
else :
ligne += " - !"
print(ligne)
# affichage de la ligne des lancers 2 ---------------------------------------
ligne = " ! Lancer 2 !"
for i in range(NOMBRE_TOURS_PAR_PARTIE) :
if i <= arg_numero_tour :
if g_ll_tableau[i][INDEX_LANCER_2] < 10 :
ligne += " " + str(g_ll_tableau[i][INDEX_LANCER_2]) + " !"
else :
ligne += " " + str(g_ll_tableau[i][INDEX_LANCER_2]) + " !"
else :
ligne += " - !"
print(ligne)
# affichage de la ligne des points ------------------------------------------
ligne = " ! Points !"
for i in range(NOMBRE_TOURS_PAR_PARTIE) :
if i <= arg_numero_tour and i < 10 :
if g_ll_tableau[i][INDEX_POINTS] < 10 :
ligne += " " + str(g_ll_tableau[i][INDEX_POINTS]) + " !"
elif g_ll_tableau[i][INDEX_POINTS] < 100 :
ligne += " " + str(g_ll_tableau[i][INDEX_POINTS]) + " !"
else :
ligne += " " + str(g_ll_tableau[i][INDEX_POINTS]) + " !"
else :
ligne += " - !"
print(ligne)
# affichage de la ligne des points cumules ----------------------------------
ligne = " ! Cumuls !"
for i in range(NOMBRE_TOURS_PAR_PARTIE) :
if i <= arg_numero_tour and i < 10 :
if g_ll_tableau[i][INDEX_CUMULS] < 10 :
ligne += " " + str(g_ll_tableau[i][INDEX_CUMULS]) + " !"
elif g_ll_tableau[i][INDEX_CUMULS] < 100 :
ligne += " " + str(g_ll_tableau[i][INDEX_CUMULS]) + " !"
else :
ligne += " " + str(g_ll_tableau[i][INDEX_CUMULS]) + " !"
else :
ligne += " - !"
print(ligne)
# affichage de la ligne des symboles ----------------------------------------
ligne = " !----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----!"
print(ligne)
ligne = " ! Symboles !"
for i in range(NOMBRE_TOURS_PAR_PARTIE) :
if i <= arg_numero_tour and i < 10 :
if g_ll_tableau[i][INDEX_STRIKE] is True :
ligne += " X !"
elif g_ll_tableau[i][INDEX_SPARE] is True :
ligne += " / !"
else :
ligne += " O !"
else :
ligne += " - !"
print(ligne)
# affichage de la derniere ligne
ligne = " ----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+----- "
print(ligne)
print(" ")
#*******************************************************************************
# MAIN *************************************************************************
#*******************************************************************************
# effacement de l'ecran (facultatif)
os.system('cls')
print(" ")
# generation du tableau de resultat
for i in range(len(g_ll_tableau)) : g_ll_tableau[i] = [0, 0, 0, 0, False, False]
# numero de tour courant
numero_tour = 0
# affichage du tableau des scores initial
afficher_resultats(numero_tour)
# boucle tant que le nombre de tour n'est pas atteint
while numero_tour < NOMBRE_TOURS_PAR_PARTIE :
# premier lancer d'un tour --------------------------------------------------
# saisie du nombre de quilles tombees au premier lancer
nombre_quilles_tombees = 11
while nombre_quilles_tombees > 10 :
texte_saisie = " Tour " + str(numero_tour + 1) + " / 1er lancer : " + " Nombre de quilles tombees ? : "
nombre_quilles_tombees = input(texte_saisie)
print(" ")
g_ll_tableau[numero_tour][INDEX_LANCER_1] = nombre_quilles_tombees
# mise a jour du nombre de points pour le 1er lancer du tour
g_ll_tableau[numero_tour][INDEX_POINTS] = g_ll_tableau[numero_tour][INDEX_LANCER_1]
# strike (10 quilles tombees au premier lancer du tour) ?
if g_ll_tableau[numero_tour][INDEX_LANCER_1] == 10 :
# oui : memorise le strike
g_ll_tableau[numero_tour][INDEX_STRIKE] = True
# calcul des points
calculer_points()
# calcul des cumuls
calculer_cumuls()
# affichage du tableau des scores
afficher_resultats(numero_tour)
# pas de strike au premier lancer ?
if g_ll_tableau[numero_tour][INDEX_STRIKE] is False and numero_tour < 10 :
# oui : deuxieme lancer du tour ------------------------------------------
nombre_quilles_tombees = 11
while nombre_quilles_tombees > 10 - g_ll_tableau[numero_tour][INDEX_LANCER_1] :
texte_saisie = " Tour " + str(numero_tour + 1) + " / 2nd lancer : " + " Nombre de quilles tombees ? : "
nombre_quilles_tombees = input(texte_saisie)
print(" ")
g_ll_tableau[numero_tour][INDEX_LANCER_2] = nombre_quilles_tombees
# spare (10 quilles tombees a la fin du tour) ?
if g_ll_tableau[numero_tour][INDEX_LANCER_1] + g_ll_tableau[numero_tour][INDEX_LANCER_2] == 10 :
# oui : memorise le spare
g_ll_tableau[numero_tour][INDEX_SPARE] = True
# calcul des points
calculer_points()
# calcul des cumuls
calculer_cumuls()
# affichage du tableau des scores
afficher_resultats(numero_tour)
# tour 10 termine sans strike ni spare ?
if (numero_tour == 9 and (g_ll_tableau[9][INDEX_STRIKE] is False and g_ll_tableau[9][INDEX_SPARE] is False)) :
# oui : fin de partie
break
if numero_tour == 10 and g_ll_tableau[9][INDEX_SPARE] is True :
# oui : fin de partie
break
# tour suivant
numero_tour += 1
Tableau des scores initial :
----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
! Tour ! 1 ! 2 ! 3 ! 4 ! 5 ! 6 ! 7 ! 8 ! 9 ! 10 ! S1 ! S2 !
!----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----!
! Lancer 1 ! 0 ! - ! - ! - ! - ! - ! - ! - ! - ! - ! - ! - !
! Lancer 2 ! 0 ! - ! - ! - ! - ! - ! - ! - ! - ! - ! - ! - !
! Points ! 0 ! - ! - ! - ! - ! - ! - ! - ! - ! - ! - ! - !
! Cumuls ! 0 ! - ! - ! - ! - ! - ! - ! - ! - ! - ! - ! - !
!----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----!
! Symboles ! O ! - ! - ! - ! - ! - ! - ! - ! - ! - ! - ! - !
----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
Tour 1 / 1er lancer : Nombre de quilles tombees ? :
Exemple :
----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
! Tour ! 1 ! 2 ! 3 ! 4 ! 5 ! 6 ! 7 ! 8 ! 9 ! 10 ! S1 ! S2 !
!----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----!
! Lancer 1 ! 1 ! 5 ! 8 ! 10 ! 1 ! 7 ! 4 ! 7 ! 4 ! 6 ! 2 ! - !
! Lancer 2 ! 2 ! 5 ! 1 ! 0 ! 0 ! 1 ! 3 ! 3 ! 2 ! 4 ! 0 ! - !
! Points ! 3 ! 18 ! 9 ! 11 ! 1 ! 8 ! 7 ! 14 ! 6 ! 12 ! - ! - !
! Cumuls ! 3 ! 21 ! 30 ! 41 ! 42 ! 50 ! 57 ! 71 ! 77 ! 89 ! - ! - !
!----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----!
! Symboles ! O ! / ! O ! X ! O ! O ! O ! / ! O ! / ! - ! - !
----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
Exemple de gain max :
----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
! Tour ! 1 ! 2 ! 3 ! 4 ! 5 ! 6 ! 7 ! 8 ! 9 ! 10 ! S1 ! S2 !
!----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----!
! Lancer 1 ! 10 ! 10 ! 10 ! 10 ! 10 ! 10 ! 10 ! 10 ! 10 ! 10 ! 10 ! 10 !
! Lancer 2 ! 0 ! 0 ! 0 ! 0 ! 0 ! 0 ! 0 ! 0 ! 0 ! 0 ! 0 ! 0 !
! Points ! 30 ! 30 ! 30 ! 30 ! 30 ! 30 ! 30 ! 30 ! 30 ! 30 ! - ! - !
! Cumuls ! 30 ! 60 ! 90 ! 120 ! 150 ! 180 ! 210 ! 240 ! 270 ! 300 ! - ! - !
!----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----!
! Symboles ! X ! X ! X ! X ! X ! X ! X ! X ! X ! X ! - ! - !
----------+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----
Annuler
connectez vous