Discussion :

[PoelQ]

Bonjour tout le monde,

Je réalise un jeu, et une partie de mon programme a besoin d'une fonction qui déplace les termes d'une liste vers une autre liste avec un indice différent. Je m'explique, en fait je fais ou en tout cas j'essaye de réaliser un 2048 (http://gabrielecirulli.github.io/2048/), j'ai modéliser les cases par les termes d'un tableau a deux dimensions. J'essaye de faire l'algorithme qui déplace les nombres vers la droite. Voici mon code :

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
 
def DeplacementDroite():
 
    Tableau=[[2,2,2,2],[0,0,0,0],[0,0,0,0],[0,8,0,0]]
 
    x=3
 
    NouveauTableau=[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
 
    for i in range (0,3):
 
        for n in range (0,3):
 
            if Tableau[x][n]!=0:
                if x>0:
                    x-=1
 
            elif Tableau[x][n]==0:
                if x<3 and i==0:
                    x+=1
 
            NouveauTableau[x][n]=Tableau[i][n]
 
    return(NouveauTableau)
 
print(DeplacementDroite())

J'obtiens le résultat :
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0]]
au lieu de :
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 2, 0, 0], [2, 8, 2, 2]]

Je n'arrive pas a faire fonctionner correctement la condition. Est-ce que quelqu'un peut m'aider ? Merci d'avance.

[plaxtor]

Quand on corrige un code il est important de dire ce qui ne va pas. Je prends pas vraiment le temps de comprendre ton code car ta méthode me paraît bien compliqué. Si je devais mettre une pièce ce serait sur le fait qu'une case peut faire plusieurs déplacements, et ça foire dans tes indices. Mettre tous les nombres à droite c'est mettre tous les vides à gauche.
Et dans un tableau on a pour habitude de représenter [[ligne1],[ligne2][ligne3]] je ne suis pas sûr que ce soit ce que tu as fait. Je ferais :

Code :

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

1
2
3
4
5
6
7
8
 
def DeplacementDroite(tableau):
    for i in range(4): # i = la ligne, j = la colonne, tout le monde se comprend !
        for j in range(4):
            if not tableau[i][j]:
                del tableau[i][j]
                tableau[i].insert(0,0)
    return tableau

[plxpy]

Bonjour

As-tu remarqué que ton problème pouvait se réduire à 1 seule dimension et 1 seul sens ?

Je prends le(s) sens normal d'écriture et mes lignes vont de gauche à droite, mes colonnes de haut en bas.

1 dimension

• aller à gauche (dans une ligne), c'est le même principe que aller en haut (dans une colonne)
• aller à droite (dans une ligne), c'est le même principe que aller en bas (dans une colonne)

lignes / colonnes ? même combat algo !

1 sens

• aller à droite, c'est aller à gauche en travaillant sur la ligne retournée et en retournant le résultat
• aller en bas, c'est aller en haut en travaillant sur la colonne retournée et en retournant le résultat.

