Tableau en escalier

Résolu
edwinzap
Messages postés
159
Date d'inscription
samedi 29 septembre 2012
Statut
Membre
Dernière intervention
21 juin 2016
- Modifié par edwinzap le 26/11/2014 à 01:23
Whismeril
Messages postés
17483
Date d'inscription
mardi 11 mars 2003
Statut
Modérateur
Dernière intervention
4 juillet 2022
- 27 nov. 2014 à 14:27
Bonjour,
J'ai réalisé un programme qui cherche les solutions à un problème donné.
Chaque solution est stockée dans un tableau de 8 lignes, 1 colonne.
Je voudrais bien sauvegarder les solutions dans un tableau de tableaux.
J'ai écris ceci qui est marqué comme autorisé dans la doc msdn:
            int[][] Solution = new int[][];

Mais j'ai d'office une erreur:
Erreur 2 Nombre d'index incorrect dans [] ; 1 attendu


Merci de m'aider svp !

Edit: ce n'est pas autorisé en fait mais je n'ai tjrs pas de solution

5 réponses

BunoCS
Messages postés
15266
Date d'inscription
lundi 11 juillet 2005
Statut
Modérateur
Dernière intervention
24 juin 2022
103
26 nov. 2014 à 09:17
Hello,

Il n'y aurait pas une virgule entre les accolades?
http://msdn.microsoft.com/fr-fr/library/2yd9wwz4.aspx
0
edwinzap
Messages postés
159
Date d'inscription
samedi 29 septembre 2012
Statut
Membre
Dernière intervention
21 juin 2016
2
26 nov. 2014 à 10:05
Je voudrais faire un tableau de tableaux et non un tableau à plusieurs colonnes...
0
edwinzap
Messages postés
159
Date d'inscription
samedi 29 septembre 2012
Statut
Membre
Dernière intervention
21 juin 2016
2
26 nov. 2014 à 10:32
J'utilise finalement une list<int[]> pour y mettre tout mes tableaux mais je n'arrive pas à récupérer le contenu d'un tableau de la liste
0
NHenry
Messages postés
14943
Date d'inscription
vendredi 14 mars 2003
Statut
Modérateur
Dernière intervention
3 juillet 2022
161
26 nov. 2014 à 12:37
En C#, il y a la possibilité de déclarer avec "var" :
var MaList=new List<int[]>
var MonTab=MaList.ToArray();

Sinon, si tu déclare un tableau multidimensionnel, pas besoin des bornes, mais pour un "new" il te faut opbligatoirement les bornes
0
edwinzap
Messages postés
159
Date d'inscription
samedi 29 septembre 2012
Statut
Membre
Dernière intervention
21 juin 2016
2
Modifié par Whismeril le 27/11/2014 à 14:14
Je n'y arrive tjrs pas ! J'utilise une liste de tableau mais ça ne fonctionne pas correctement.
Je stocke correctement des séries de nombres comme ceci: 13567402, 03726145,... je l'ai vérifié, ça fonctionne ! mais si je veux récupérer les données à la fin du programme il ne m'affiche que des 7 !!!

