Besoin urgent d'aide sur une fonction qui me semble pourtant simple à créer.

Version imprimable

Bonsoir, je suis en Terminale S et pour mon projet d' ISN, j'ai choisi de faire un programme permettant d'augmenter ses chances de gagner au Black Jack.
J'ai déjà bien avancé mais ça fait une journée que je bloque sur une fonction dont j'ai besoin mais que je n'arrive pas à créer.
En fait, grâce à la partie de mon programme que j'ai déjà fait, je peut savoir quelles seront les prochaines carte (cela peut aller de 1 a environ 25 cartes) qui tomberont mais pas dans quel ordre. Je connais aussi l'unique carte du croupier. Dans mes règles, le croupier est obligé (par le casino) de piocher à 16 et de s’arrêter à 17. Je voudrais maintenant savoir parmi tous les cas possibles, combien feraient que le croupier explose et combien feraient qu'il soit entre 17 et 21.
Il me faudrait donc une fonction qui me renvoie le nombre d'additions possible entre la valeur d'une variable et les termes d'une liste (qui seront tous compris entre 1 et 10 inclus) donnant un résultat compris entre 17 et 21 inclus.
Il faut que cette fonction marche peut importe la longueur de la liste.

Précisions :
On n'est bien sur pas obligé d'utiliser tous les termes de la liste.
On ne peut utiliser qu'une seule fois par addition chaque termes.

Voici ce que j'ai seulement réussi à faire. J'ai pensé qu'il serait peut être utile d'utiliser cette fonction dans une autre.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 mainCroupier=10 listeCroupier=[10,2,3,4,9,8,6,3,10] def Nbdefois(main,liste,min,max): possibilité=0 if liste!=[]: for element in liste: if min<=element+main<=max: possibilité+=1 return possibilité if liste==[]: return "vide"
Voila j’espère sincèrement que vous avez compris ce que je veux faire parce que j'ai vraiment besoin d'aide ^^. Je ne connais que les bases du langage python mais je suis d'habitude assez doué pour ce qui est logique pure. Si vous avez besoin de précisions dites le moi !

24/04/2015, 22h05
plxpy

"Besoin urgent d'aide sur une fonction qui me semble pourtant simple à créer."

Ca tombe bien, c'est urgent et on n'a que ça à faire !
En même temps, trop pas de chance !, cette année le bac tombe en Juin , comme Noël, le 25 décembre ...

