using System;

class MainClass
{
    const int MAX_LOTTO_KUGELN = 49;
    public enum LottoMode {Oesterreich, Deutschland};

    public static void Main(string[] args)
    {
    LottoMode eMode = LottoMode.Oesterreich;;
    
    Console.Write("(d)...Deutsches oder \n(o)...österreichisches Lotto? ");

    //ohne Netz & doppelten Boden:
    string strMode = Console.ReadLine();
    
    // etwas simpel, aber was soll's
    // alles was nicht 'd' ist, ist österreichisch
    if (strMode.Length > 0)
        if (strMode[0] == 'd')
            {
            eMode = LottoMode.Deutschland;
            }

    Console.Write("Ihr Tipp: ");    
    BruteForceLotto (eMode);
    UnrolledLoopLotto (eMode);
    DualLoopLotto (eMode);
    }

/*******************************************************************/

    // Referenzläsung basierend auf CD-shuffle
    public static void BruteForceLotto (LottoMode eMode)
        {
        // default ist österreich
        int nKugelZahl = 45;
        // Aus Neugier
        int nRunden = 0;
        
        if (eMode == LottoMode.Deutschland)
            {
            nKugelZahl = 49;
            }
            
        // Modell einer Echten Lottoziehung:
        // Dieses Array modelliert unsere "Urne", aus der die "Kugeln" gezogen werden
        // Anfänglich enthält es alle Werte von 1 bis 45(49). Ein zufälliger Indexwert
        // bestimmt, welche Kugel gezogen wird. Dieses Arrayelement erhält dann den 
        // Wert 0, der eine gezogene Kugel kennzeichnet.
        int[] anKugeln = new int[nKugelZahl];

        // Kugeln initialisieren (Index 0..44 => Wert 1..45 usw)
        for (int i = 0; i < nKugelZahl; i++)
            {
            // Der Operator "[]" heisst Indexoperator und adressiert 
            // ein einzelnes Element eines Arrays
            // Hier wird jedem Arrayelement ein Wert zugewiesen 
            // (Die Indexposition + 1)
            anKugeln[i] = i+1;
            }

        // NIE innerhalb einer Schleife deklarieren!
        // System.Random ist ein Pseudo-Zufallszahlengenerator, der seinen 
        // Startwert aus der Systemzeit oder einem Konstruktor-Parameter bezieht 
        Random rndGen = new Random();
        
        int nZufallsIndex;
        
        // Wichtig ist, dass KEINE Kugel mehrmals in eimem Tipp erscheinen darf.
        // Die Brute force Methode ist hier gut geeignet, da bei nur 6 Werten aus 45(49)
        // die Wahrscheinlichkeit, eine noch vorhandene Kugel zu treffen recht hoch ist.
        for (int i = 0; i < 6; i++)
            {
            // so lange Zufallsindzes berechnen, bis wir KEINE Null treffen.
            do
                {
                // Die Methode Next(nKugelZahl) liefert einen Pseudo-Zufallswert zwischen 
                // 0 (inklusive) und nKugelZahl (exklusive).
                nZufallsIndex = rndGen.Next(nKugelZahl);
                nRunden++;
                }
            while (anKugeln[nZufallsIndex] == 0);
            
            // Diese Kugel als "gezogen" markieren
            anKugeln[nZufallsIndex] = 0;
            }

        // Luxusversion: SORTIERTE Ausgabe: Wir laufen noch mal durch 
        // das Kugelarray geben einfach aus, wo die Nullen stehen
        for (int i = 0; i < nKugelZahl; i++)
            {
            if (anKugeln[i] == 0)
                {
                // Die Nummer der Kugel ist ja index+1 
                Console.Write("{0:D2} ",i+1);
                }
            }           
        
        Console.WriteLine("=> {0} Runden", nRunden);    
        return;         
        }

/*******************************************************************/
    
    // Allgemeinlösung Hauptvariante II, aber funktionierend ;-)
    public static void UnrolledLoopLotto (LottoMode eMode)
        {
        // default ist österreich
        int nKugelZahl = 45;
        // Aus Neugier
        
        if (eMode == LottoMode.Deutschland)
            {
            nKugelZahl = 49;
            }

        Random rndGen = new Random();

        int Zahl1=0, Zahl2=0, Zahl3=0, Zahl4=0, Zahl5=0, Zahl6=0;
                
        // die muss ja eindeutig sein...
        Zahl1 = rndGen.Next(nKugelZahl) + 1;

        do
            Zahl2 = rndGen.Next(nKugelZahl) + 1;
        while(Zahl2 == Zahl1);
            
        do
            Zahl3 = rndGen.Next(nKugelZahl) + 1;
        while(Zahl3 == Zahl1 || Zahl3 == Zahl2);
            
        do
            Zahl4 = rndGen.Next(nKugelZahl) + 1;
        while(Zahl4 == Zahl1 || Zahl4 == Zahl2 || Zahl4 == Zahl3);
            
        do
            Zahl5 = rndGen.Next(nKugelZahl) + 1;
        while(Zahl5 == Zahl1 || Zahl5 == Zahl2 || Zahl5 == Zahl3 || Zahl5 == Zahl4);
            
        do
            Zahl6 = rndGen.Next(nKugelZahl) + 1;
        while(Zahl6 == Zahl1 || Zahl6 == Zahl2 || Zahl6 == Zahl3 || Zahl6 == Zahl4 || Zahl6 == Zahl5);

        Console.WriteLine("Dies sind die Lottozahlen (Version II): {0} {1} {2} {3} {4} {5}!",
                          Zahl1,Zahl2,Zahl3,Zahl4,Zahl5,Zahl6);
    
        }

/*******************************************************************/

    // Allgemeinlösung Hauptvariante III, aber funktionierend ;-)
    public static void DualLoopLotto (LottoMode eMode)
        {
        const int ZIEHUNG_KUGELN = 6;
        // default ist österreich
        int   nKugelZahl = 45;
        int[] anKugeln = new int[ZIEHUNG_KUGELN];
        
        if (eMode == LottoMode.Deutschland)
            {
            nKugelZahl = 49;
            }

        Random rndGen = new Random();
        
        // hier fehlt absichtlich die Inkrementierung!
        for (int nZiehung = 0; nZiehung < ZIEHUNG_KUGELN; )
            {
            anKugeln[nZiehung] = rndGen.Next(nKugelZahl)+1;     
            
            bool fDuplicate = false;
            
            // mit dieser Laufbedingung wird der Wert an der Stelle
            // nZiehung selbst NICHT verglichen!
            for (int i = 0; i < nZiehung; i++)
                {
                if (anKugeln[nZiehung] == anKugeln[i])
                    {
                    fDuplicate = true;      
                    }
                }
            // Wennns den schon gegeben hat, OHNE Inkrement zurück in die Schleife 
            if (fDuplicate)
                {
                continue;
                }
            // nur sonst haben wir eine gültige Zahl gezogen.  
            nZiehung++; 
            }

        Console.Write("Dies sind die Lottozahlen (Version III): ");
        for (int i=0; i < ZIEHUNG_KUGELN; i++)
            {
            Console.Write("{0} ",anKugeln[i]);
            }
            
        Console.WriteLine("!");

        }

} // class

syntax highlighted by Code2HTML, v. 0.9.1