public static void Sort<T>(T[] items) where T : ICategorizable
        {
            int t = 0;
            T merke = items[0];
            for (int i = 1; i < items.Length; i++)
			{
			     if (items[i].Category < merke.Category)
	             {
                     items[t] =items[i];
                     items[i] = items[t+1];
                     items[t+1] = merke;
                     t++;
	             }
			}
        }

public static void Sort<T> (T [] items) where T : ICategorizable
{
   int lowerBorder = -1;
   int upperBorder = items.Length;
   for (int currentIndex = 0; currentIndex < upperBorder;) {
      switch (items [currentIndex].Category) {
         case Category.First: {
            Swap (items, currentIndex++, ++lowerBorder);
            break;
         }
         case Category.Second: {
            ++currentIndex;
            break;
         }
         case Category.Third: {
            Swap (items, currentIndex, --upperBorder);
            break;
         }
      }
   }
}

class Program
{
	static string inputFile = @"..\..\encrypted.txt";
	static int maxKeyLength = 20;

	[STAThread]
	static void Main(string[] args)
	{
		string encryptedText = null;
		using (StreamReader sr = new StreamReader(inputFile, System.Text.Encoding.Default))
		{
			encryptedText = sr.ReadToEnd();
		}

		Cracker cracker = new Cracker(encryptedText);
		int keyLength = cracker.GetKeyLength(maxKeyLength);
		string key = cracker.GetKey(keyLength);
		Console.WriteLine("KEYLENGTH: {0}", keyLength);
		Console.WriteLine("KEY:       {0}", key);
		Console.WriteLine();
		Console.WriteLine("Decrypted Text:\r\n{0}", DeCrypter.Decrypt(encryptedText, key));
		Clipboard.SetText(DeCrypter.Decrypt(encryptedText, key));

		Console.ReadLine();
	}
}

public static string Encrypt(string text,params int[] key)
{
	return Permute(text,key,true);
}

public static string Decrypt(string text,params int[] key)
{
	return Permute(text,key,false);
}

private static string Permute(string text,int[] key,bool useInvertedKey)
{
	StringBuilder stringBuilder = new StringBuilder(text.Length);

	int[] actualKey = (useInvertedKey) ? InvertKey(key) : key;
	for (int sequenceStart=0;sequenceStart≤text.Length-actualKey.Length;sequenceStart+=actualKey.Length)
		for (int sequenceOffset=0;sequenceOffset<actualKey.Length;sequenceOffset++)
			stringBuilder.Append(text[sequenceStart+actualKey[sequenceOffset]]);

	string remainingText = text.Substring(stringBuilder.Length);
	if (remainingText.Length>0)
	{
		int[] remainingKey = key.Where(value => value<remainingText.Length).ToArray();
		stringBuilder.Append(Permute(remainingText,remainingKey,useInvertedKey));
	}

	return stringBuilder.ToString();
}

private static int[] InvertKey(int[] key)
{
	return Enumerable.Range(0,key.Length).Select(i => Array.IndexOf(key,i)).ToArray();
}

public static void Main(string[] args)
{
	string text = @"...";

	var ratingFunctions = new Func<char,char,double>[]
	{
		// TODO: Bewertungsfunktion(en) für Buchstabenpaare
		// (firstChar,secondChar) => (true) ? 1 : 0,
		// (firstChar,secondChar) => (false) ? -1 : 0,
	};

	var keyKandidates = Enumerable.Range(1,30)
		.Select(length => GenerateKeyposBigramProbabilityMatrix(length,text,ratingFunctions))
		.SelectMany(matrix => GenerateKeys(matrix));

	foreach (int[] key in keyKandidates)
	{
		Debug.WriteLine(String.Join(",",key));
		Debug.WriteLine(Decrypt(text,key));
	}
}

private static double[,] GenerateKeyposBigramProbabilityMatrix(int keyLength,string text,IEnumerable<Func<char,char,double>> ratingFunctions)
{
	double[,] result = new double[keyLength,keyLength];

	// alle Varianten von aufeinanderfolgenden Schlüsselpositionen durchgehen
	for (int firstIdx=0;firstIdx<keyLength;firstIdx++)
		for (int secondIdx=0;secondIdx<keyLength;secondIdx++)
			if (firstIdx!=secondIdx)
			{
				// alle Buchstabenpaare für diese Schlüsselpositionen im Text suchen...
				for (int sequenceStart=0;sequenceStart≤text.Length-keyLength;sequenceStart+=keyLength)
				{
					char firstChar = text[sequenceStart+firstIdx];
					char secondChar = text[sequenceStart+secondIdx];
					// ... und bewerten
					foreach (var func in ratingFunctions)
						result[firstIdx,secondIdx] += func(firstChar,secondChar);
				}
			}

	return result;
}