(je n'ai pas pris (perdu) le temps à lire ton message, cela dit)
24/04/2015, 23h34
Mrflop124

J'ai pas vraiment compris le sens de ton message mais j'imagine que c'était pas très constructif... Mais on est bien sur le forum d'entraide non ? Donc au lieu de me lâcher ce message comme si j'étais qu'un idiot qui essaie seulement de gratter des points pour le bac tu pourrais au moins commencer par lire entièrement le mien.
Bref, j'espère qu'il y a des personnes plus intelligentes que ce "modérateur" inutile sur ce forum.

PS: Pour l'ISN c'est bien avant le bac qu'il faut rendre les projets.
25/04/2015, 06h06
__dardanos__

Citation:

Il me faudrait donc une fonction qui me renvoie le nombre d'additions possible entre la valeur d'une variable et les termes d'une liste (qui seront tous compris entre 1 et 10 inclus) donnant un résultat compris entre 17 et 21 inclus.

Salut.
Tu vas avoir besoin de itertools.permutations pour générer toutes les permutations de l'ensemble.
Itère sur chaque permutation en sommant élément par élément, jusqu'à dépasser la valeur maximale. Si la somme vérifie le critère et que cette solution n'a pas déjà été prise en compte, il faut la retenir.
25/04/2015, 11h53
plxpy
Salut

Citation:

Envoyé par Mrflop124

J'ai pas vraiment compris le sens de ton message mais j'imagine que c'était pas très constructif... Mais on est bien sur le forum d'entraide non ?

A l'avenir, si tu veux éviter les mouvements d'humeur (car c'était le cas), évite de débouler sur le forum comme un sauvage avec tes "urgent". Passons ...

Des trucs pas terribles :
- même si python 3 semble l'accepter, évite de mettre des caractères exotiques dans les noms de variables (de fonctions, de ...). Ton bout de code n'est pas spécifique à la version 3 mais, en version 2, l'interpréteur couine avec le 'é' de 'possibilité'
- évite également min et max comme noms de variables : ce sont des fonctions python. Préfère, par exemple, mini et maxi
- même si, en python, on a un typage dynamique, ta fonction qui retourne un entier OU la chaine "vide" est mal foutue. Déjà, si la liste est vide, ce serait mieux de retourner 0 possibilité. Si, vraiment, tu veux "fliquer" ce cas de figure, lève une exception
Quand on débute, c'est didactique de bien décomposer les choses.
Mais en python, ta fonction peut se réduire à :
Code:

1 2 [ elt for elt in liste if mini <= elt+main <= maxi ]

Citation:

Envoyé par __dardanos__

Salut.
Tu vas avoir besoin de itertools.permutations pour générer toutes les permutations de l'ensemble.
Itère sur chaque permutation en sommant élément par élément, jusqu'à dépasser la valeur maximale. Si la somme vérifie le critère et que cette solution n'a pas déjà été prise en compte, il faut la retenir.

Merci ! J'ai réussi à faire ce dont j'avais besoin grâce à ce module sans même utiliser une fonction. Par contre est ce normal que le calcul prenne autant de temps ? J'ai un ordi pas trop trop nul et le calcul met déjà plusieurs secondes à se faire donc j'ai peur pour les ordis du lycée ^^'.
Voila mon bout de code au cas ou vous auriez des simplifications à faire.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 ## Les variables Main, listeCroupier et mainCroupier sont définies et utilisées dans le début du code. Main c'est le total de points qu'on a en main... ## mainCroupier c'est la carte que le croupier a en main et listeCroupier c'est la liste contenant toutes les cartes que le croupier est susceptible de piocher quand son tour viendras ## (la liste peut être longue de 1 à une vingtaine valeurs) ChcCroupierPlus=0 ChcCroupierMoins=0 ChcCroupierPete=0 ChcTotale=0 for element in permutations(listeCroupier): list(element) mainCroupierPossible=mainCroupier for chiffre in element: mainCroupierPossible+=chiffre if Main<=mainCroupierPossible<22 and mainCroupierPossible>16: ChcCroupierPlus+=1 if mainCroupierPossible>21: ChcCroupierPete+=1 if 16<mainCroupierPossible<Main: ChcCroupierMoins+=1 if mainCroupierPossible>16: ChcTotale+=1 break
Citation:

A l'avenir, si tu veux éviter les mouvements d'humeur (car c'était le cas), évite de débouler sur le forum comme un sauvage avec tes "urgent". Passons ...

Des trucs pas terribles :

même si python 3 semble l'accepter, évite de mettre des caractères exotiques dans les noms de variables (de fonctions, de ...). Ton bout de code n'est pas spécifique à la version 3 mais, en version 2, l'interpréteur couine avec le 'é' de 'possibilité'
évite également min et max comme noms de variables : ce sont des fonctions python. Préfère, par exemple, mini et maxi
même si, en python, on a un typage dynamique, ta fonction qui retourne un entier OU la chaine "vide" est mal foutue. Déjà, si la liste est vide, ce serait mieux de retourner 0 possibilité. Si, vraiment, tu veux "fliquer" ce cas de figure, lève une exception

Ok je ferais attention. Merci pour les conseils (effectivement je me demandais pourquoi min et max n'étaient pas de la même couleur que les autres paramètres ^^).

C'est suspect. Il faudrait tout mettre à plat, faire un tableau des conditions.
Mais il semble que plusieurs variables peuvent être incrémentées en même temps.
Il doit y avoir moyen d'utiliser un if-elif-else.
Le break peut peut-être déplacé.

Mon programme pour le problème décrit dans le premier post s'exécute instantanément.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
from itertools import permutations
 
def all_permu(card, heap, mini=17, maxi=21):
    ans = []
    for permu in permutations(heap):
        run = [card]
        for item in permu:
            run.append(item)
            s = sum(run)
            if maxi < s:
                break
            elif mini <= s:
                run.sort()
                if not run in ans:
                    ans.append(run[:])
    return ans
 
if __name__ == '__main__':
    main = 10
    liste = [10,2,3,4,9,8,6,3,10]
    for idx, p in enumerate(sorted(all_permu(main, liste))):
        print('{} : {}'.format(idx + 1, p))

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1 : [2, 3, 3, 10]
2 : [2, 3, 4, 10]
3 : [2, 3, 6, 10]
4 : [2, 6, 10]
5 : [2, 8, 10]
6 : [2, 9, 10]
7 : [3, 3, 4, 10]
8 : [3, 4, 10]
9 : [3, 6, 10]
10 : [3, 8, 10]
11 : [4, 6, 10]
12 : [8, 10]
13 : [9, 10]
14 : [10, 10]

25/04/2015, 17h13
Mrflop124

Salut !
Effectivement lorsque je lance ton programme, il s’exécute presque instantanément mais il suffit que je rajoute un valeur à la liste pour que le calcul prenne plus de 15 secondes...
Mais je pense qu'il n'y a rien à améliorer c'est juste qu'il y a énormément de cas à traiter.
Tu dois avoir un ordinateur plus puissant que le mien mais essaie en ajoutant 2 ou 3 valeurs et je pense que ça fera la même chose.