public static void Main(string[] args)
		{
			var matrix = new List<List<double>> {
				new List<double> { 1.0, 1.1, 1.2, 1.3 },
				new List<double> { 2.0, 2.1, 2.2, 2.3 },
				new List<double> { 3.0, 3.1, 3.2, 3.3 },
				new List<double> { 4.0, 4.1, 4.2, 4.3 }
			};
			
			var sentence = "Dies ist ein Beispielsatz";
			
			var iter = matrix.Machwas(...);
			
			var iter2 = sentence.Machwas(...);
				
			foreach( var item in iter ) {
				Console.WriteLine( item );
			}
			
			Console.WriteLine("\n");
			
			foreach( var item in iter2 ) {
				Console.WriteLine( item );
			}
		}

public static void Main (string[] args)
		{
			
			var matrix = new List<List<double>> {
                new List<double> { 1.0, 1.1, 1.2, 1.3 },
                new List<double> { 2.0, 2.1, 2.2, 2.3 },
                new List<double> { 3.0, 3.1, 3.2, 3.3 },
                new List<double> { 4.0, 4.1, 4.2, 4.3 }
            };

            var sentence = "Dies ist ein Beispielsatz";

            var iter = matrix.MachWas(matrixFunc);

            var iter2 = sentence.MachWas(stringFunc);

            foreach( var item in iter ) {
                Console.WriteLine( item );
            }

            Console.WriteLine("\n");

            foreach( var item in iter2 ) {
                Console.WriteLine( item );
            }
		}
		
		public static IList<String> matrixFunc(IEnumerable list) {
			if(!(list is List<List<double>>)) {
				throw new ArgumentException("Expected List<List<double>>.");
			}
			List<List<double>> l = (List<List<double>>)list;
			IList<String> tmp = new List<String>();
			for(int i = 0; i < l[0].Count; i++) {
				for(int j = 0; j < l.Count; j++) {
					tmp.Add(l[j][i].ToString(CultureInfo.CreateSpecificCulture("de-DE")));
				}
			}
			
			return tmp;
		}
		
		public static IList<String> stringFunc(IEnumerable str) {
			if(!(str is String)) {
				throw new ArgumentException("Expected string");
			}	
			return ((String)str).Split(' ');
		}
		
		public static IList<String> MachWas(this IEnumerable obj, Func<IEnumerable, IList<String>> f) {
			return f(obj);
		}

			var iter3 = 1.Machwas(...)
				
			foreach( var item in iter3 ) {
				Console.WriteLine( item );
			}

public static void Main (string[] args)
		{
			
			var matrix = new List<List<double>> {
                new List<double> { 1.0, 1.1, 1.2, 1.3 },
                new List<double> { 2.0, 2.1, 2.2, 2.3 },
                new List<double> { 3.0, 3.1, 3.2, 3.3 },
                new List<double> { 4.0, 4.1, 4.2, 4.3 }
            };

            var sentence = "Dies ist ein Beispielsatz";

            var iter = matrix.MachWas((List<List<double>> l ) => {
				IList<double> tmp = new List<double>();
				for(int i = 0; i < l[0].Count; i++) {
					for(int j = 0; j < l.Count; j++) {
						tmp.Add(l[j][i]);
					}
				}
				return tmp;	});
			
			
			
            var iter2 = sentence.MachWas((string s) => { return s.Split(' '); });

            foreach( var item in iter ) {
                Console.WriteLine( item );
            }

            Console.WriteLine("\n");

            foreach( var item in iter2 ) {
                Console.WriteLine( item );
            }
		}
		
		public static TReturn MachWas<TReturn, T>(this T obj, Func<T, TReturn> f) {
			return f(obj);
		}

public static IEnumerable<TItem>
			MakeCustomIterator<TCollection, TCursor, TItem>(
				this TCollection collection,
				TCursor cursor,
				Func<TCollection, TCursor, TItem> getCurrent,
				Func<TCursor, bool> isFinished,
				Func<TCursor, TCursor> advanceCursor) {
					while( !isFinished(cursor) ) {
						yield return getCurrent( collection, cursor );
						cursor = advanceCursor( cursor );
					}
				}