private static IEnumerable<int[]> GenerateKeys(double[,] keyposBigramProbabilityMatrix)
{
   // TODO: Anhand der Wahrscheinlichkeitsmatrix die möglichen Schlüssel generieren
}

static string cryptedText = "...";

 static void Main(string[] args)
 {

	 Stopwatch stopwatch = new Stopwatch();
	 stopwatch.Start();

	 var ratingFunctions = new List<Func<char, char, double>>
	  {
		  { new Func<char, char, double>(Bigram) }
	  };

	 for (int i = 0; i < 30; i++)
	 {
		 int[] key;
		 if (FindKey(out key, GenerateKeyposBigramProbabilityMatrix(i, cryptedText, ratingFunctions)))
		 {
			 stopwatch.Stop();
			 Console.WriteLine(Decrypt(cryptedText, key));
			 Console.Write("Schlüssel: ");
			 foreach (int k in key)
				 Console.Write(k + " ");
			 Console.WriteLine();
			 Console.WriteLine("Benötigte Rechenzeit: " + stopwatch.ElapsedMilliseconds + " ms");

			 break;
		 }
	 }

	 Console.ReadKey();
 }

 // Gewichtete Häufigkeit von Buchstabenpaaren
 static Dictionary<string, double> bigramFrequenzy = new Dictionary<string, double>()
 {
	 {"EN",    3.97},
	 {"ER",    3.93},
	 {"CH",    2.70},
	 {"EI",    2.15},
	 {"DE",    2.04},
	 {"IN",    2.03},
	 {"TE",    1.86},
	 {"IE",    1.66},
	 {"UN",    1.35},
	 {"GE",    1.31},
	 {"ES",    1.30},
	 {"ST",    1.29},
	 {"ND",    1.25},
	 {"BE",    1.16},
	 {"AN",    1.13},
	 {"RE",    1.13},
	 {"NE",    1.08},
	 {"HE",    1.04},
	 {"IC",    1.00},
	 {"DI",    0.99}
 };
 static double Bigram(char c1, char c2)
 {
	 string bigram = String.Concat(c1, c2).ToUpper();
	 foreach (KeyValuePair<string, double> freq in bigramFrequenzy)
	 {
		 if (bigram == freq.Key)
			 return freq.Value;
	 }

	 return -1;
 }

 private static double[,] GenerateKeyposBigramProbabilityMatrix(int keyLength, string text, IEnumerable<Func<char, char, double>> ratingFunctions)
 {
	// ...siehe oben
 }

 private static bool FindKey(out int[] key, double[,] keyposBigramProbabilityMatrix)
 {
	 int keyLength = (int)Math.Sqrt(keyposBigramProbabilityMatrix.Length);

	 // Schlüsselläbge von 1 übergehen
	 if (keyLength == 1)
	 {
		 key = null;
		 return false;
	 }

	 List<int[]> candidateKey = new List<int[]>();
	 int lastDigitInKey = 0;

	 for (int i = 0; i < keyLength; i++)
	 {
		 // Durchschitt der Möglichkeiten für Nachfolger für aktuelle Stelle berechnen
		 Dictionary<int[], double> probDigit = new Dictionary<int[], double>();
		 double average = 0;
		 double max = double.MinValue;
		 int digit = 0;
		 int child = 0;

		 for (int j = 0; j < keyLength; j++)
		 {
			 if (keyposBigramProbabilityMatrix[i, j] != 0)
			 {
				 average += keyposBigramProbabilityMatrix[i, j];

				 if (keyposBigramProbabilityMatrix[i, j] > max)
				 {
					 max = keyposBigramProbabilityMatrix[i, j];
					 digit = i;
					 child = j;
				 }
			 }
		 }

		 average /= keyLength - 1;

		 // Größter statistischer "Außreißer" -> Postition gefunden
		 if (max * 1.5 > average)
		 {
			 candidateKey.Add(new int[] {digit, child});
		 }
		 else // Kein Außreißer: letzte Position oder falsche Position
			 lastDigitInKey = i;
	 }


	 // Schlüssel gefunden, zusammensetzen
	 if (candidateKey.Count + 1 == keyLength)
	 {
		 key = new int[keyLength];
		 key[0] = lastDigitInKey;
		 int curDigit = lastDigitInKey;

		 for (int k = 1; k < keyLength; k++)
		 {
			 curDigit = FindNextDigit(curDigit, candidateKey);
			 key[k] = curDigit;
		 }

		 Array.Reverse(key);
		 return true;
	 }

	 key = null;
	 return false;
 }

 static int FindNextDigit(int i, List<int[]> probDigits)
 {
	 foreach (int[] digits in probDigits)
	 {
		 if (i == digits[1])
			 return digits[0];
	 }

	 return 0;
 }

