[Python] 2048 Intelligence Artificielle sur le forum Programmation - 05-03-2015 16:57:22

ClemFrr

Niveau 1

05 mars 2015 à 16:57:22

Bonjour,

Je viens vers vous car j'ai besoin d'aide sur un projet à rendre sous peu.
Je doit coder sous Python un algorithme intelligent qui résout le jeu 2048 à 100%.

Pour ce faire, j'ai tout d'abord codé les déplacements du jeu :

import random, sys, copy

matrice = [[2,0,0,0],
[0,0,0,0],
[0,0,0,0],
[0,0,0,2]]

def tourner_matrice(matrice):
n = []
for i in range(4):
n.append([matrice[3][i], matrice[2][i], matrice[1][i], matrice[0][i]])
return n

def glisser_droite(matrice):
nouvelle_matrice = []
for ligne in matrice :
ligne = [elem for elem in ligne if elem!=0]
for i in range(len(ligne)-1,0,-1):
if ligne[i]==ligne[i-1]:
ligne[i] = ligne[i]+ligne[i-1]
ligne[i-1] = 0
ligne = [elem for elem in ligne if elem!=0]
ligne = [0]*(4-len(ligne))+ligne
nouvelle_matrice.append(ligne)
return nouvelle_matrice

def glisser_gauche(matrice):
nouvelle_matrice = []
for ligne in matrice :
ligne = [elem for elem in ligne if elem!=0]
for i in range(0,len(ligne)-1,1):
if ligne[i]==ligne[i+1]:
ligne[i] = ligne[i]+ligne[i+1]
ligne[i+1] = 0
ligne = [elem for elem in ligne if elem!=0]
ligne = ligne+[0]*(4-len(ligne))
nouvelle_matrice.append(ligne)
return nouvelle_matrice

def glisser_haut(matrice):
matrice = tourner_matrice(matrice)
nouvelle_matrice = glisser_droite(matrice)
for i in range(3):
nouvelle_matrice= tourner_matrice(nouvelle_matrice)
return nouvelle_matrice

def glisser_bas(matrice):
for i in range(3):
matrice = tourner_matrice(matrice)
nouvelle_matrice = glisser_droite(matrice)
nouvelle_matrice = tourner_matrice(nouvelle_matrice)
return nouvelle_matrice

def aleatoire(nouvelle_matrice):
liste = []
for i in range(4):
for j in range(4):
if nouvelle_matrice[i][j] == 0:
liste.append((i,j))

if liste== []:
return nouvelle_matrice
bite = random.choice(liste)
nouvelle_matrice[bite[0]][bite[1]] = random.choice([2,4])
return nouvelle_matrice

Il a fallu ensuite concevoir une fonction d'évaluation (c'est cette partie qui est à ameliorer) basée sur divers arguments afin de choisir la matrice (gauche, droite, haut ou bas) pour l'état suivant :

def maximum(m):
h=2
for i in range (4):
for j in range (4):
if m[i][j]>h:
h=m[i][j]
return h

def nbre_zero(m):
k=0
for i in range (4):
for j in range (4):
if m[i][j]==0:
k=k+1
return k

def nombre_addition_ligne (m):
f=0
for ligne in m :
ligne = [elem for elem in ligne if elem!=0]
for i in range(len(ligne)-1,0,-1):
ligne[i-1]==ligne[i]
f=f+1
return f

def nombre_addition_colonne(m):
g=0
m=tourner_matrice(m)
for ligne in m :
ligne = [elem for elem in ligne if elem!=0]
for i in range(0,len(ligne)-1,1):
ligne[i]==ligne[i+1]
g=g+1
return g

def sousmax(m):
h=2
for i in range (4):
for j in range (4):
if m[i][j]>h and m[i][j]< maximum(m):
h=m[i][j]
return h

def sous_sousmax(m):
h=2
for i in range (4):
for j in range (4):
if m[i][j]>h and m[i][j]<sousmax(m):
h=m[i][j]
return h

def sous_sous_sousmax(m):
h=2
for i in range (4):
for j in range(4):
if m[i][j]>h and m[i][j]<sous_sousmax(m):
h=m[i][j]
return h