var iter = matrix.MakeCustomIterator(
				// Cursor zum Merken der Position
				new int[] { 0, 0, int.MaxValue},
				// Aktuelles Element zurückgeben
				(coll, cur) => {
					cur[2] = coll.Count;
					return coll[cur[0]][cur[1]];
				},
				// Prüfen ob fertig
				(cur) => cur[0] ≥ cur[2] || cur[1] ≥ cur[2],
				// Nächstes Element wählen
				(cur) => { 
					if(++cur[0] ≥ cur[2]){
						cur[0] = 0;
						cur[1]++;
					}
					return new int[] { cur[0],cur[1],cur[2]};
				});
			
			var iter2 = sentence.MakeCustomIterator(
				// Cursor zum Merken der Position
				new int[] { 0, 0, int.MaxValue },
				// Aktuelles Element zurückgeben
				(coll, cur) => {
					cur[2] = coll.Length;
					var idx = coll.IndexOf(" ",cur[1]);
					return coll.Substring(cur[0],(cur[1] = idx > -1 ? idx : coll.Length)-cur[0]);
				},
				// Prüfen ob fertig
				(cur) => cur[1] ≥ cur[2],
				// Nächstes Element wählen
				(cur) => {
					return new int[] { cur[0]=++cur[1], cur[1], cur[2]};
				}
			);
			
			var iter3 = 1.MakeCustomIterator(
				// Cursor zum Merken der Position
				new int[] {1},
				// Aktuelles Element zurückgeben
				(coll, cur) => coll*cur[0],
				// Prüfen ob fertig
				cur => cur[0] > 10,
				// Nächstes Element wählen
				cur => new int[] { ++cur[0]} );

using System;
using System.Numerics;
using System.IO;
using System.Linq;

public class LeastCommonMultiple
{
	public static void Main()
	{
		Console.Write(
			File
			.ReadAllLines("numbers.txt")
			.Select(s => BigInteger.Parse(s))
			.Aggregate((oldLCM, nextNumber) => 
				(oldLCM * nextNumber) / BigInteger.GreatestCommonDivisor(oldLCM, nextNumber)
			)
		);
	}
}

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Modus: "+(IntPtr.Size*8)+"bit");
            // Zahlen Array erzeugen und im Speicher festpinnen
            int[] numberArray = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
            GCHandle gch = GCHandle.Alloc(numberArray, GCHandleType.Pinned);

            // Aufruf der magischen Funktion, die ein .NET Array erzeugt,
            // das ein reales Unter-Array ist
            int[] subArray = SubArrayMaker.GetSubArray(numberArray);

            // Sicherstellen, dass das Array an Position 5 und 6 noch intakt ist.
            if (numberArray[5] != 5 || numberArray[6] != 6)
                return;

            // das Unter-Array komplett mit Nullen füllen
            lock (subArray) // nur aus Spaß gelockt, ihr seht schon warum ;)
                Array.Clear(subArray, 0, subArray.Length);

            // Überprüfen ob die 5te Stelle nun 0 ist, aber die 6te noch unverändert
            if (numberArray[5] == 0 && numberArray[6] == 6)
                Console.WriteLine("SUCCESS");

            Console.ReadLine();
        }
    }

    public class SubArrayMaker
    {
        delegate IntPtr pRefToPtr(ref object reference);
        static pRefToPtr RefToPtr=MakeRefToPtr();

        private static pRefToPtr MakeRefToPtr()
        {
            DynamicMethod meth = new DynamicMethod("GetAddr", typeof(IntPtr), new Type[1] { typeof(object).MakeByRefType() },typeof(SubArrayMaker),true);
            ILGenerator gen= meth.GetILGenerator();
            gen.Emit(OpCodes.Ldarg_0);
            gen.Emit(OpCodes.Conv_I);
            gen.Emit(OpCodes.Ret);
            return (pRefToPtr)meth.CreateDelegate(typeof(pRefToPtr));
        }

        struct ArrayHeader
        {
            public IntPtr Syncblock1;
            public IntPtr TypeId;
            public IntPtr Length;
        }

        public static unsafe int[] GetSubArray(int[] numberArray)
        {
            ArrayHeader* oldArray = &(((ArrayHeader*)Marshal.UnsafeAddrOfPinnedArrayElement(numberArray, 0))[-1]);
            ArrayHeader* newArray=&(((ArrayHeader*)Marshal.UnsafeAddrOfPinnedArrayElement(numberArray, 5))[-1]);
            *newArray = *oldArray;
            newArray->Length = (IntPtr)1;

            object array = null;
            IntPtr* pArrayVar = ((IntPtr*)RefToPtr(ref array));
            *pArrayVar = (IntPtr)(&(newArray->TypeId));
            return (int[])array;
        }
    }