Voici mon code:
namespace ConsoleApplication_Echec
{
    class Program
    {
        static void Main(string[] args)
        {
            //Stopwatch permet de calculer des intervalles de temps, utilisé ici pour calculer le temps mis par l'ordinateur pour touver toutes les solutions
            Stopwatch sw = new Stopwatch();
            sw.Start();

            // Tableau de 8 lignes, 1 colonnes
            int[] Table = new int[8];
            List<int[]> Solution = new List<int[]>();

            // Pour réussir à trouver les différentes possibilités, j'utilise le système suivant:
            // Les lignes du tableau réprésentent une colonne du plateau d'échec. Le nombre indiqué représente la ligne
            // Ainsi, pour teste toutes les possibilités, je dois tester toutes les séries de chiffres de 00000000 à 88888888

            //Les boucles ci-dessous incrémentent les valeurs de chaque ligne
            for (int a = 0; a < 8; a++) // boucle n°0, incrémente la ligne '0'
            {
                Table[0] = a;
                for (int b = 0; b < 8; b++) // boucle n°1, incrémente la ligne '1'
                {
                    Table[1] = b;
                    for (int c = 0; c < 8; c++) // boucle n°2, incrémente la ligne '2'
                    {
                        Table[2] = c;
                        for (int d = 0; d < 8; d++) // boucle n°3, incrémente la ligne '3'
                        {
                            Table[3] = d;
                            for (int e = 0; e < 8; e++) // boucle n°4, incrémente la ligne '4'
                            {
                                Table[4] = e;
                                for (int f = 0; f < 8; f++) // boucle n°5, incrémente la ligne '5'
                                {
                                    Table[5] = f;
                                    for (int g = 0; g < 8; g++) // boucle n°6, incrémente la ligne '6'
                                    {
                                        Table[6] = g;                                        
                                        for (int h = 0; h < 8; h++) // boucle n°7, incrémente la ligne '7'
                                        {
                                            Table[7] = h;

                                            // une des condition est qu'il n'y ai pas 2 reines sur la même ligne
                                            // la boucle suivante vérifie s'il y a des chiffres identiques

                                            int m = 0;                                            
                                            bool condition1 = true;                                        
                                            while (m < 8 & condition1 == true)// tant que 'm' est plus petit que 8 et que condition1 (aucun chiffres identique) est vraie, exécuter le bloc                                                
                                            {
                                                int n = m + 1;    
                                                while (n < 8 & condition1 == true) // tant que 'n' est plus petit que 8 et que condition1 (aucun chiffres identique) est vraie, exécuter le bloc
                                                {
                                                    if (Table[m] == Table[n]) // Vérifie si le chiffre se trouvant à la ligne 'm' du tableau est égale à celui ce trouvant à la ligne 'n'
                                                    {
                                                        condition1 = false; // si vrai, alors condition1 est fausse
                                                    }                                                   
                                                    n++;
                                                }
                                                m++;                                        
                                            }
                                            if (condition1 == true) // si la condition1 est vraie, tester la condition2
                                            {
                                                //Console.WriteLine("{0} | {1} | {2} | {3} | {4} | {5} | {6} | {7}" + condition1, Table[0], Table[1], Table[2], Table[3], Table[4], Table[5], Table[6], Table[7]);
                                                //Console.ReadLine();

                                                // la boucle suivante vérifie les diagonales
                                                // Pour cela il faut calculer l'écart entre le premier chiffre et le deuxième et ajouter cet écart au chiffre
                                                // Si le premier chiffre avec ajout (et retrait) de l'écart égale le deuxième chiffre, alors les 2 reines sont sur une même diagonale
                                                // Ajouter l'écart vérifie la diagonale vers le bas
                                                // Soustraire l'écart vérifie la diagonale vers le haut
                                                int o = 0;
                                                bool condition2 = true;
                                                while (o < 8 & condition2 == true)
                                                {
                                                    int p = o + 1;
                                                    while (p < 8 & condition2 == true)
                                                    {
                                                        if ((Table[o] + Math.Abs(o - p)) == Table[p] | (Table[o] - Math.Abs(o - p)) == Table[p])
                                                            condition2 = false;
                                                        p++;
                                                    }
                                                    o++;
                                                }
                                                if (condition2 == true) // Si condition2 est également vraie alors le résultat est une solution possible !
                                                {
                                                    Solution.Add(Table);
                                                }                                              
                                            }
                                        }
                                    } 
                                }
                            }
                        }
                    }
                }
            }
            


            sw.Stop();
            TimeSpan ts = sw.Elapsed; // ts est une mesure de temps et contient le temps nécessaire pour calculer les solutions.
            Console.WriteLine("Temps d'exécution: " + ts);
            Console.ReadLine();
            Console.WriteLine("Nombre de solution: " + Solution.Count());
            Console.ReadLine();

            // N'affiche que des 7 !!!
                   
            for (int z = 0; z < Solution.Count(); z++)
            {
                int[] Tableau = Solution[z];
                Console.WriteLine("Table: {0} | {1} | {2} | {3} | {4} | {5} | {6} | {7} /" + z, Tableau[0], Tableau[1], Tableau[2], Tableau[3], Tableau[4], Tableau[5], Tableau[6], Tableau[7]);
            }
            Console.ReadLine();
        }
    }
} 
0
NHenry
Messages postés
14943
Date d'inscription
vendredi 14 mars 2003
Statut
Modérateur
Dernière intervention
3 juillet 2022
161
26 nov. 2014 à 18:32
Je pense que le tableau est ajouté par référence, donc tu ajoutes à chaque fois le même tableau.
Essayes de remplacer :
Solution.Add(Table);
par :
Solution.Add(Table.ToArray());
ou un équivalent.
0
edwinzap
Messages postés
159
Date d'inscription
samedi 29 septembre 2012
Statut
Membre
Dernière intervention
21 juin 2016
2
26 nov. 2014 à 19:06
Pour récapituler, j'ai à chaque fois un tableau de 8 lignes contenant les valeurs. Je souhaiterais sauvegarder ses données pour pouvoir les réutiliser par la suite. Que dois-je utiliser finalement? Sachant que si je choisi un élément, je souhaiterais pouvoir récupérer les 8 valeurs.
0
NHenry
Messages postés
14943
Date d'inscription
vendredi 14 mars 2003
Statut
Modérateur
Dernière intervention
3 juillet 2022
161
26 nov. 2014 à 19:32
As-tu essayé ma suggestion ?
0
edwinzap
Messages postés
159
Date d'inscription
samedi 29 septembre 2012
Statut
Membre
Dernière intervention
21 juin 2016
2
26 nov. 2014 à 19:41
Oui mais je ne sais pas comment aller chercher les valeurs au bon endroit ! J'ai cherché mais je n'ai pas trouvé car je ne sais pas comment le .toarray ajoute à la liste
0
Whismeril
Messages postés
17483
Date d'inscription
mardi 11 mars 2003
Statut
Modérateur
Dernière intervention
4 juillet 2022
600
26 nov. 2014 à 20:46
Bonsoir, pour répondre à ta premiere question, pour initier un tableau il faut lui dire le nombre d'enregistrements, ce point est acquis puisque tu le fais quelque par dans ton code. Et bien un tableau de tableaux c'est pareil...
int[][] = new int[8][8];