var ratingFunctions = new Func<char,char,double>[]
{
	// Abwertung, wenn ein Großbuchstabe auf einen Kleinbuchstaben folgt
	(firstChar,secondChar) => (Char.IsLower(firstChar) && Char.IsUpper(secondChar)) ? -1 : 0,
	// Aufwertung, wenn ein Großbuchstabe auf ein Leerzeichen folgt
	(firstChar,secondChar) => (Char.IsWhiteSpace(firstChar) && Char.IsUpper(secondChar)) ? 1 : 0, 
};

// ...

private static IEnumerable<int[]> GenerateKeys(double[,] keyposBigramProbabilityMatrix)
{
	for (int i=0;i<keyposBigramProbabilityMatrix.GetLength(0);i++)
		foreach (int[] key in GenerateKeys(keyposBigramProbabilityMatrix,new[] { i }))
			yield return key;
}

private static IEnumerable<int[]> GenerateKeys(double[,] keyposBigramProbabilityMatrix,int[] keyPrefix)
{
	int length = keyposBigramProbabilityMatrix.GetLength(0);

	int firstIdx = keyPrefix.Last();
	for (int secondIdx=0;secondIdx<length;secondIdx++)
		if (!keyPrefix.Contains(secondIdx))
			if (keyposBigramProbabilityMatrix[firstIdx,secondIdx]>0)
			{
				int[] newPrefix = keyPrefix.Concat(new[] { secondIdx }).ToArray();

				if (newPrefix.Length==length)
					yield return newPrefix;
				else
					foreach (int[] key in GenerateKeys(keyposBigramProbabilityMatrix,newPrefix))
						yield return key;
			}
}

        static long rnd = DateTime.Now.Ticks;

        static void Main(string[] args)
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(i + ": " + get_random);
            }
            Console.ReadLine();
        }

        static long get_random
        {
            get
            {
                rnd = (rnd * 110671L + 1263L) & 167215L;
                return rnd;
            }
        }

    public static uint Rnd(uint seed, int idx)
    {
      return idx < 0 ? seed : (253 * Rnd(seed, idx - 1) + 3) % 16777216;
    }

    public static void Main()
    {
      uint res;
      uint seed = 5;
      int lesser = 0;
      int greater = 0;
      int inner = 0;
      int max = 16777216;
      int interval = 100000;
      int i = 0;
      while(i < 100000)
      {
        res = Rnd(seed, i);
        if(res < interval)
        {
          lesser++;
        }
        if(res > max -interval)
        {
          greater++;
        }
        if((res > max/2 -interval/2) && (res < max/2 + interval/2))
        {
          inner++;
        }
        Console.CursorLeft = 0;
        Console.Write("i:{0} lesser:{1} inner:{2} greater:{3}", i, lesser, inner, greater);
        i++;
      }
      Console.WriteLine("done");
      Console.Read();
    }

static long x;
static long randLCM(long seed)
{
        return (x = (526 * ( seed != 0 ? x = seed : x) + 121441) % 7441875);
}

public enum NodeResult
{
  // normal weiterlaufen
  Continue,

  // Suchlauf abbrechen
  Exit,
  
  // im aktuellen Knoten enthaltene Objekte überspringen
  SkipContained,
  
  // Nachbarknoten des aktuellen Knotens überspringen
  SkipSiblings,

  // Kombination aus SkipContained und SkipSiblings
  SkipContainedAndSiblings,
}

public static class EnumerableSearchExtension
{
  public static NodeResult SearchAsTree(this IEnumerable root, Func<object, NodeResult> evaluateNode)
  {
    //*****************************
    //* hier eure Implementierung *
    //*****************************
  }
}

class TypeCounter
{
  Dictionary<Type, int> typeDict = new Dictionary<Type, int>();
  
  public void Print(string head)
  {
    Console.WriteLine();
    Console.WriteLine(head);
    Console.WriteLine("------------------");
    foreach(Type key in typeDict.Keys)
    {
      Console.WriteLine("{0}: {1}", key, typeDict[key]);
    }
  }
  
  public NodeResult ReInit(object o)
  {
    typeDict[o.GetType()] = 0;
    return NodeResult.Continue;
  }
  
  public NodeResult ContinueAll(object o)
  {
    typeDict[o.GetType()] ++;
    return NodeResult.Continue;
  }
  
  public NodeResult ExitOnInt3(object o)
  {
    NodeResult res = ContinueAll(o);
    return 3.Equals(o) ? NodeResult.Exit :res;
  }
  
  public NodeResult SkipContainedOfIntArray(object o)
  {
    NodeResult res = ContinueAll(o);
    return o is int[] ? NodeResult.SkipContained : res;
  }
  
