/***********************************************************************************************
* Générateur de no 6/49 avec validation
***********************************************************************************************
* Par:David Bérubé
* Date 12 juin 2006
* Réviser le: 9 juillet 2006
* *********************************************************************************************/
using System;
namespace TravailPratique2
{
class Class1
{
static void Main()
{
try
{
do
{
Random rnd = new Random(unchecked((int)DateTime.Now.Ticks)); //initialise un compteur selon le temps
int[,] tab_nombres = new int[10,6]; // Tableau des combinaisons tirer , 10ligne par 6 colonne
int[,] tab_gains = new int[10,6]; // Tableau comparaison de tab_nombres
int[] tab_combine_gagnante = new int[6]; // Tableau pour la combinaison gagnante de 6 chiffres
int[] tab_extra= new int[11];//Tableau pour les 10combinaisons gagnante , 11 etant celle gagnante
int[] tab_gains_extra = new int[11]; //Tableau de comparaison de tab_extra
int[] tab_doublons = new int[50]; //Tableau avec tout les nbr utilisés, pour verif. de doublons
int nbr_tirage=0; //Nombre de tirage a faire.
saisir_nbr_tirage(ref nbr_tirage);//Fontion pour determiner le nombre de tirages
initialiser_table(tab_nombres,nbr_tirage,tab_doublons,ref rnd);//Initialise un tableau multi-dimensionel
initialiser_table(tab_extra,nbr_tirage,tab_doublons,ref rnd);//Initialise un tableau a une dimension
trier_tableau(tab_nombres); //Trie d'un tableau multi-dimensionel en ordre croissant
generer_combine_gagnante(tab_combine_gagnante,tab_doublons,ref rnd); //Genere la combinaison gagnante
generer_Tab_gains(tab_combine_gagnante,tab_gains,tab_nombres); // Compare deux tableau multi-dimensionel
generer_Tab_gains(tab_gains_extra,tab_extra); // Compare un tableau a une dimension
afficher_table(tab_nombres,tab_gains,tab_extra,tab_gains_extra,nbr_tirage,tab_combine_gagnante); //Affichage des resultats et tableau
}while(recommencer() == 'O');
}
catch(Exception){Console.WriteLine("Erreur inatendue");Console.ReadLine();Main();}
}
public static void initialiser_table(int[,] tab_nombres,int nbr_tirage,int[] tab_doublons,ref Random rnd)
{
//initialise un tableau aleatoire a plusieurs dimensions.
int colonne,ligne,nbr_rnd;
colonne=ligne=0;
for(colonne = 0;colonne < nbr_tirage ;colonne++)
{
for(ligne = 0;ligne < tab_nombres.GetLength(1);ligne++)
{
nbr_rnd=rnd.Next(49)+1;
tab_nombres[colonne,ligne]=nbr_rnd; //Assigne le nombre aléatoire
if(verifier_doublons(tab_doublons,nbr_rnd)==true)
{
ligne--;//retourne a la ligne précédente
continue;//recommence la boucle
}
}
Effacer_Tabdoublons(tab_doublons);
}
}
public static void initialiser_table(int[] tab_extra,int nbr_tirage,int[] tab_doublons,ref Random rnd)
{
//initialise un tableau aleatoire a une dimension
int ligne,nbr_rnd;
ligne=0;
for(ligne = 0;ligne < tab_extra.Length;ligne++)
{
nbr_rnd=rnd.Next(49)+1;
tab_extra[ligne]=nbr_rnd;//Assigne le nombre aléatoire
if(ligne == 10) //la combinaison gagnante ne doit pas passer doublon
break;
if(verifier_doublons(tab_doublons,nbr_rnd)==true) // si c'est un doublon
{
ligne--; //retourne a la ligne précédente
continue; //recommence la boucle
}
}
Effacer_Tabdoublons(tab_doublons);
}
public static void trier_tableau(int[,] tab_nombres)
{
//Trie le tableau en ordre croissant , apelle copier_ligne & trier_ligne
int[] tab_CloneLigne = new int[tab_nombres.GetLength(1)];
int ligne,colonne;
ligne=colonne=0;
for(colonne = 0;colonne < tab_nombres.GetLength(0);colonne++)
{
copier_ligne(ligne,colonne,tab_nombres,tab_CloneLigne);
trier_ligne(tab_nombres,tab_CloneLigne,ligne,colonne);
}
}
public static void trier_ligne(int[,] tab_nombres ,int[] tab_CloneLigne,int ligne,int colonne)
{
//Trie une ligne , d'une copie de tableau
Array.Sort(tab_CloneLigne);
for(ligne = 0;ligne < tab_nombres.GetLength(1);ligne++)
{
tab_nombres[colonne,ligne]=tab_CloneLigne[ligne];
}
}
public static void copier_ligne(int ligne,int colonne,int[,] tab_nombres,int[] tab_CloneLigne)
{
//Copie une ligne dun tableau multi-dimensionel vers un tableau a une seule dimension , pour triage.
for(int ind=0;ind<tab_CloneLigne.Length;ind++)
{
tab_CloneLigne[ind] = tab_nombres[colonne,ind];
}
}
public static void Effacer_Tabdoublons(int[] tab_doublons)
{
//Initialise un tableau
int ind;
for(ind=0;ind<tab_doublons.Length;ind++)
{
tab_doublons[ind] = 0;
}
}
public static bool verifier_doublons(int[] tab_doublons,int nbr_rnd)
{
//Verifie si un nombre a deja ete tirer , si c'est le cas il retourne vrai
//sinon , le tab_doublons a l'indice du nombre tirer , prend la valeur 1
bool reponse;
if(tab_doublons[nbr_rnd] == 1)
{
reponse=true;
}
else
{
reponse = false;
tab_doublons[nbr_rnd] = 1;
}
return reponse;
}
public static void generer_combine_gagnante(int[] tab_combine_gagnante,int[] tab_doublons,ref Random rnd)
{
//Genere la combinaison gagnante de 6 chiffres.
int ind=0;
for(ind=0;ind<tab_combine_gagnante.Length;ind++)
{
tab_combine_gagnante[ind]=rnd.Next(49)+1;
}
Array.Sort(tab_combine_gagnante);
}
public static void saisir_nbr_tirage(ref int nbr_tirage)
{
//Demande a l'utilisateurs le nombre de tirages a effectuer.
do
{
Console.WriteLine("Combien de combinaisons a tirer (1-10)?");
nbr_tirage=int.Parse(Console.ReadLine());
}while(nbr_tirage < 0 || nbr_tirage > 10);
}
public static void generer_Tab_gains(int[] tab_combine_gagnante,int[,] tab_gains,int[,] tab_nombres)
{
//Génère le tableau des combinaisons a tirer
int colonne,ligne,ind;
colonne=ligne=ind=0;
for(colonne = 0;colonne < tab_nombres.GetLength(0);colonne++)
{
for(ligne = 0;ligne < tab_nombres.GetLength(1);ligne++)
{
for(ind=0;ind<tab_combine_gagnante.Length;ind++)
{
if(tab_nombres[colonne,ligne] == tab_combine_gagnante[ind])
tab_gains[colonne,ligne] = 1;
}
}
}
}
public static void generer_Tab_gains(int[] tab_gains_extra,int[] tab_extra)
{
//Génère le tableau des combinaisons gagnantes
int ind;
ind=0;
for(ind=0;ind<tab_extra.Length;ind++)
{
if(tab_extra[ind] == tab_extra[tab_extra.Length-1])
tab_gains_extra[ind] = 1;
}
}
public static void afficher_table(int[,] tab_nombres,int[,] tab_gains,int[] tab_extra,int[] tab_gains_extra,int nbr_tirage,int[] tab_combine_gagnante)
{
//Fonction d'affichage.
int colonne,ligne;
colonne=ligne=0;
Console.Write("#########################################################\n");
Console.Write("# 1\t 2\t 3\t 4\t 5\t 6\tExtra #\n");
Console.Write("#########################################################\n");
for(colonne = 0;colonne < nbr_tirage ;colonne++)
{
Console.Write("#");
for(ligne = 0;ligne < tab_nombres.GetLength(1);ligne++)
{
Console.Write("{0,2}\t",tab_nombres[colonne,ligne]);
}
Console.Write("{0}\t",tab_extra[colonne]);
Console.Write("#");
Console.Write("\n");
}
Console.Write("#########################################################\n");
int ind=0;
Console.Write("#");
for(ind=0;ind<tab_combine_gagnante.Length;ind++)
{
Console.Write("{0,2}\t",tab_combine_gagnante[ind]);
}
Console.Write("{0,2}\t",tab_extra[tab_extra.Length-1]);
Console.Write("#\n");
Console.Write("#########################################################\n");
/* Tableau pour le debug
* affiche la table des gains pour tab_gains[]
Console.Write("#########################################################\n");
Console.Write("# 1\t 2\t 3\t 4\t 5\t 6\tExtra #\n");
Console.Write("#########################################################\n");
for(colonne = 0;colonne < nbr_tirage ;colonne++)
{
Console.Write("#");
for(ligne = 0;ligne < tab_gains.GetLength(1);ligne++)
{
Console.Write("{0,2}\t",tab_gains[colonne,ligne]);
}
Console.Write("#");
Console.Write("\n");
}
Console.Write("#########################################################\n");
*/
Resultat_stats(tab_gains,tab_gains_extra,nbr_tirage); //Apelle resultat_stats
}
public static void Resultat_stats(int[,] tab_gains,int[] tab_gains_extra,int nbr_tirage)
{
int addition,colonne,ligne;// Affiche les gains
ligne=addition=colonne=0;
for(colonne = 0;colonne < tab_gains.GetLength(0) ;colonne++)
{
for(ligne = 0;ligne < tab_gains.GetLength(1);ligne++)
{
addition += tab_gains[colonne,ligne];
}
if(nbr_tirage == colonne)break;
Console.Write("\n");
Console.Write("ligne{0}: {1} de 6 + {2}\t",colonne+1,addition,tab_gains_extra[colonne]);
addition = 0;
}
Console.Write("\n");
}
public static char recommencer()
{//Fonction qui demande a l'utilisateur s'il veu recomencer ou terminer.
char recommence;
do
{
Console.Write("Voulez vous recommencer ? (O/N):");
recommence = Char.ToUpper(Char.Parse(Console.ReadLine()));
}while(recommence != 'O' && recommence != 'N');
return recommence;
}
}
}