def c_pleine (m):
if m[0][0]!=0 and m[1][0]!=0 and m[2][0]!=0 and m[3][0 ]!=0:
return True
else:
return False

def evaluation (matrice, etat_actuel):

if matrice==etat_actuel:
return -sys.maxsize
score=0

if maximum(matrice)==matrice[0][0]:
score += pow(matrice[0][0],3)

else:
score += 0

score += pow(maximum(matrice),2)

o = nbre_zero(matrice)
score += pow(o,3)

for i in range (4):
for j in range (4):
if matrice[0][0]==maximum(matrice) and matrice[0][1]==sousmax(matrice):
score += pow(sousmax(matrice),2.5)
if matrice[0][1]==sousmax(matrice) and matrice[0][2]==sous_sousmax(matrice):
score += pow(sous_sousmax(matrice),2.5)
if matrice[0][2]==sous_sousmax(matrice) and matrice[0][3]==sous_sous_sousmax(matrice):
score+= pow(sous_sous_sousmax(matrice),2.5)

return score

if c_pleine (matrice) == True :
score+=pow(matrice[1][0],2)
else :
score+=0

if matrice[1][0]>matrice[2][0] and matrice[2][0]>matrice[3][0] and matrice[3][0]>0:
score +=pow(matrice[1][0],2.5)
else:
score +=0

'''
a = nombre_addition_ligne(matrice)
if a==0:
score += 0
else:
score += pow(a,10)

e = nombre_addition_colonne(matrice)
if e==0:
score += 0
else:
score += pow(e,10)
'''

Voici ensuite l'algorithme du jeu:

def jouer(matrice):

matrice_gauche = glisser_gauche(matrice)
matrice_droite = glisser_droite(matrice)
matrice_haut = glisser_haut(matrice)
matrice_bas = glisser_bas(matrice)
if matrice_gauche==matrice_droite==matrice_haut==matrice_bas:
print "************************************************************************************"
return "aucune", None

score_gauche = evaluation(matrice_gauche, matrice)
score_droite = evaluation(matrice_droite, matrice)
score_haut = evaluation(matrice_haut, matrice)
score_bas = evaluation(matrice_bas, matrice)

print score_gauche
print score_droite
print score_haut
print score_bas

score_max = max(score_gauche, score_droite, score_haut, score_bas)

if(score_max == score_gauche):
return "gauche", matrice_gauche
elif(score_max == score_droite):
return "droite", matrice_droite
elif(score_max == score_haut):
return "haut", matrice_haut
else:
return "bas", matrice_bas

for i in range(1000):
print("tour",i)
nouvelle_direction, nouvelle_matrice = jouer(matrice)
if nouvelle_direction=="aucune":
print " You failed - Try again (Gautier suce)"
matrice = aleatoire(nouvelle_matrice)
print(nouvelle_direction,nouvelle_matrice)

Un algorithme minmax doit aussi être établi mais ma fonction d'évaluation est trop faible pour y penser :p
En voici un début :

def minmax(etat_jeu):
matrice_gauche = glisser_gauche(etat_jeu)
matrice_droite = glisser_droite(etat_jeu)
matrice_haut = glisser_haut(etat_jeu)
matrice_bas = glisser_bas(etat_jeu)
mon_tour=[matrice_gauche, matrice_droite, matrice_haut,matrice_bas]
tour_ordinateur=[]
for tour in mon_tour:
for i in range (4):
for j in range (4):
if matrice[i][j]==0:
matrice[i][j]=2
nouvelle_matrice = copy.deepcopy(matrice)
tour_ordinateur.append(nouvelle_matrice)
mon_tour[i]=(tour, tour_ordinateur)
i= i+1

Voilà voilà, il me faudrait donc de l'aide pour aboutir ! Merci d'avance !!

Dark_Chouhartem

Niveau 11

05 mars 2015 à 21:34:24

bite = random.choice(liste)

C’est tout ce que j’ai lu en parcourant

Sinon utilise <code>…</code>

ClemFrr

Niveau 1

05 mars 2015 à 21:40:17

Une bonne blague de mon binôme surement ... :p


import random, sys, copy

