Discussion :

[Walernac]

Bonjour je ne comprends pas pourquoi l'aléatoire gagne tout le temps. Il est aléatoire...
Aidez moi svp.

Merci d'avance

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
from random import *
 
choix = ['T','C']  # T : Trahison, C : Coopération
 
def gain(lui,moi):
    if lui=='C' and moi=='C':
        return 3
    elif lui=='C' and moi=='T':
        return 5
    elif lui=='T' and moi=='C':
        return 0
    elif lui=='T' and moi=='T':
        return 1
 
 
# Toujours seul
# ne coopére jamais
 
def toujours_seul(liste_lui,liste_moi):
    return 'T'
 
 
# Bonne poire
# coopére toujours
 
def bonne_poire(liste_lui,liste_moi):
    return 'C'
 
 
# Aléatoire
# joue avec une probabilité égale 'T' ou 'C'
 
def aleatoire(liste_lui,liste_moi):
    global choix
    return choice(choix)
 
 
# Donnant donnant
# coopère seulement si l'autre joueur a coopèré au coup précédent.
 
def donnant_donnant(liste_lui,liste_moi):
    if len(liste_lui)>0:
        return liste_lui[-1]
    else:  # premier coup
        return 'C'
 
# Majorité
# coopére seulement si l'autre joueur a coopéré en majorité depuis le début.
 
def majorite(liste_lui,liste_moi):
    if len(liste_lui)>0:
        if liste_lui.count('C') > len(liste_lui)//2:
            return 'C'
        else:
            return 'T'
    else:
        return 'C'
 
# Stratégies à rajouter ici  →
# Le tournoi
 
liste = {}
strategie = {}
score = {}
duel = {}
 
liste['Toujours seul'] = []
liste['Bonne poire'] = []
liste['Aléatoire'] = []
liste['Majorité'] = []
liste['Donnant donnant'] = []
 
# on peut les désactiver ici pour voir ne fonction de ses adversaires
 
strategie['Toujours seul'] = lambda lui, moi : toujours_seul(lui,moi)
strategie['Bonne poire'] = lambda lui, moi : bonne_poire(lui,moi)
strategie['Majorité'] = lambda lui, moi : majorite(lui,moi)
strategie['Aléatoire'] = lambda lui, moi : aleatoire(lui,moi)
strategie['Donnant donnant'] = lambda lui, moi : donnant_donnant(lui,moi)
 
 
nb_total_coups = 10  ## ca peut changer jusqu'à 1000 sinon ça bug sur mon pc
 
for joueur in liste.keys():
    score[joueur] = 0
 
for i in liste.keys():  # i et j sont les joueurs
    for j in liste.keys() :
        liste[i] = []
        liste[j] = []
        if i>=j:
            nb_coups = 0
            score_joueur1 = 0
            score_joueur2 = 0
            seed(45226)
            while nb_coups < nb_total_coups :
                coup_joueur1 = strategie[i](liste[j],liste[i])
                coup_joueur2 = strategie[j](liste[i],liste[j])
                liste[i].append(coup_joueur1)
                if i!=j:
                    liste[j].append(coup_joueur2)
                score_joueur1 += gain(coup_joueur2,coup_joueur1)
                score_joueur2 += gain(coup_joueur1,coup_joueur2)
                nb_coups += 1
            duel[(i,j)] = score_joueur1
            if i!=j:
                duel[(j,i)] = score_joueur2
            score[i] += score_joueur1
            if i!=j:
                score[j] += score_joueur2
 
# affichage des résultats
 
def trie_par_valeur(d):
    return sorted(d.items(), key=lambda x: x[1])
 
def trie_par_cle(d):
    return sorted(d.items(), key=lambda x: x[0])
 
score_trie = trie_par_valeur(score)
score_trie.reverse()
for i in range(0,len(score_trie)):
    print(score_trie[i][0],":",score_trie[i][1])
print()
duel_trie = trie_par_cle(duel)
for i in range(0,len(duel_trie)):
    print(duel_trie[i][0][0],"contre",duel_trie[i][0][1],"gagne",duel_trie[i][1],"points")

[wiztricks]

Salut,

ligne 95: seed(45226)...

- W

[Sve@r]

Bonjour

J'aime bien ton code J'avais fait un truc analogue pour évaluer l'algorithme de Monty hall...

Allez, un petit coup de pouce pour optimiser quelques trucs...

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
def gain(lui, moi):
	return {
		("C", "C") : 3,
		("C", "T") : 5,
		("T", "C") : 0,
		("T", "T") : 1,
	}[lui, moi]

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
def aleatoire(liste_lui,liste_moi):
    return choice(choix)

(toute variable définie dans le namescope "global" est directement accessible en lecture par toutes les fonctions => inutile de remettre global)

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
def donnant_donnant(liste_lui,liste_moi):
	return liste_lui[-1] if liste_lui else "C"
 
def majorite(liste_lui,liste_moi):
	return "C" if not liste_lui or liste_lui.count('C') > len(liste_lui)//2 else "T"

(inutile de tester len(iterable) > 0 pour vérifier son remplissage. En Python, tout itérable non vide est considéré comme vrai => if iterable (plus généralement, tout en Python est vrai sauf False, None, 0 (et tout nombre assimilé à 0 comme par exemple une fraction 0/n ou un complexe 0+0i) et tout iltérable vide). Et pour la "majorite" ben si tu réfléchis un peu tu verras que la simplification était évidente (sinon utilise les tables de De Morgan ))

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
liste = {
	"Toujours seul" : [],
	"Bonne poire" : [],
	"Aléatoire" : [],
	"Majorité" : [],
	"Donnant donnant" : [],
}
strategie = {
	"Toujours seul" : toujours_seul,
	"Bonne poire" : bonne_poire,
	"Aléatoire" : aleatoire,
	"Majorité" : majorite,
	"Donnant donnant" : donnant_donnant,
}

(tu as le droit de remplir ton dico à la création. Et une fonction étant un objet, elle est alors directement utilisable sans avoir besoin de l'encapsuler dans une lambda)

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def trie_par_valeur(d):
    return sorted(d.items(), key=lambda x: x[1])
 
def trie_par_cle(d):
    return sorted(d.items(), key=lambda x: x[0])
 
score_trie = trie_par_valeur(score)
score_trie.reverse()
for i in range(0,len(score_trie)):
    print(score_trie[i][0],":",score_trie[i][1])
print()
duel_trie = trie_par_cle(duel)
for i in range(0,len(duel_trie)):
    print(duel_trie[i][0][0],"contre",duel_trie[i][0][1],"gagne",duel_trie[i][1],"points")

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
def trie_par_valeur(d):
    return sorted(d.items(), key=lambda x: x[1], reverse=True)
 
def trie_par_cle(d):
    return sorted(d.items(), key=lambda x: x[0])
 
for s in trie_par_valeur(score):
	print(s[0],":",s[1])
print()
for d in trie_par_cle(duel):
	print(d[0][0],"contre",d[0][1],"gagne",d[1],"points")