Structure de données Utilisée pour le Serpent et Échelle de jeu

Règles pour Serpent et Échelle sont:

1. Il y a deux joueurs dans ce jeu et la taille du conseil est de 100.(10 X 10)
2. Résultats possibles en lançant un dé sont 1,2,3,4,5,6.
3. Si la sortie est 6 alors en vigueur, les joueurs auront une chance de nouveau pour lancer les Dés.
4. Si le résultat des Dés est 1,2,3,4,5,6 et le joueur placé sur la bouche de serpent puis de sa position actuelle va changer à la queue de serpent, et il n'aura pas d'autre chance jusqu'à ce qu'il jette un dé qui a de la valeur 6.
5. Si le résultat des Dés est 1,2,3,4,5,6 et le joueur placé au-dessous de l'échelle, puis de Sa position actuelle va changer à la première position de l'échelle, et il aura une autre chance de jeter les dés de nouveau.
6. Si le joueur de la position actuelle+ roll >100 puis prendre les considérations suivantes
   j'. si(rouleau==6), les joueurs auront la chance de nouveau ,sinon les autres joueurs auront.
7. Un joueur atteint les 100 plus tôt que les autres joueur sera le gagnant et le jeu prendra fin.

Nous sommes en train de seulement une table de hachage, qui contient la position actuelle comme la clé et suivant la position de la valeur. Je pense qu'une table de hachage permet d'accomplir toutes les exigence de l'Échelle et le Serpent,

int playSnakeAndLadder(HashMap<Integer, Integer> hashMap){
    int player1=1, player2=1;//Initial position of players
    int chance=0;//This value show the change of players if chance is odd then player1 will play
                 //if chance is even then player2 will play
    while(1){
        if((player1==100)||(player2==100))//if any of player's position is 100 return chance;
            return chance;//Here chance shows who win the game, if chance is even player1 wins other //wise player2 wins
    int roll=Randon(6);//this will generate random number from 1 to 6.
    if(chance%2==0){
         int key=roll+player1;//new position of player1             
         boolean isLadder=false;//This is for checking the turn current player if againTurn is ture 
         //then the current player will player again.
         if(hashMap.contains(Key)){
             player1=hashMap.getValue(Key);
             //Here player current position will automatically update according to the hashMap.
             //if there is a snake the key value is greater than it mapping value.
             //if there is a ladder then key value is less than it mapping value. 
             if(Key<hashMap.getValue(Key))
                 isLadder=true;//Here player gets ladder.
             if(isLadder==true && roll==6 || isLadder==true)
               chance=chance;
             else
               chance=(chance+1)%2;
         }
         else if(player1+roll>100 && roll!=6)
               chance=(chance+1)%2;
            else if(player1+roll>100 && roll==6)
               chance=chance;
            else if(roll==6){
               player1=player1+roll;
               chance=chance;
            }
            else{
               player1=player1+roll;
               chance1=(chance1+1)%2;
            }                 
       }


    else{//Now similarly for player2
              {
             int key=roll+player2;//new position of player2             
             boolean isLadder=false;//This is for checking the turn current player if againTurn is ture 
             //then the current player will player again.
             if(hashMap.contains(Key)){
                 player2=hashMap.getValue(Key);
                 //Here player current position will automatically update according to the hashMap.
                 //if there is snake the key value is greater than it mapping value.
                 //if there is ladder then key value is less than it mapping value. 
                 if(Key<hashMap.getValue(Key))
                     isLadder=true;//Here player gets ladder.
                 if(isLadder==true && roll==6 || isLadder==true)
                   chance=chance;
                 else
                   chance=(chance+1)%2;
             }
             else if(player2+roll>100 && roll!=6)
                   chance=(chance+1)%2;
                else if(player2+roll>100 && roll==6)
                   chance=chance;
                else if(roll==6){
                   player2=player2+roll;
                   chance=chance;
                }
                else{
                   player2=player2+roll;
                   chance=(chance+1)%2;
                }                 
        }
       }
     }
  }

Dans le la mise en œuvre à mon blog, j'ai utilisé une simple paire de listes liées à stocker les serpents et les échelles. Chaque élément de la liste a une paire de places, le "de place" et le "pour" carré; si vous avez atterri sur tout "" de place, votre pièce a été transféré à l' "à la place". J'ai trouvé un minimum de jeu longueur de 7 tours, et une moyenne de jeu de la longueur de 33 tours. Vous peut alternativement utiliser un tableau à une dimension, où l'indice de la matrice indique la place et la valeur de la matrice représente les "pour" carré, ce qui est la même que celle de l'indice, sauf au début d'un serpent ou d'une échelle.

Oui c'est possible: chaque tableau 2D peut être représenté comme un tableau 1D.

Représenter toutes les lignes du tableau 2D un après l'autre dans un tableau 1D. Ce faisant, 2d[i][j] devient 1d[i * rowLength + j]. Sauf si vous n'avez pas d'autre choix que d'utiliser un tableau 1d, il n'est généralement pas une bonne chose à faire car il devient de moins en moins lisible et moins facile à utiliser.

Certainement, nous pouvons résoudre le problème en utilisant 1D tableau parce que le nombre marqué sur le conseil d'administration sont de 1 à 100. Nous pouvons initialiser deux tableaux 1D: serpent et échelle à la fois de taille 100.
Si le joueur à la tête de serpent(supposons au 56), alors il faut passer à la queue(supposons au 6). Ensuite serpent[56] = 6 (selon la règle) le joueur va passer à bloc qui est marqué que 6. De même pour l'échelle de tableau. J'ai couvert le cas dans lequel le joueur est à la tête de serpent et de naviguer à sa queue et il s'est trouvé une échelle et vice versa.
Le pseudo-code est:

int snake[101], ladder[101];
void SnakeAndLadder()
{
    int player_1=1, player_2=1, turn_player_1 = 1, a;
    while(1)
    {
        a = rand()%6 +1;
        if(turn_i==1)
        {
            turn_player_1 = 0;
            player_1 = takeStep(player_1+a);
            if(player_1==100)
            {
                cout<<"Player 1 won";
                break;
            }
        }
        else
        {
            turn_player_1 = 1;
            player_2 = takeStep(player_2+a);
            if(player_2==100)
            {
                cout<<"Player 2 won";
                break;
            }
        }
    }
}

int takeStep(int i)
{
    if(i<100)
    {
    if(snake[i]!=0 && i!=100)
    {
        i = snake[i];
    }
    if(ladder[i]!=0 && i!=100)
    {
        i = ladder[i];
        if(snake[i]!=0 && i!=100)
        {
            i= snake[i];
        }
    }
    }
return i;
}