matrice = [[2,0,0,0],
           [0,0,0,0],
           [0,0,0,0],
           [0,0,0,2]]


def tourner_matrice(matrice):
    n = []   
    for i in range(4):
        n.append([matrice[3][i], matrice[2][i], matrice[1][i], matrice[0][i]])
    return n
         
def glisser_droite(matrice): 
    nouvelle_matrice = [] 
    for ligne in matrice : 
        ligne = [elem for elem in ligne if elem!=0] 
        for i in range(len(ligne)-1,0,-1): 
            if ligne[i]==ligne[i-1]: 
                ligne[i] = ligne[i]+ligne[i-1] 
                ligne[i-1] = 0 
        ligne = [elem for elem in ligne if elem!=0] 
        ligne = [0]*(4-len(ligne))+ligne 
        nouvelle_matrice.append(ligne) 
    return nouvelle_matrice     

def glisser_gauche(matrice): 
    nouvelle_matrice = [] 
    for ligne in matrice : 
        ligne = [elem for elem in ligne if elem!=0] 
        for i in range(0,len(ligne)-1,1): 
            if ligne[i]==ligne[i+1]: 
                ligne[i] = ligne[i]+ligne[i+1] 
                ligne[i+1] = 0 
        ligne = [elem for elem in ligne if elem!=0] 
        ligne = ligne+[0]*(4-len(ligne))
        nouvelle_matrice.append(ligne) 
    return nouvelle_matrice

   
def glisser_haut(matrice):
    matrice = tourner_matrice(matrice)
    nouvelle_matrice = glisser_droite(matrice)
    for i in range(3):
        nouvelle_matrice= tourner_matrice(nouvelle_matrice)
    return nouvelle_matrice
 
def glisser_bas(matrice):
    for i in range(3):
        matrice = tourner_matrice(matrice)
    nouvelle_matrice = glisser_droite(matrice)
    nouvelle_matrice = tourner_matrice(nouvelle_matrice)
    return nouvelle_matrice

def aleatoire(nouvelle_matrice):
    liste = []
    for i in range(4):
        for j in range(4):
            if nouvelle_matrice[i][j] == 0:
                liste.append((i,j))
    
    if liste== []:
        return nouvelle_matrice
    pion = random.choice(liste)    
    nouvelle_matrice[pion[0]][pion[1]] = random.choice([2,4])
    return nouvelle_matrice
    
#=============================================================================#
    
                              # EVALUATION    
    
def maximum(m):
    h=2
    for i in range (4):
        for j in range (4):
            if m[i][j]>h:
                h=m[i][j]
    return h
    
def nbre_zero(m): 
    k=0
    for i in range (4):
        for j in range (4):
            if m[i][j]==0:
                k=k+1
    return k
    
def nombre_addition_ligne (m):
    f=0
    for ligne in m : 
        ligne = [elem for elem in ligne if elem!=0] 
        for i in range(len(ligne)-1,0,-1): 
            ligne[i-1]==ligne[i]
            f=f+1
        return f
            
def nombre_addition_colonne(m):
    g=0
    m=tourner_matrice(m)
    for ligne in m : 
        ligne = [elem for elem in ligne if elem!=0] 
        for i in range(0,len(ligne)-1,1): 
            ligne[i]==ligne[i+1]
            g=g+1
        return g

def sousmax(m):          
    h=2
    for i in range (4):
        for j in range (4):
            if m[i][j]>h and m[i][j]< maximum(m):
                h=m[i][j]
    return h

def sous_sousmax(m):
    h=2
    for i in range (4):
        for j in range (4):
            if m[i][j]>h and m[i][j]<sousmax(m):
                h=m[i][j]
    return h         
    
def sous_sous_sousmax(m):
    h=2 
    for i in range (4):
        for j in range(4):
            if m[i][j]>h and m[i][j]<sous_sousmax(m):
                h=m[i][j]
    return h


    
def c_pleine (m):
	if m[0][0]!=0 and m[1][0]!=0 and m[2][0]!=0 and m[3][0 ]!=0: 
		return True
	else:
		return False    
    
    
