using System;

namespace mmVide
{
	class MainClass
	{
		/* Retourne une combinaison aléatoire de nbChiffres compris 
		 * entre 1 et chiffreMax
		 * */
		
		public static int[] creerCombinaison(int nbChiffres, int chiffreMax, 
		                                     bool doublonsAutorises)
		{
			return null;
		}		

		/*
		 * Retourne vrai ssi pour tout i, 1 <= t[i] <= chiffreMax
		 * */
		
		public static bool infChiffreMax(int [] t, int chiffreMax)
		{
			return true;
		}
		
		/*
		 * retourne un tableau contenant les nbChiffres saisis dans la chaîne s
		 * la chaîne s doit contenir les chiffres de la combinaison séparés par 
		 * des espaces. Retourne null si le tableau est impossible à parser.
		 * */
		
		public static int[] parseCombinaison(string s, int nbChiffres)
		{
			return null;
		}

		/*
		 * Retourne le nombre de chiffres identiques dans les deux tableaux
		 * ne compare que les valeurs de même indice, les deux tableaux 
		 * doivent être de même longueur.
		 * */
		
		public static int calculeBienPlaces(int[] a, int[] b)
		{
			return 0;
		}
		
		/*
		 * Retourne un tableau x de chiffreMax éléments tel que x[i] est 
		 * le nombre d'occurrences de i dans t.
		*/
		
		public static int[] nbOccurrences(int[] t, int chiffreMax)
		{
			return null;
		}
		
		/*
		 * Retourne le plus petit de ses arguments.
		 * */
		
		public static int min(int a, int b)
		{
			return 0;
		}
		
		/*
		 * Retourne un tableau t tq t[i] = min(a[i], b[i])
		 * a et b doivent être de même longueur.
		 * */
		
		public static int[] min(int[] a, int[] b)
		{
			return null;
		}
		
		/*
		 * Retourne le nombre d'élements mal positionnés dans la combinaison. 
		 * Soit a et b les deux combinaisons à comparer, tabMin[x] doit être le nombre 
		 * d'occurrences de x présentes dans les deux tableaux à la fois.
		 * */
		
		public static int calculeMalPlaces(int[] tabMin, int bienPlaces)
		{
			return 0;
		}
		
		/*
		 * Demande à l'utilisateur de saisir une combinaison de nbChiffres compris entre 1 et chiffreMax
		 * au format chaîne de caractère,
		 * contrôle la saisie et retourne un tableau contenant les éléments saisis.
		 * */
		
		public static int[] saisitCombinaison(int nbChiffres, int chiffreMax)
		{
			return null;
		}
		

		/*
		 * Affiche la combinaison. Ne revient pas à la ligne.
		 * */
		
		public static void afficheCombinaison(int[] combinaison)
		{	
		}

		/*
		 * Affiche un tableau récapitulatif des combinaisons précédentes.
		 * tour est le nombre de tours déjà effectués.
		 * combinaisons[i] contient la combinaison saisie par l'utilisateur au tour i.
		 * bienPlaces[i] est le nombre d'éléments bien placés dans combinaisons[i]
		 * malPlaces[i] est le nombre d'éléments mal placés dans combinaisons[i]
		 * */
		
		public static void afficheCombinaisonsPrecedentes(int[][] combinaisons, 
		                                                  int[] bienPlaces, int[] malPlaces, int tour)
		{
		}		
		
		/*
		 * Fin d'une partie, affiche la réponse à l'utilisateur s'il a perdu.
		 */
		
		public static void afficheResultat(int[] combinaison, bool gagne)
		{
		}
		
		/*
		 * Lance une partie.
		 * nbChiffres est la taille de la combinaison à trouver
		 * ChiffreMax est le nombre le plus grand de la combinaison
		 * nbTour est le nombre d'essais laissés à l'utilisateur.
		 */
		
		public static void tousLesTours(int nbChiffres, int chiffreMax, 
		                                int nbTours, bool doublonsAutorises)
		{
		}
		
		/*
		 * Initialise les paramètres et lance une ou plusieurs parties.
		 * */
		
		public static void menuPrincipal()
		{
		}
		
		/*
		public static void Main (string[] args)
		{
			menuPrincipal();
		}
		*/
	}
}