Cependant la liste c'est bien mieux

Je ne peux pas tester ton code ce soir, mais je peux déjà simplifier un point, si tu veux faire une string à partir des éléments d'un tableau, il faut utiliser la méthode String.Join.

Je pense comme NHenry que Table étant passée par référence, et bien chaque il n'y en a en fait qu'une qui représente le dernier résultat trouvé. Pour éviter ça il faut faire un new list... à chaque nouvelle recherche.


Maintenant de façon plus générale, C# est un langage "tout" objet et si tu veux faire un jeu d'échec la base serait d'utiliser autant d'objets que de type de pièce, ceux ci se caractériseraient par leur position, déplacement et prise(au moins pour les pions puisque pas dans le sens du déplacement).
Et là dans ton code pas d'objet....
0
edwinzap
Messages postés
159
Date d'inscription
samedi 29 septembre 2012
Statut
Membre
Dernière intervention
21 juin 2016
2
26 nov. 2014 à 21:53
Merci à tous,
Vous m'avez mis sur quelques pistes et c'est là l'essentiel !

J'utilise finalement une liste de tableaux:
            List<int[]> Solution = new List<int[]>();


Et j'ajoute les tableaux:
{  int[] nouvelle = new int[8];
    nouvelle = (int[]) Table.Clone();
    Solution.Add(nouvelle);
     }
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Whismeril
Messages postés
17483
Date d'inscription
mardi 11 mars 2003
Statut
Modérateur
Dernière intervention
4 juillet 2022
600
27 nov. 2014 à 14:27
Bonjour, j'ai eu un peu de temps voici ma proposition (attention je n'ai pas chercher à optimiser tes boucles!), mes commentaires commencent par "Whismeril:"

            //Stopwatch permet de calculer des intervalles de temps, utilisé ici pour calculer le temps mis par l'ordinateur pour touver toutes les solutions
            Stopwatch sw = new Stopwatch();
            sw.Start();

            // Tableau de 8 lignes, 1 colonnes
            //int[] Table = new int[8]; Whismeril: une seule référence d'ou ton problème précédent
            List<int[]> Solution = new List<int[]>();

            // Pour réussir à trouver les différentes possibilités, j'utilise le système suivant:
            // Les lignes du tableau réprésentent une colonne du plateau d'échec. Le nombre indiqué représente la ligne
            // Ainsi, pour teste toutes les possibilités, je dois tester toutes les séries de chiffres de 00000000 à 88888888

            //Les boucles ci-dessous incrémentent les valeurs de chaque ligne
            for (int a = 0; a < 8; a++) // boucle n°0, incrémente la ligne '0'
            {
                int[] Table = new int[8];//Whismeril : ici c'est mieux
                Table[0] = a;
                for (int b = 0; b < 8; b++) // boucle n°1, incrémente la ligne '1'
                {
                    Table[1] = b;
                    for (int c = 0; c < 8; c++) // boucle n°2, incrémente la ligne '2'
                    {
                        Table[2] = c;
                        for (int d = 0; d < 8; d++) // boucle n°3, incrémente la ligne '3'
                        {
                            Table[3] = d;
                            for (int e = 0; e < 8; e++) // boucle n°4, incrémente la ligne '4'
                            {
                                Table[4] = e;
                                for (int f = 0; f < 8; f++) // boucle n°5, incrémente la ligne '5'
                                {
                                    Table[5] = f;
                                    for (int g = 0; g < 8; g++) // boucle n°6, incrémente la ligne '6'
                                    {
                                        Table[6] = g;
                                        for (int h = 0; h < 8; h++) // boucle n°7, incrémente la ligne '7'
                                        {
                                            Table[7] = h;

                                            // une des condition est qu'il n'y ai pas 2 reines sur la même ligne
                                            // la boucle suivante vérifie s'il y a des chiffres identiques

                                            int m = 0;
                                            bool condition1 = true;
                                            while (m < 8 & condition1 == true)// tant que 'm' est plus petit que 8 et que condition1 (aucun chiffres identique) est vraie, exécuter le bloc                                                
                                            {
                                                int n = m + 1;
                                                while (n < 8 & condition1 == true) // tant que 'n' est plus petit que 8 et que condition1 (aucun chiffres identique) est vraie, exécuter le bloc
                                                {
                                                    if (Table[m] == Table[n]) // Vérifie si le chiffre se trouvant à la ligne 'm' du tableau est égale à celui ce trouvant à la ligne 'n'
                                                    {
                                                        condition1 = false; // si vrai, alors condition1 est fausse
                                                    }
                                                    n++;
                                                }
                                                m++;
                                            }
                                            if (condition1 == true) // si la condition1 est vraie, tester la condition2
                                            {
                                                //Console.WriteLine("{0} | {1} | {2} | {3} | {4} | {5} | {6} | {7}" + condition1, Table[0], Table[1], Table[2], Table[3], Table[4], Table[5], Table[6], Table[7]);
                                                //Console.ReadLine();

                                                // la boucle suivante vérifie les diagonales
                                                // Pour cela il faut calculer l'écart entre le premier chiffre et le deuxième et ajouter cet écart au chiffre
                                                // Si le premier chiffre avec ajout (et retrait) de l'écart égale le deuxième chiffre, alors les 2 reines sont sur une même diagonale
                                                // Ajouter l'écart vérifie la diagonale vers le bas
                                                // Soustraire l'écart vérifie la diagonale vers le haut
                                                int o = 0;
                                                bool condition2 = true;
                                                while (o < 8 & condition2 == true)
                                                {
                                                    int p = o + 1;
                                                    while (p < 8 & condition2 == true)
                                                    {
                                                        if ((Table[o] + Math.Abs(o - p)) == Table[p] | (Table[o] - Math.Abs(o - p)) == Table[p])
                                                            condition2 = false;
                                                        p++;
                                                    }
                                                    o++;
                                                }
                                                if (condition2 == true) // Si condition2 est également vraie alors le résultat est une solution possible !
                                                {
                                                    //Solution.Add((int [])Table.Clone()); Whismeril: à éviter, un tableau de 8 entiers ça n'est pas compliqué mais si tu fait ça avec un objet plus complexe tu va perdre du temps d'exécution à creer une copie et la caster.
                                                    Solution.Add(Table);
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }



            sw.Stop();
            TimeSpan ts = sw.Elapsed; // ts est une mesure de temps et contient le temps nécessaire pour calculer les solutions.
            Console.WriteLine("Temps d'exécution: " + ts);
            Console.ReadLine();
            Console.WriteLine("Nombre de solution: " + Solution.Count());
            Console.ReadLine();


            for (int z = 0; z < Solution.Count(); z++)
            {
                int[] Tableau = Solution[z];
                //Console.WriteLine("Table: {0} | {1} | {2} | {3} | {4} | {5} | {6} | {7} /" + z, Tableau[0], Tableau[1], Tableau[2], Tableau[3], Tableau[4], Tableau[5], Tableau[6], Tableau[7]); Whismeril: voir en dessous
                Console.WriteLine(string.Format("Table: {0} | {1} /",z, string.Join(" |", Tableau)));//Whismeril: c'est plus propre
            }
            Console.ReadLine();

0