public class SubArrayMaker
{
    public unsafe static int[] GetSubArray(int[] array)
    {
        fixed (int* ptr = array)
        {
            ptr[0] = 0;         // SyncBlock
            ptr[1] = ptr[-2];   // TypeInformation übernehmen
            ptr[2] = 3;         // Length

            return ConvertPointerToIntArrayReference(ptr + 1); 
        }
    }

    [StructLayout(LayoutKind.Sequential)]
    unsafe struct IntArrayHolder
    {
        public int[] array;
        public int* ptr;
    }

    unsafe static int[] ConvertPointerToIntArrayReference(int* ptr)
    {
        IntArrayHolder ah = new IntArrayHolder();
        (&ah.ptr)[-1] = ptr; // Referenz überschreiben
        return ah.array;
    }
}

public enum Scores
{
   Ones,            // Sum of Ones
   Twos,            // Sum of Twos
   Threes,          // Sum of Threes
   Fours,           // Sum of Fours
   Fives,           // Sum of Fives
   Sixes,           // Sum of Sixes
   ThreeOfAKind,    // Sum of all dice
   FourOfAKind,     // Sum of all dice
   FullHouse,       // 25
   SmallStraight,   // 30
   LargeStraight,   // 40
   Yahtzee,         // 50
   Chance           // Sum of all dice
}

public static int [] GetPoints (int [] dice)

public static void Main (string [] astrArg)
{
   Random rand = new Random ();

   int [] dice = new int [5];

   for (int i = 0; i < dice.Length; ++i) {
      dice [i] = rand.Next (6); // also Werte von einschließlich 0 bis einschließlich 5
   }

   int [] points = GetPoints (dice);

   foreach (Scores score in Enum.GetValues (typeof (Scores))) {
      Console.WriteLine ("{0,15} {1}", score, points [(int)score]);
   }
}