  public NodeResult SkipSiblingsOfCharR(object o)
  {
    NodeResult res = ContinueAll(o);
    return 'r'.Equals(o) ? NodeResult.SkipSiblings : res;
  }
  
  public NodeResult SkipContainedAndSiblingsOfCharArray(object o)
  {
    NodeResult res = ContinueAll(o);
    return o is char[] ? NodeResult.SkipContainedAndSiblings : res;
  }
  
  public static void Main()
  {
    object[] root = { 
      new object(),
      new int[] { 1, 2, 3, 4 },
      new object(),
      new char[] { 's', 't', 'r', 'i', 'n', 'g' },
      new object() 
    };
    
    TypeCounter tc = new TypeCounter();
    
    root.SearchAsTree(tc.ReInit);
    root.SearchAsTree(tc.ContinueAll);
    tc.Print("ContinueAll");
    
    root.SearchAsTree(tc.ReInit);
    root.SearchAsTree(tc.ExitOnInt3);
    tc.Print("ExitOnInt3");
    
    root.SearchAsTree(tc.ReInit);
    root.SearchAsTree(tc.SkipContainedOfIntArray);
    tc.Print("SkipContainedOfIntArray");
    
    root.SearchAsTree(tc.ReInit);
    root.SearchAsTree(tc.SkipSiblingsOfCharR);
    tc.Print("SkipSiblingsOfCharR");
    
    root.SearchAsTree(tc.ReInit);
    root.SearchAsTree(tc.SkipContainedAndSiblingsOfCharArray);
    tc.Print("SkipContainedAndSiblingsOfCharArray");
    
    Console.Read();
  }
}

public static NodeResult SearchAsTree(this IEnumerable root, Func<object, NodeResult> evaluateNode)
        {
            Boolean skip = false;
            foreach (var child in root)
            {
                if (skip)
                {
                    //skip = false;
                    //continue;
                    break; // <-- Editiert!
                }
                NodeResult result = evaluateNode(child);

                if (result == NodeResult.Exit)
                    return NodeResult.Exit;

                if (result == NodeResult.SkipSiblings || result == NodeResult.SkipContainedAndSiblings)
                    skip = true;

                IEnumerable childNode = child as IEnumerable;
                if (childNode != null)
                {
                    if (result != NodeResult.SkipContained && result != NodeResult.SkipContainedAndSiblings)
                        if (childNode.SearchAsTree(evaluateNode) == NodeResult.Exit)
                            return NodeResult.Exit;
                }
            }

            return NodeResult.Continue;
        }

public class PushDownAutomaton
    {
        private Stack<String> stack = new Stack<String>();
        public State StartState;
        public List<State> FinalStates = new List<State>();

        public Boolean CheckWord(List<String> word)
        {
            stack.Clear();
            return StartState.ChangeState(word, 0, stack, FinalStates);
        }

    }

    // =================
    public class State
    {
        public List<Transition> Transitions = new List<Transition>();

        // input => Wort
        // index => Der aktuelle Buchstabe im Wort
        // stack => Der Stack
        // finalStates => Die Endzustände
        // Gibt <true> zurück, wenn das Wort abgearbeitet ist, der Stack leer ist und der letzte Zustand ein Endzustand war
        public Boolean ChangeState(List<String> input, Int32 index, Stack<String> stack, List<State> finalStates)
        {
              // Hier kommt euer Code hin
        }

    }

    // =================
    public class Transition
    {
        public String Input;
        public String OnStack;
        public List<String> Output = new List<String>();
        public State NextState;

        public readonly Boolean IsEpsilon;

        public Transition(String input, String onStack, State nextState, params String[] output)
        {
            Input = input;
            OnStack = onStack;
            NextState = nextState;

            IsEpsilon = String.IsNullOrEmpty(input);

            if (output != null)
                Output.AddRange(output);

        }

        // Überprüft, ob alle Bedingungen für den Zustandswechsel erfüllt sind.
        public Boolean CheckConditions(String input, Stack<String> stack)
        {
            if (String.IsNullOrEmpty(Input)) // Epsilonübergang
                //return Peek(OnStack, stack); // FEHLER BEHOBEN!!!
                return true;
            else // Normaler Übergang
                return Input == input && Peek(OnStack, stack);
        }

        // Kleine Hilfsmethode 
        private static Boolean Peek(String str, Stack<String> stack)
        {
            // Auf dem Stack darf nichts liegen, wenn <str> leer ist
            if (String.IsNullOrEmpty(str))
                return stack.Count == 0;

            // Ist <str> nicht leer, dann muss <str> auf dem Stack liegen
            return stack.Count > 0 && stack.Peek() == str;
        }
    }