Je viens de terminer un programme qui permet, selon le chiffre (de 1 - 13) que l'utilisateur rentre, de donner ou de dessiner (le mot étant mieux ici) un losange avec des nombres.
Mon programme est ci dessous. Ma question est donc de savoir si il n'y aurait pas une méthode plus simple de le faire. par exemple avec des boucles imbriqués for for ou do while.
public static void FabricationLosangeNombres () {
int choix = Choix ();
if (choix == 1) NumUn ();
if (choix == 2) NumDeux ();
if (choix == 3) NumTrois ();
if (choix == 4) NumQuatre ();
if (choix == 5) NumCinq ();
if (choix == 6) NumSix ();
if (choix == 7) NumSept ();
if (choix == 8) NumHuit ();
if (choix == 9) NumNeuf ();
if (choix == 10) NumDix ();
if (choix == 11) NumOnze ();
if (choix == 12) NumDouze ();
if (choix == 13) NumTreize ();
}// Fin méthode FabricationLosangeNombres ()
Ceci est un exemple des methodes que j'ai fait. Il y en a normalement 13, mais je mets juste les 4 premières a titre d'exemple de ce que je veux faire (mais avec des boucles imbriqués).
Salut, alors le problème est relativement simple...
Pourquoi relativement simple ?
Parce que si tu regardes bien ton losange, tu as juste besoin que d'un quart du losange car le reste peut se construire par symétrie horizontale et verticale donc si un losange de 5 te donnes :
Il te faut d'abord une méthode qui te construit un losange et qui prend en paramètre le nombre de "cotés" du losange :
static private string BuildLosange(int number)
Ensuite nous avons donc notre nombre de "cotés" du losange, il nous faut connaitre la longueur du losange : cela équivant à 2 fois le nombre passé en paramètre - 1.
Puis nous avons besoin d'un stringbuilder pour nos recréer le beau losange :
StringBuilder builder = new StringBuilder();
int i = 2 * number - 1;
Nous savons que le losange est symétrique donc nous allons créer des variables pour ne calculer qu'un quart du losange :
int numCol = (i / 2) + 1;
int numLignes = (i / 2) + 1;
Maintenant un jagged array nous sera utile pour conserver nos valeurs. Ce type de tableau auront exactement le même nombres de cases que i.
Ensuite pour avoir les valeurs correcte au bon endroit une variable temporaire contiendra notre chiffre de départ.
string[][] losange = new string[i][];
int start = number;
Maintenant on instantie le reste du tableau :
for (int j = 0; j < i; ++j)
losange[j] = new string[i];
Maintenant deux choix s'offrent à nous :
soit on a mis 1 en paramètre de méthode, soit un autre chiffre. Si on a mis 1, alors il nous suffit de remplir la première case du tableau à 1 :
if (i == 1)
losange[0][0] = "1";
else
{
Sinon ben le remplissage est assez simple;
il suffit de partir de 0 jusqu'à numLignes.
Dans cette boucle on initialise notre valeur de départ à number. Puis nous comptons le nombre de "-" à insérer dans le tableau avant le chiffre. Puis avec une boucle imbriquée à l'interieure de la précédente, nous mettons à jour notre tableau avec des "-" puis à partir du nombre de "-" jusqu'au nombre de colonnes, nous mettons à jour le chiffre à insérer en décrémentant le nombre de départ.
Le gros pavé du dessus se réduit à ces lignes de code :
for (int y = 0; y < numLignes; ++y)
{
start = number;
int numMinus = numLignes - y - 1;
for (int x = 0; x < numMinus; ++x)
losange[y][x] = "-";
for (int x = numMinus; x < numCol; ++x)
losange[y][x] = (start--).ToString();
}
Ensuite il ne nous reste qu'à appliquer la symétrique horizontale. L'idée est si on a un losange à 5 cases, alors la case 4 vaut la case 2 et la case 5 vaut la case 1.
Cela se traduit par ce code :
// Symétrie horizontale
for (int y = 0; y < numLignes; ++y)
{
for (int x = numCol; x < i; ++x)
{
losange[y][x] = losange[y][i - 1 - x];
}
}
la symétrie verticale repose sur le même principe :
// Symétrie verticale
for (int y = numLignes; y < i; ++y)
{
for (int x = 0; x < i; ++x)
{
losange[y][x] = losange[i - 1 - y][x];
}
}
}
Maintenant la dernière étape est de créer le string de rendu :
for (int y = 0; y < i; ++y)
{
for (int x = 0; x < i; ++x)
{
builder.Append(losange[y][x]);
}
builder.AppendLine();
}
return builder.ToString();
}
}
Il existe certainement des manières plus efficace de gérer la chose mais elle a le mérite de bien fonctionner...
Oh my god. Mais t'es un god dit donc. Ta méthode marche a merveille et comme tu l'as toi même dit, a partir de 10, le losange pose un petit problème. Je pense que ça doit être du a l'incrémentation entre chaque valeur du losange. Peux être que si j'essaye de mettre un espace entre chaque ligne et chaque colonne ça marcheras. Qu'est ce que t'en penses?
Rien de mieux que la joie ressentit lors d'une simple et bonne programmation!!
Je suppose que non ça ne changeras rien...
à l'écran un 1 prend moins de place qu'un 5 donc tu auras toujours un décrochage.
Pour résoudre ce problème, lorsque tu auras plus de connaissances en C# sera de passé par un Winform
Ok c'est cool, de toute les manières, ta première réponse était celle qu'il me fallait. Je vais m'attarder maintenant sur d'autres projet c# afin d'acquérir l'expérience nécessaire pour comprendre un Winform
Rien de mieux que la joie ressentit lors d'une simple et bonne programmation!!
