using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace kartentrick
{
    class Program
    {
        static char[] colors = { 'H', 'K', 'P', 'Z' };
        static string[] cardtypes = { "Zehn", "Bube", "Dame", "König", "Ass" };

        static void Main(string[] args)
        {
            Console.WindowWidth = 90;
            string[] cards = GetCardPack();
            Print(5, cards);
            Console.Write("\nIn welchem Stapel ist ihre Karte?: ");
            string input = Console.ReadLine();
            Print(4, cards);
            Console.Write("\nIn welchem Stapel ist ihre Karte?: ");
            string stacknum = Console.ReadLine();
            string choosen = RetrieveChoosenCard(int.Parse(input), int.Parse(stacknum), cards);
            Console.Clear();
            Console.WriteLine("Ihre Karte: {0}", choosen);
            Console.ReadLine();
        }

        /// <summary>
        /// Gibt die gesuchte Karte zurück
        /// </summary>
        static string RetrieveChoosenCard(int fiveStack, int fourStack, string[] cards)
        {
            for (int i = 0; i < 4; i++)
            {        
                for (int j = 0; j < 5; j++)
                {
                    if (cards[i * 5 + fiveStack-1] == cards[j * 4 + fourStack - 1])
                    {
                        return cards[i * 5 + fiveStack - 1];
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// Initialisiert Karten und mischt sie
        /// </summary>
        /// <returns></returns>
        static string[] GetCardPack()
        {
            string[] pack = new string[20];
            int ct = 0;
            for (int i = 0; i < cardtypes.Length; i++)
            {
                for (int j = 0; j < colors.Length; j++)
                {
                    pack[ct] = colors[j] + " " + cardtypes[i] ;
                    ct++;
                }
            }
            Random random = new Random();
            for (int i = 0; i < 50; i++) //Funktion zum Mischen der Karten
            {
                int a = random.Next(0, 20);
                int b = random.Next(0, 20);
                if (a != b)
                {
                    string swap = pack[a];
                    pack[a] = pack[b];
                    pack[b] = swap;
                }
            }
            return pack;
        }

        static void Print(int stackcount, string[] cards)
        {
            for (int i = 0; i < stackcount; i++)
            {
                Console.Write("{0}.Stapel\t", i + 1);
            }
            Console.WriteLine("\n");
            int ct = 0;
            for (int i = 0; i < 20 / stackcount; i++)
            {
                for (int j = 0; j < stackcount; j++)
                {
                    Console.Write(cards[ct] + "\t\t");
                    ct++;
                }
                Console.WriteLine();
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace Kartentrick
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WindowWidth = 120;
            
            Console.WriteLine("Bitte eine Karte aussuchen und merken:\n");
            
            string[] karten = InitKarten();
            AusgabeStapel(5, karten);
           
            Console.Write("\nIn welchem Stapel liegt ihre gemerkte Karte? ");
            
            int stapel1;
            while (!int.TryParse(Console.ReadKey(false).KeyChar.ToString(), out stapel1) || (stapel1 < 1 || stapel1 > 5 ))
                Console.Write("\nUngültige Eingabe. In welchem Stapel liegt ihre gemerkte Karte? ");
            
            Console.Write("\n\n");
            AusgabeStapel(4, karten);
            Console.Write("\nIn welchem Stapel liegt ihre gemerkte Karte jetzt? ");
            
            int stapel2;
            while (!int.TryParse(Console.ReadKey(false).KeyChar.ToString(), out stapel2) || (stapel2 < 1 || stapel2 > 4))
                Console.Write("\nUngültige Eingabe. In welchem Stapel liegt ihre gemerkte Karte? ");
            
            Console.WriteLine("\n\nIhre gemerkte Karte: " + karten[GetKarte(stapel1, stapel2) -1 ]);
            Console.ReadKey();
        }
                
        static int GetKarte(int stapel1, int stapel2)
        {
            // Chinesischer Restsatz, siehe Posting  
            return (stapel1 * 16 + stapel2 * 5) % 20;  
        }

        static string[] InitKarten()
        {
            string[] farben = { "Kreuz", "Karo", "Herz", "Pik" };
            string[] werte = { "Zehn", "Bube", "Dame", "König", "Ass" };

            string[] karten = new string[20];

            for (int i = 0; i < 20; i++)
                karten[i] = farben[i % 4] + " " + werte[i % 5];

            Shuffle<string>(karten);

            return karten;
        }

        static void AusgabeStapel(int anzStapel, string[] karten)
        {
            for (int i = 1; i ≤ anzStapel; i++)
                Console.Write("{0,-15}", i);
            
            Console.Write('\n');
            for (int i = 1; i ≤ 20; i++)
            {
                Console.Write("{0,-15}", karten[i-1]);
                if (i % anzStapel == 0)
                    Console.Write('\n');
            }
        }

        private static Random rand = new Random();
        public static void Shuffle<T>(IList<T> ilist)
        {
            int iIndex;
            T tTmp;
            for (int i = 1; i < ilist.Count; ++i)
            {
                iIndex = rand.Next(i + 1);
                tTmp = ilist[i];
                ilist[i] = ilist[iIndex];
                ilist[iIndex] = tTmp;
            }
        }
    }
}

private bool IsAccessable(int sourceX, int sourceY, int destX, int destY){ ... } 

     private void InitEdge(ref Button b, int i, int h)
        {
           .
           .
           .
           .
            b.Name = "Ecke";
        }

        private void InitField(ref Button b, int i, int h)
        {
          
           .
           .
           .
           .
            b.Name = "Feld";
        }

        private void InitHorStone(ref Button b, int i, int h)
        {
           
           .
           .
           .
           .
            b.Name = "HSchranke";
        }

        private void InitVerStone(ref Button b, int i, int h)
        {
           .
           .
           .
           .
             b.Name = "VSchranke";
        }

private void canPacmanAccessToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (IsAccessable(startPoint[0], startPoint[1], cageField[0], cageField[1]))
                MessageBox.Show("YES! Pacman can access!");
            else
                MessageBox.Show("NO! Pacman can NOT access.");

        }
        
        private bool IsAccessable(int sourceX, int sourceY, int destX, int destY)
        {
            // Labyrinth aus dem Button Array erzugen
            Pathfinder.Field[,] labyrinth = new Pathfinder.Field[11,8];

            for (int i = 0; i < 11; i++)
            {
                for (int j = 0; j < 8; j++)
                {
                    Pathfinder.Field curField = new Pathfinder.Field();

                    int curPacmanField_X = i == 0 ? 1 : i * 2 + 1;
                    int curPacmanField_Y = j == 0 ? 1 : j * 2 + 1;

                    // Feld oben geschlossen?
                    if (pacmanField[curPacmanField_X, curPacmanField_Y - 1].BackColor == colorClosed)
                        curField.WallAbove = true;

                    // Feld rechts geschlossen?
                    if (pacmanField[curPacmanField_X + 1, curPacmanField_Y].BackColor == colorClosed)
                        curField.WallRight = true;

                    // Feld unten geschlossen?
                    if (pacmanField[curPacmanField_X, curPacmanField_Y + 1].BackColor == colorClosed)
                        curField.WallBelow = true;

                    // Feld links geschlossen?
                    if (pacmanField[curPacmanField_X - 1, curPacmanField_Y].BackColor == colorClosed)
                        curField.WallLeft = true;

                    labyrinth[i, j] = curField;
                }    
            }
            
            Pathfinder pathfinder = new Pathfinder(labyrinth, 11, 8);
          
            return pathfinder.CanReach(ToRealIndex(sourceX), ToRealIndex(sourceY), ToRealIndex(destX), ToRealIndex(destY));
        }

        private int ToRealIndex(int index)
        {
            return (int)(index / 2);
        }

using System;
using System.Collections.Generic;

namespace pacman
{
    class Pathfinder
    {
        /// <summary>
        /// Ein Feld im Labyrinth
        /// </summary>
        public class Field
        {
            public bool WallAbove { get; set; }
            public bool WallRight { get; set; }
            public bool WallBelow { get; set; }
            public bool WallLeft { get; set; }

            public bool visited { get; set; }
        }

        /// <summary>
        /// Ein Punkt im Labyrinth, für den "Faden" benötigt
        /// </summary>
        class Point
        {
            public int X { get; set; }
            public int Y { get; set; }

            public Point(int x, int y)
            {
                X = x;
                Y = y;
            }
        }

        /// <summary>
        /// Das Labyrinth als 2D-Array
        /// </summary>
        private Field[,] labyrinth;
        private int rows;
        private int colums;

        public Pathfinder(Field[,] labyrinth, int rows, int colums)
        {
            if (labyrinth.Length < 4 || labyrinth == null)
                throw new ArgumentException("No valid labyrinth");

            if (rows < 2 || colums < 2)
                throw new ArgumentException("Invalid row or colums count.");

            this.labyrinth = labyrinth;
            this.rows = rows - 1;
            this.colums = colums - 1;
        }

        private bool FieldAlreadyVisited(int x, int y)
        {
            // Oben raus, unten rein, rechts raus, links rein umd umgekehrt ;)
            if (x < 0)
                x = rows;
            
            if (x > rows)
                x = 0;

            if (y < 0)
                y = colums;

            if (y > colums)
                y = 0;

            return labyrinth[x, y].visited;
        }

        public bool CanReach(int startX, int startY, int targetX, int targetY)
        {
            if (startX > rows || startY > colums || startX < 0 || startY < 0)
                throw new ArgumentException("No valid start point.");

            if (targetX > rows || targetY > colums || targetX < 0 || targetY < 0)
                throw new ArgumentException("No valid target point.");

            if (startX == targetX && startY == targetY)
                throw new ArgumentException("Start and target are equal.");

            // Der Ariadnefaden um im Labyrinth wieder (aus Sackgasse) herauszufinden
            Stack<Point> ariadne = new Stack<Point>();

            // Startwerte setzten
            int curFieldX = startX;
            int curFieldY = startY;

            while (true)
            {
                // Ziel schon erreicht?
                if (curFieldX == targetX && curFieldY == targetY)
                    return true;

                // In das nächte Feld gehen, wenn keine Wand im Weg oder nicht schon besucht
                if (!labyrinth[curFieldX, curFieldY].WallAbove && !FieldAlreadyVisited(curFieldX, curFieldY - 1))
                {
                    if (curFieldY - 1 < 0)
                        curFieldY = colums;
                    else
                        curFieldY--;
                }
                else if (!labyrinth[curFieldX, curFieldY].WallRight && !FieldAlreadyVisited(curFieldX + 1, curFieldY)) 
                {
                    if (curFieldX + 1 > rows)
                        curFieldX = 0;
                    else
                        curFieldX++;
                }
                else if (!labyrinth[curFieldX, curFieldY].WallBelow && !FieldAlreadyVisited(curFieldX, curFieldY +1 )) 
                {
                    if (curFieldY + 1 > colums)
                        curFieldY = 0;
                    else
                        curFieldY++;
                }
                else if (!labyrinth[curFieldX, curFieldY].WallLeft && !FieldAlreadyVisited(curFieldX - 1, curFieldY))
                {                 
                    if (curFieldX - 1 < 0)
                        curFieldX = rows;
                    else
                        curFieldX--;
                }
                else // Sackgasse
                {
                    // Wieder am Startpunkt angelangt oder eingesperrt -> Kein Weg
                    if (ariadne.Count == 0)
                        return false;

                    // Ein Schritt zurück
                    Point prev = ariadne.Pop();
                    curFieldX = prev.X;
                    curFieldY = prev.Y;

                    continue;
                }

                // Aktuelles Feld als besucht markieren
                labyrinth[curFieldX, curFieldY].visited = true;
                
                // "Faden verlängern"
                ariadne.Push(new Point(curFieldX, curFieldY));
            }
        }

    }
}

using System;
using System.Collections.Generic;

class AchtDamen
{
    const int brettGröße = 8;
    const int feldzahl = brettGröße * brettGröße;

    static void Main(string[] args)
    {
        int[] angriffszahlen = new int[brettGröße * brettGröße];
        int aktuellesFeld = 0;

        Stack<int> schritte = new Stack<int>();
        while (true)
        {
            if (aktuellesFeld < feldzahl)
            {
                if (angriffszahlen[aktuellesFeld] == 0)
                {
                    FürAlleErreichbarenFelder(aktuellesFeld % brettGröße, aktuellesFeld / brettGröße,
                        (x, y) =>
                        {
                            angriffszahlen[x + y * brettGröße]++;
                        });
                    schritte.Push(aktuellesFeld);
                    if (schritte.Count == 8)
                        break;

                    aktuellesFeld = 0;
                }
                else
                    aktuellesFeld++;
                continue;
            }
            if (schritte.Count > 0)
            {
                aktuellesFeld = schritte.Pop();
                FürAlleErreichbarenFelder(aktuellesFeld % brettGröße, aktuellesFeld / brettGröße,
                    (x, y) =>
                    {
                        angriffszahlen[x + y * brettGröße]--;
                    });
                aktuellesFeld++;
                continue;
            }
            Console.WriteLine("Keine Lösung gefunden!");
            Console.ReadLine();
            return;
        }
        char[] ausgabe = new char[feldzahl];
        for (int i = 0; i < ausgabe.Length; i++)
            ausgabe[i] = (((i + i / brettGröße) & 1) == 0) ? ' ' : 'ˆ';
        foreach (int schritt in schritte)
        {
            ausgabe[schritt] = 'Q';
        }

        Console.WriteLine("##########");
        for (int y = 0; y < brettGröße; y++)
        {
            Console.Write("#");
            for (int x = 0; x < brettGröße; x++)
                Console.Write(ausgabe[x + y * brettGröße]);
            Console.WriteLine("#");
        }
        Console.WriteLine("##########");
        Console.ReadLine();
    }

    private static void FürAlleErreichbarenFelder(int xStart, int yStart, Action<int, int> aktion)
    {
        aktion(xStart, yStart);
        int x, y;

        for (x = 0; x < brettGröße; x++)//quer
        {
            if (x != xStart)
                aktion(x, yStart);
        }

        for (y = 0; y < brettGröße; y++)//senkrecht
        {
            if (y != yStart)
                aktion(xStart, y);
        }

        x = xStart; y = yStart;//links oben
        while (x > 0 && y > 0)
            aktion(--x, --y);

        x = xStart; y = yStart;//rechts unten
        while (x < brettGröße - 1 && y < brettGröße - 1)
            aktion(++x, ++y);

        x = xStart; y = yStart;//links unten
        while (x > 0 && y < brettGröße - 1)
            aktion(--x, ++y);

        x = xStart; y = yStart;//rechts oben
        while (x < brettGröße - 1 && y > 0)
            aktion(++x, --y);
    }
}

string s = Encoding.Unicode.GetString(BitConverter.GetBytes(15481342765760561ul));

public class MillerRabin
    {

        int w; // Zeugen
        int zahl;
        string bin;
        int t;

        public MillerRabin(int zahl, int durchlaeufe)
        {
            if (zahl % 2 == 0 || durchlaeufe < 1 || zahl < 2)
            {
                throw new ArgumentException();
            }
            w = durchlaeufe;
            this.zahl = zahl;
        }

        //Startet den Algorithmus
        public bool Start()
        {
             if (zahl != 0)
             {
             return miller_rabin(zahl, w);
             }
             throw new ArgumentException();
        }

        //Hauptmethode
        private bool miller_rabin(int n, int s)
        {
            int r;
            bool prime = true;
            Random rand = new Random();
            for (w = 1; w < s + 1; w++)
            {
                r = rand.Next(2, n);
                if (witness(r, n))
                {
                    prime = false;
                    break;
                }
            }
            return prime;
        }

        // Konvertiert eine Zahl zu einem Binärstring
        private void IntToBinary(int B)
        {
            bin = Convert.ToString(B, 2);
        }


       private int modular_exponentiation(int a, int u, int n)
        {

            int c = 0;
            int d = 1;

            // Sei {b[0],b[1],...,b[k-1],b[k]} die binäre Darstellung von b
            if (w == 1) IntToBinary(u);
            // Da für alle Zeugen gleich, nur einmal berechnen

            for (int i = 0; i < bin.Length; i++)
            {

                c *= 2;
                d = (int)Math.Pow(d, 2) % n;

                if (bin[i] == '1')
                {
                    c += 1;
                    d = (d * a) % n;
                }
            }

            return d;
        }

        private bool witness(int a, int n)
        {
            int N_1 = n - 1;

            if (w == 1) while ((N_1 / (int)(Math.Pow(2, t)) % 2) == 0) t++;
            // Da für alle Zeugen gleich, nur einmal berechnen

            int u = N_1 / (int)Math.Pow(2, t);

            int x0;
            int x1 = modular_exponentiation(a, u, n); 

            for (int i = 1; i < t + 1; i++)
            {
                x0 = x1;
                x1 = (int)Math.Pow(x0, 2) % n;
                if (x1 == 1 && x0 != 1 && x0 != N_1)
                    return true;
            }
            return x1 != 1;
        }
    }

        static void Main(string[] args)
        {
            while (true)
            {
                Console.Write("Zahl eingeben (ungültige Eingabe für Abbruch!): ");
                string input = Console.ReadLine();
                int zahl;
                if (!int.TryParse(input, out zahl) || zahl < 1 || zahl % 2 == 0)
                {
                    Console.WriteLine("Ungültige Eingabe! Zahl muss größer 0 sein und ungerade sein!");
                    Console.ReadLine();
                    return;
                }
                if (zahl < 4)
                {
                    Console.WriteLine("Zahl ist prim!");
                }
                else
                {
                    MillerRabin mr = new MillerRabin(zahl, 20);

                    Console.WriteLine("Zahl ist{0} prim!", mr.Start() ? "" : " nicht");
                }
            }
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConwaysGameOfLife
{
  class Program
  {
    public bool Abort { get; set; }
    private bool[,] map;
    private int amount, sleeptime;
    private Thread t;

    static void Main(string[] args)
    {
      Program p = new Program();
      p.Start();
      Console.ReadLine();
      p.Abort = true;
    }

    public void Start()
    {
      do {
        Console.WriteLine("Bitte geben Sie die Zeit in ms zwischen den Generationen an.");
      } while (!Int32.TryParse(Console.ReadLine(), out sleeptime)
        || sleeptime < 1);
      do {
        Console.WriteLine("Bitte geben Sie die Anzahl der Felder ein.");
      } while (!Int32.TryParse(Console.ReadLine(), out amount)
        || amount < 1 || amount > 39);

      map = new bool[amount, amount];

      Console.WriteLine("Wollen Sie die Felder selbst befüllen? (J/N)");
      if (Console.ReadLine().Equals("J", StringComparison.OrdinalIgnoreCase))
      {
        ReadCells();
      }
      else
      {
        RandomizeCells();
      }

      t = new Thread(new ThreadStart(Run));
      t.Start();
    }
    
    private void Run()
    {
      while (!Abort)
      {
        PrintMap();
        try
        {
          Thread.Sleep(sleeptime);
        }
        catch (Exception) { }
        CalculateLife();
      }
    }

    private void ReadCells()
    {
      Console.WriteLine("Bitte geben Sie die lebenden Zellen im Format 'x,y' an.");
      string line;
      do
      {
        line = Console.ReadLine();
        string[] elements = line.Split(',');
        if (elements.GetLength(0) == 2)
        {
          int x, y;
          if (Int32.TryParse(elements[0], out y)
            && Int32.TryParse(elements[1], out x))
          {
            if (x ≥ 0 && x < amount
              && y ≥ 0 && y < amount)
            {
              map[x, y] = true;
            }
            else
            {
              Console.WriteLine("Bitte geben Sie eine Zahl im gültigen Bereich ein.");
            }
          }
          else
          {
            Console.WriteLine("Bitte geben Sie eine Zahl ein.");
          }
        }
        else
        {
          Console.WriteLine("Bitte geben Sie die lebenden Zellen im Format 'x,y' an.");
        }
      } while (line != "");
    }

    private void RandomizeCells()
    {
      Random random = new Random();
      for (int i = 0; i < amount; ++i)
      {
        for (int j = 0; j < amount; ++j)
        {
          map[i, j] = random.Next(2) == 0;
        }
      }
    }

    private void PrintMap()
    {
      Console.Clear();
      for (int i = 0; i < map.GetLength(0); i++)
      {
        Console.WriteLine(new string('-', amount * 2 + 1));
        for (int j = 0; j < map.GetLength(1); j++)
        {
          Console.Write('|');
          Console.Write(map[i,j] ? (char)2 : ' ');
        }
        Console.WriteLine('|');
      }
      Console.Write(new string('-', amount * 2 + 1));
    }

    private void CalculateLife()
    {
      bool[,] newGen = new bool[amount, amount];

      for (int i = 0; i < amount; ++i)
      {
        for (int j = 0; j < amount; ++j)
        {
          int neighbors = GetNeighbors(i, j);
          if (neighbors < 2)
          {
            newGen[i, j] = false;
          }
          if (neighbors == 3)
          {
            newGen[i, j] = true;
          }
          if (neighbors == 2 && map[i, j])
          {
            newGen[i, j] = true;
          }
          if (neighbors > 3)
          {
            newGen[i, j] = false;
          }
        }
      }

      map = newGen;
    }

    private int GetNeighbors(int x, int y)
    {
      int count = 0;

      if (x != 0)
      {
        if (y != 0)
        {
          count += map[x - 1, y - 1] ? 1 : 0;
        }
        if (y != amount - 1)
        {
          count += map[x - 1, y + 1] ? 1 : 0;
        }
        count += map[x - 1, y] ? 1 : 0;
      }
      if (x != amount - 1)
      {
        if (y != 0)
        {
          count += map[x + 1, y - 1] ? 1 : 0;
        }
        if (y != amount - 1)
        {
          count += map[x + 1, y + 1] ? 1 : 0;
        }
        count += map[x + 1, y] ? 1 : 0;
      }
      if (y != 0)
      {
        count += map[x, y - 1] ? 1 : 0;
      }
      if (y != amount - 1)
      {
        count += map[x, y + 1] ? 1 : 0;
      }

      return count;
    }
  }
}

Console.WindowHeight
Console.WindowWidth