def evaluation (matrice, etat_actuel):
    
    if matrice==etat_actuel:
        return -sys.maxsize
    score=0
    
    if maximum(matrice)==matrice[0][0]:
        score += pow(matrice[0][0],5)
        
    else:
        score += 0

    score += pow(maximum(matrice),4)        
        
    o = nbre_zero(matrice)  
    score += pow(o,3)
    
    for i in range (4):
        for j in range (4):        
            if matrice[0][0]==maximum(matrice) and matrice[0][1]==sousmax(matrice):
                score += pow(sousmax(matrice),2.5)
            if matrice[0][1]==sousmax(matrice) and matrice[0][2]==sous_sousmax(matrice):
                score += pow(sous_sousmax(matrice),2.5)
            if matrice[0][2]==sous_sousmax(matrice) and matrice[0][3]==sous_sous_sousmax(matrice):
                score+= pow(sous_sous_sousmax(matrice),2.5)

    return score   
    
    if c_pleine (matrice) == True :
        score+=pow(matrice[1][0],2)
    else :
        score+=0

    if matrice[1][0]>matrice[2][0] and matrice[2][0]>matrice[3][0] and matrice[3][0]>0:
        score +=pow(matrice[1][0],2.5)
    else:
        score +=0        
    
    a = nombre_addition_ligne(matrice)
    if a==0:
        score += 0
    else:     
        score += pow(a,10)
    
    e = nombre_addition_colonne(matrice)
    if e==0:
        score += 0  
    else:
        score += pow(e,10)
    
  
###############################################################################
  
                                #JEU#   

def jouer(matrice):
    
    matrice_gauche = glisser_gauche(matrice)
    matrice_droite = glisser_droite(matrice)
    matrice_haut = glisser_haut(matrice)
    matrice_bas = glisser_bas(matrice)
    if matrice_gauche==matrice_droite==matrice_haut==matrice_bas:
        print "************************************************************************************"
        return "aucune", None
  
    score_gauche = evaluation(matrice_gauche, matrice)
    score_droite = evaluation(matrice_droite, matrice)
    score_haut = evaluation(matrice_haut, matrice)
    score_bas = evaluation(matrice_bas, matrice)
 
    print score_gauche
    print score_droite
    print score_haut
    print score_bas

    score_max = max(score_gauche, score_droite, score_haut, score_bas)

    if(score_max == score_gauche):
        return "gauche", matrice_gauche
    elif(score_max == score_droite):
        return "droite", matrice_droite
    elif(score_max == score_haut):
        return "haut", matrice_haut
    else:
        return "bas", matrice_bas
 
 

for i in range(1000):
    print("tour",i)
    nouvelle_direction, nouvelle_matrice = jouer(matrice)
    if nouvelle_direction=="aucune":
        print "                                       You failed - Try again (Gautier suce)"
    matrice = aleatoire(nouvelle_matrice)
    print(nouvelle_direction,nouvelle_matrice)
    
    
    
###############################################################################
    
                                    #MINMAX#
'''
def minmax(etat_jeu):
    matrice_gauche = glisser_gauche(etat_jeu)
    matrice_droite = glisser_droite(etat_jeu)
    matrice_haut = glisser_haut(etat_jeu)
    matrice_bas = glisser_bas(etat_jeu)
    mon_tour=[matrice_gauche, matrice_droite, matrice_haut,matrice_bas]
    tour_ordinateur=[]
    for tour in mon_tour:
        for i in range (4):
            for j in range (4):
                if matrice[i][j]==0:
                    matrice[i][j]=2
                    nouvelle_matrice = copy.deepcopy(matrice)
                    tour_ordinateur.append(nouvelle_matrice)
        mon_tour[i]=(tour, tour_ordinateur)
        i= i+1
            
            
            
 '''

Voilà c'est mieux

JmeDefonceAuLSD

Niveau 5

06 mars 2015 à 00:58:22

Tu connais les commentaires par hasard? parceque la c'est carrement imbuvable

Dark_Chouhartem

Niveau 11

06 mars 2015 à 09:16:07

Le 06 mars 2015 à 00:58:22 jmeDefonceAuLSD a écrit :
Tu connais les commentaires par hasard? parceque la c'est carrement imbuvable

C’est du python voyons, ça se passe de commentaires