public static int [] GetPoints (int [] dice)  {
    int[] result = new int[Enum.GetValues(typeof(Scores)).Length];

    var getCount = new Func<int, int>((i) => dice.Where((d) => d == dice[i]).Count());

    Array.Sort(dice);

    result[(int)Scores.Ones] = dice.Where((d) => d == 0).Count() * 1;
    result[(int)Scores.Twos] = dice.Where((d) => d == 1).Count() * 2;
    result[(int)Scores.Threes] = dice.Where((d) => d == 2).Count() * 3;
    result[(int)Scores.Fours] = dice.Where((d) => d == 3).Count() * 4;
    result[(int)Scores.Fives] = dice.Where((d) => d == 4).Count() * 5;
    result[(int)Scores.Sixes] = dice.Where((d) => d == 5).Count() * 6;
    result[(int)Scores.ThreeOfAKind] = getCount(0) ≥ 3 || getCount(2) ≥ 3 || getCount(4) ≥ 3 ? dice.Sum((d) => d + 1) : 0;
    result[(int)Scores.FourOfAKind] = getCount(0) ≥ 4 || getCount(4) ≥ 4 ? dice.Sum((d) => d + 1) : 0;
    result[(int)Scores.FullHouse] = result[(int)Scores.ThreeOfAKind] > 0 ? (getCount(0) == 2 || getCount(4) == 2 ? 25 : 0) : 0;

    bool largeStraight = true;
    var num = dice[0];

    for (int i = 0; i < 5; i++) {
        largeStraight = largeStraight && (dice[i] == i + num);
    }

    result[(int)Scores.LargeStraight] = largeStraight ? 40 : 0;

    bool smallStraight = false;
    var arr = dice.Distinct().ToArray();

    if (arr.Length ≥ 4) {
        var slice = arr.Take(4).ToArray();
        
        num = slice[0];
        smallStraight = true;

        for (int i = 0; i < 4; i++) {
            smallStraight = smallStraight && (slice[i] == i + num);
        }
        
        if (!smallStraight && arr.Length == 5) {
            slice = arr.Skip(1).ToArray();
            smallStraight = true;
            num = slice[0];

            for (int i = 0; i < 4; i++) {
                smallStraight = smallStraight && (slice[i] == i + num);
            }
        }
    }

    result[(int)Scores.SmallStraight] = smallStraight ? 30 : 0;
    result[(int)Scores.Yahtzee] = getCount(0) == 5 ? 50 : 0;
    result[(int)Scores.Chance] = dice.Sum((d) => d + 1);

    return result;
}

   public static int [] GetPoints (int [] dice)
   {
      int [] diceCounts = new int [6];
      int [] points = new int [Enum.GetValues (typeof (Scores)).Length];
      int    sumOfAllDice = 0;
      int    straight = 0;
      int    maxStraight = 0;
      bool   full = false;
      bool   house = false;

      for (int i = 0; i < dice.Length; ++i) {
         ++diceCounts [dice [i]];
         sumOfAllDice += dice [i] + 1;
      }

      for (int i = 0; i < diceCounts.Length; ++i) {
         points [i] = diceCounts [i] * (i + 1);
         if (diceCounts [i] > 0) { ++straight; }
         else { if (straight > maxStraight) { maxStraight = straight; } straight = 0; }
         if (diceCounts [i] == 2) { full = true; }
         if (diceCounts [i] ≥ 3) { points [(int)Scores.ThreeOfAKind] = sumOfAllDice; house = true; }
         if (diceCounts [i] ≥ 4) { points [(int)Scores.FourOfAKind] = sumOfAllDice; }
         if (diceCounts [i] ≥ 5) { points [(int)Scores.Yahtzee] = 50; points [(int)Scores.FullHouse] = 25; }
      }
      if (full && house) { points [(int)Scores.FullHouse] = 25; }
      if (straight > maxStraight) { maxStraight = straight; }
      if (maxStraight ≥ 4) { points [(int)Scores.SmallStraight] = 30; }
      if (maxStraight ≥ 5) { points [(int)Scores.LargeStraight] = 40; }
      points [(int)Scores.Chance] = sumOfAllDice;

      return points;
   }

using System;
using System.Text;

public class Compression
{
    public static void Main() {
        string input = /*Gekürzt! Siehe Anhang!*/"";
        byte[] uncompressed = Encoding.ASCII.GetBytes(input);
        byte[] compressed = Compress(uncompressed);
        byte[] decompressed = Decompress(compressed);
        string output = Encoding.ASCII.GetString(decompressed);
        double ratio = (1d - (double)compressed.Length / (double)uncompressed.Length) * 100;
        bool equal = input == output;
        bool success = ratio > 10d && equal;
        
        Console.WriteLine("Uncompressed Length: {0}", uncompressed.Length);
        Console.WriteLine("Compressed Length: {0}", compressed.Length);
        Console.WriteLine("Decompressed Length: {0}", decompressed.Length);
        Console.WriteLine("Compression Ratio: {0:0.0000}%", ratio);
        Console.WriteLine("Input equals output: {0}", equal);
        Console.WriteLine("Successful: {0}", success);
        
        Console.ReadKey(true);
    }
    
    public static byte[] Compress(byte[] input) {
        // Hier der Kompressions-Algorithmus
    }
    
    public static byte[] Decompress(byte[] input) {
       // Hier der Dekompressions-Algorithmus
    }
}