Lottorader c#

{
            //Deklaration av variabler
            char fortsätta = 'j';
            char sammaLottorad = 'n';
            short valMeny1 = 0;
            short valMeny2 = 0;
            short[] lottorad = new short[7];
            short inmatatLottotal = 0;
            int jämförelseTermer = 0;
            int[] jämförelseRader = new int[7];
            int jämförelseRaderTal = 0;
            short räknareAntalRättPerRad = 0;
            int[] antalRätt = new int[3];
            short antalRättVal2 = 0;
            int varvVal2 = 0;
            bool giltligRad = true;
            bool klarVal2 = false;

            //Nytt random-objekt
            Random r = new Random();

            while (fortsätta == 'j')        //Gör att man senare kan välja om man vill köra programmet igen
            {
                //Menyval
                Console.Clear();        //Rensa konsollen, användbart om programmet körs flera gånger utan att stänga fönstret
                Console.WriteLine("Välj vad du vill göra i menyn nedan.");
                Console.WriteLine("1. Jämför egen lottorad mot andra och se antal rätt");
                Console.WriteLine("2. Undersök hur många dragningar som krävs för att få ett visst antal rätt");

                valMeny1 = short.Parse(Console.ReadLine());

                //Inmatning av lottorad
                if (sammaLottorad == 'n')       //Gör så att man kan använda samma lottorad flera varv
                {
                    Console.WriteLine("Ange din lottorad:");
                    for (int i = 0; i < lottorad.Length; i++)
                    {
                        Console.Write("Nummer {0}: ", (i + 1));
                        inmatatLottotal = short.Parse(Console.ReadLine());

                        //Gör att man ej kan ange samma tal flera gånger per lottorad eller ange tal större än 35
                        if (inmatatLottotal == lottorad[0] || inmatatLottotal == lottorad[1] || inmatatLottotal == lottorad[2] || inmatatLottotal == lottorad[3] || inmatatLottotal == lottorad[4] || inmatatLottotal == lottorad[5] || inmatatLottotal == lottorad[6] || inmatatLottotal > 35)
                        {
                            giltligRad = false;
                        }

                        lottorad[i] = inmatatLottotal;      //Sparar till variabeln lottorad
                    }

                    //Om raden ej var giltlig
                    if (giltligRad == false)
                    {
                        Console.WriteLine("Lottorad är ej giltlig.");
                        Console.WriteLine("Samma värde får ej förekomma mer än en gång och högsta tillåtna tal är 35.");
                        sammaLottorad = 'n';
                    }
                }

                if (giltligRad == true)     //Gör att programmet endast kan gå vidare om den inmatade lottoraden var giltlig
                {
                    if (valMeny1 == 1)      //Valet i den första menyn verkställs
                    {
                        Console.WriteLine("Hur många rader vill du jämföra mot? Ange nummret på alternativet nedan.");
                        Console.WriteLine("1. 10 000 stycken");
                        Console.WriteLine("2. 100 000 stycken");
                        Console.WriteLine("3. 1 000 000 stycken");
                        Console.WriteLine("4. 10 000 000 stycken");
                        Console.WriteLine("5. Ange eget värde");

                        valMeny2 = short.Parse(Console.ReadLine());     //Låter användaren välja hur många rader man ska jämföra mot

                        switch (valMeny2)
                        {
                            case 1:
                                {
                                    jämförelseTermer = 10000;
                                    break;
                                }
                            case 2:
                                {
                                    jämförelseTermer = 100000;
                                    break;
                                }
                            case 3:
                                {
                                    jämförelseTermer = 1000000;
                                    break;
                                }
                            case 4:
                                {
                                    jämförelseTermer = 10000000;
                                    break;
                                }
                            case 5:
                                {
                                    Console.WriteLine("Ange antalet rader nedan:");     //Gör det möjligt att ange ett eget värde för antalet rader att jämföra mot
                                    jämförelseTermer = int.Parse(Console.ReadLine());
                                    break;
                                }
                        }

                        //Beräkningen av antalet rätt
                        for (int i = 0; i < jämförelseTermer; i++)      //Kör slingan lika många varv som valdes ovan
                        {
                            for (int q = 0; q < 7; q++)     //Slinga som kör sju varv, ett varv för varje tal i enskild lottorad som jämförs mot
                            {
                                jämförelseRaderTal = r.Next(1, 36);     //Skapar ett random-tal 1 ≤ x ≤ 35

                                //Jämför talet med tidigare tal i lottoraden. Om talet förekommer tidigare i raden ersätts det med ett annat
                                while (jämförelseRaderTal == jämförelseRader[0] || jämförelseRaderTal == jämförelseRader[1] || jämförelseRaderTal == jämförelseRader[2] || jämförelseRaderTal == jämförelseRader[3] || jämförelseRaderTal == jämförelseRader[4] || jämförelseRaderTal == jämförelseRader[5] || jämförelseRaderTal == jämförelseRader[6])
                                {
                                    jämförelseRaderTal = r.Next(1, 36);
                                }

                                //Talet jämförs med den inmatade lottoraden. Om talet matchar något av talen i den ökar variablen med ett
                                if (jämförelseRaderTal == lottorad[0] || jämförelseRaderTal == lottorad[1] || jämförelseRaderTal == lottorad[2] || jämförelseRaderTal == lottorad[3] || jämförelseRaderTal == lottorad[4] || jämförelseRaderTal == lottorad[5] || jämförelseRaderTal == lottorad[6])
                                {
                                    räknareAntalRättPerRad++;
                                }

                                jämförelseRader[q] = jämförelseRaderTal;        //Sparar talet till jämförelseRader. Talet får samma plats som varvet i loopen.

                            }
                            //Räknar antalet rätt
                            switch (räknareAntalRättPerRad)
                            {
                                case 5:     //Om antal rätt = 5 ökar variabeln med ett
                                    {
                                        antalRätt[0]++;
                                        break;
                                    }
                                case 6:     //Om antal rätt = 6 ökar variabeln med ett
                                    {
                                        antalRätt[1]++;
                                        break;
                                    }
                                case 7:     //Om antal rätt = 7 ökar variabeln med ett
                                    {
                                        antalRätt[2]++;
                                        break;
                                    }
                            }

                            räknareAntalRättPerRad = 0;     //Nollställer räknaren för antal rätt per rad

                            //Nollställer raden som jämförelsen sker mot
                            for (int k = 0; k < jämförelseRader.Length; k++)
                            {
                                jämförelseRader[k] = 0;
                            }

                            //Skriver ut punkter som indikerar att programmet räknar om talet är 10 000 eller större
                            if (jämförelseTermer >= 10000)
                            {
                                if (i % (jämförelseTermer / 20) == 0)       //Om varvet i loopen går att dela med en tjugondel av raderna som man jämför mot utan att få någon rest, skrivs en punkt ut
                                {
                                    Console.Write(".");
                                }
                            }
                        }
                        Console.WriteLine();        //Radbryt efter punkterna
                        //Skriver ut resultatet
                        Console.WriteLine("Rättat mot {0} rader, hade du sju rätt {1} gång(er), sex rätt {2} gång(er) och fem rätt {3} gång(er).", jämförelseTermer, antalRätt[2], antalRätt[1], antalRätt[0]);
                    }

                    DEL 2 AV PROGRAMMET. EJ PROBLEMET.
                }

                //Möjliggör att användaren kan köra programmet igen
                Console.WriteLine("Vill du köra programmet igen (fönstret kommer att rensas)? (j/n)");
                fortsätta = char.Parse(Console.ReadLine());

                //OM användaren vill köra programmet igen ställs frågan om samma lottorad ska användas
                if (fortsätta == 'j')
                {
                    if (giltligRad == true)
                    {
                        Console.WriteLine("Vill du använda samma lottorad? (j/n)");
                        sammaLottorad = char.Parse(Console.ReadLine());
                    }

                        //Om användaren vill ange en ny lottorad nollställs den förra
                        if (sammaLottorad == 'n')
                        {
                            for (int i = 0; i < 7; i++)
                            {
                                lottorad[i] = 0;
                            }
                        }

                    klarVal2 = false;       //Nollställer loopen för val 2 i den första menyn (jämföra raden till man får ett visst antal rätt
                    giltligRad = true;      //Möjliggör att en ny rad kan betraktas som giltlig, annars blir ägven en giltlig rad sedd som ogiltlig

                    //Nollställer räknaren för antal rätt per antal rätt (ex. vis hur många 5 rätt)
                    for (int o = 0; o < antalRätt.Length; o++)
                    {
                        antalRätt[o] = 0;
                    }

                }
            }

            Console.ReadLine();
        }
    }
}