Discussion :

[Intsugari]

Bonjour,

Dans le cadre d'un jeu que je dois programmer, j'ai besoin de faire un sous-programme ( en ADA ) qui va vérifier si la partie est terminée ou non.
Pour que le jeu soit fini, il faut que une ligne entière ou colonne soit complétée d'un même pion ( mes pions sont des '#' et des 'o' ).
Seul problème : je n'arrive pas à trouver un moyen de vérifier toutes les lignes et toutes les colonnes d'un tableau à 2 dimensions.
Si quelqu'un a une idée, ça serait gentil !

Merci

[tbc92]

Tu es étudiant... en informatique je suppose.
Tu as dû apprendre la notion de boucle, non ?
Peut être même que tu as déjà fait des exercices avec 2 boucles imbriquées ?

Si on ne t'a jamais parlé des boucles , alors tu ne peux pas t'en sortir. Mais si on t'a déjà expliqué cette notion, et si tu as déjà fait des exercices avec des boucles imbriquées, alors c'est un exercice très facile.

[localghost]

Bonjour.
C'est pas deux boucle imbriquer qu'il faut ici, mais deux fois une boucle.
Une pour les ligne et une pour les colone.

Pour accéder à un élément dans un tableau à deux dimmensions c'est Tableau(indice1, indice2).

Pour faire une boucle dans l'indice1 du tabeleau c'est for indice in Tableau'range(1) loop
Pour faire une boucle dans l'indice2 du tabeleau c'est for indice in Tableau'range(2) loop

A toi de savoir comment est orientés la matrice pour savoir où sont les lignes et les colonnes.

[Intsugari]

Bonjour,

Oui j'avais déjà l'idée de faire 2x2 boucles imbriquées pour vérifier premièrement les colonnes et deuxièmement les lignes. Malheureusement je n'ai aucune idée du code que je dois insérer à l'intérieur d'où mon post.

J'ai eu des idées pour vérifier que la valeur suivante était égale à cette valeur, elle même égale à mon pion ('#' ou 'o') mais ça ne semble pas marcher.
Si quelqu'un a un début de code (algorithme) pouvant me faire comprendre le principe, ça serait cool !

[Prof]

Bonjour.

Supposons que la matrice soit notée A, possède n lignes et p colonnes, et que l'on accède à un de ses éléments sous la forme A(i,j) avec i = numéro de ligne et j = numéro de colonne.

Notons "fini" une variable booléenne.
Notons "a" une variable de type caractère ; elle va recevoir '#' ou 'o'.

L'algorithme pourrait se présenter ainsi :

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
 
pour i de 1 à n faire              # étudier toutes les lignes
    fini <- vrai                           
    a <- A(i,1)                    # premier élément de la ligne i
    pour j de 2 à p faire          # étudier les autres éléments de la ligne i
        si A(i,j) <> a alors 
            fini <- faux           # il y a deux éléments différents dans la ligne i
            break                  # inutile d'étudier les autres éléments de la ligne
        fin_si
    fin_pour                       # fin de l'étude de la ligne i
    si fini alors break            # si la ligne i est bonne, inutile d'étudier les autres lignes
    fin_si
fin_pour                           # fin d'étude des lignes
 
si fini alors retourner(vrai)      # si une ligne est bonne, inutile d'étudier les colonnes
fin_si
 
pour j de 1 à p faire              # étudier toutes les colonnes
    fini <- vrai                           
    a <- A(1,j)                    # premier élément de la colonne j
    pour i de 2 à n faire          # étudier les autres éléments de la colonne j
        si A(i,j) <> a alors 
            fini <- faux           # il y a deux éléments différents dans la colonne j
            break                  # inutile d'étudier les autres éléments de la colonne
        fin_si
    fin_pour                       # fin de l'étude de la colonne j
    si fini alors break            # si la colonne j est bonne, inutile d'étudier les autres colonnes
    fin_si
fin_pour                           # fin d'étude des colonnes
 
retourner(fini)

J'ai noté "break" l'instruction qui permet de sortir d'une boucle avant la fin.
Elle est notée "exit" en ADA.

Notez que, si la fonction retourne vrai, le contenu de la variable a permet de savoir qui a gagné.
Il est alors possible de modifier la fonction afin qu'elle retourne a quand la partie est finie ou le caractère nul dans le cas contraire.

[Intsugari]

Merci beaucoup !

J'y étais presque, mais je n'avais pas vu qu'on pouvait stocker la valeur de M(I,J) dans une variable pour pouvoir la comparer avec toutes les valeurs de la ligne ou de la colonne...
Merci !!