gauche/droite et haut/bas ? même algo (qu'on complète par des retournements) !

Bref, c'est un seul algo (simple) + une gestion des sens et des directions (avec des trucs python style reversed et un passage dans les deux sens damier complet <=> lignes et/ou damier complet <=> colonnes). Perso, je mettrais même mon damier sous la forme d'une seule liste de 16 valeurs.

Le plus simple (à mon sens), c'est de pousser les éléments d'une séquence vers le début (vers l'indice 0) de la séquence ("aller à gauche dans une ligne") et d'avoir un "truc" (une fonction) qui fait ça :

[ 0, 0, 2, 2 ] donne [ 4, 0, 0, 0 ]
[ 0, 2, 0, 2 ] donne [ 2, 2, 0, 0 ] plutôt [ 4, 0, 0, 0 ] : les rêgles précises ne sont pas fournies ... sauf si on achète le jeu. Faut deviner/intuiter en y jouant
[ 2, 2, 8, 4 ] donne [ 4, 8, 4, 0 ]
[ 2, 2, 4, 4 ] donne [ 4, 8, 0, 0 ]

Ensuite, c'est de l'assemblage. N'oublie pas, non plus, après chaque déplacement effectué, d'ajouter une nouvelle valeur 2 dans une case libre du damier.

[PoelQ]

Bonjour plxpy, est-ce que tu pourrai illustrer ton exemple avec un morceau de code ? Car j'ai du mal à comprendre comment tu fais la différence entre les lignes et les colonnes, et je ne comprend pas non plus comment tu réalises les déplacements. Merci d'avance.

[plxpy]

Les termes "lignes" et "colonnes" sont à prendre dans leur acceptation la plus courante : une ligne, c'est horizontal, une colonne, vertical !

Une matrice (un damier "2048") :

Code :

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

1
2
3
4
    2  0  0  0
    0  8  0  4
    2  4  0  4
    0  0  0  0

damier décrit comme une liste de lignes :

Code :

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

1
2
   <- lig0 ->    <- lig1 ->    <- lig2 ->    <- lig3 ->
[ [2, 0, 0, 0], [0, 8, 0, 4], [2, 4, 0, 4], [0, 0, 0, 0] ]

chaque ligne étant, elle-même, une liste de 4 valeurs

ou, comme tu avais choisi de le faire, :

damier décrit comme une liste de colonnes :

Code :

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

1
2
   <- col0 ->    <- col1 ->    <- col2 ->    <- col3 ->
[ [2, 0, 2, 0], [0, 8, 4, 0], [0, 0, 0, 0], [0, 4, 4, 0] ]

chaque colonne étant, elle-même, une liste de 4 valeurs


Après, pour les déplacements, dans une séquence, il "suffit" de décomposer ce qu'il faut faire, étape par étape.
Ici, un déplacement à gauche dans une séquence :

état initial : 0 2 4 4

on pousse à gauche, en oubliant/écrasant les cases vides (avec 0)
2 4 4 <place laissée vide>

traitement, 2 par 2, des valeurs : égales ? on les somme ! différentes ? on n'y touche pas
On rajoute, dans ta logique, un 0 pour signifier que la dernière case est vide.

2 4 4 0


Après, si je développe plus, je fais l'exercice à ta place !
Mais, si tu galères déjà avec les indices de liste, mes ... indices ne vont pas forcément t'aider.

Si l'inspiration me vient, je reposterai

[plaxtor]

J'ai eu cours d'algo cet aprem du coup ce petit jeu sympa m'est resté dans la tête, j'ai donc codé un truc qui assure la fonction principale, c'est à dire faire les déplacements. Comme l'a intelligemment fait remarqué plxpy, se déplacer dans n'importe quelle direction c'est le même problème à rotation de ton damier près.
Dans un premier temps je considère mon damier de 4x4 de la manière la plus courante :

Code :

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

1
2
   <- lig0 ->    <- lig1 ->    <- lig2 ->    <- lig3 ->
[ [2, 0, 0, 0], [0, 8, 0, 4], [2, 4, 0, 4], [0, 0, 0, 0] ]

Je me dis que j'ai envie de ramener les déplacements vers le haut/le bas/la gauche à un déplacement vers la droite. Il suffit de remarquer que :
- se deplacer vers la gauche, c'est retourner notre matrice (on échange colonne 0,1,2,3 --> colonne 3,2,1,0) ET se déplacer vers la droite,
- se déplacer vers le bas, c'est transposer notre matrice ET se déplacer vers la droite,
- se déplacer vers le bas, c'est la retourner dans les deux directions (colonne 0,1,2,3 --> ligne 3,2,1,0 ; ligne 0,1,2,3 --> colonne 3,2,1,0) ET se déplacer vers la droite.
Ces transformations sont involutives donc si je les rappliques ça me redonne la matrice initiale -----> Pratique !

Ensuite me dis elles me font ch*** ces cases vides, donc dans un premier temps je les fous toutes à gauche
Ensuite vient la fusion. La c'est plus délicats, faut pas que ça foire sur les cas sensibles suivants :
[2,2,2,2] --> [0,0,4,4]
[2,0,0,2] --> [0,0,0,4]
[0,2,2,4] --> [0,0,4,4]
[0,2,2,2] --> [0,0,2,4]

Et à la fin tu rapplique la transormée de l'étape 1 pour avoir un tableau tout beau tout neuf
Si tu galères pour le code je veux bien le mettre, mais je te mache déjà bien le travail là