1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

public int strasse(int[] wurf)    // Berechnet große Straße
{
    Array.Sort(wurf);
    int i, zaehler = 0, zahl = 4;

    for (i = 0; i < zahl; i++)
    {
        if ((wurf[i] + 1) != (wurf[i + 1]))
        return 0;
    }
    return zahl*10;
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

int c;
            
            Random rd = new Random();
            List<int> Zahlen = new List<int> {};
            for(c=0;c<=5;c++)
            {
              Zahlen.Add(rd.Next(1, 7));
                
            }
            Zahlen.Sort();

            int zaehler, i, altes_i, neues_i;
            zaehler = 1;

            for (i = 1; i < Zahlen.Count;i++ )
            {
                neues_i = Zahlen[i];
                altes_i = Zahlen[i-1];
                if (altes_i + 1 != neues_i)
                {
                    break;
                }
                zaehler++;
                if (zaehler == 4)
                {
                    Console.WriteLine("Es ist eine kleine Straße vorhanden");
                    //Mache irgendwas.
                    break;
                    
                }
            }
            if (zaehler != 4)
            {
                Console.WriteLine("Sie haben keine Straße gewürfelt");
            }
            
            Console.ReadLine();                    

1:
2:
3:
4:

if (altes_i + 1 != neues_i)
{
   break;
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:

public int strasse(int[] wurf, int zahl)    // Berechnet kleine,große Straße
{
    wurf[0] = 1;
    wurf[1] = 2;
    wurf[2] = 2;
    wurf[3] = 3;
    wurf[4] = 4;

    Array.Sort(wurf);
    int i, zaehler = 0;
    if (zahl == 3)
    {
        for (i = 0; i < 4; i++)
        {
            if (wurf[i] + 1 != wurf[i + 1])
                continue;
            zaehler++;
            if (zaehler == 3)
                return zahl * 10;
        }
        return 0;
    }
    else
    {
        for (i = 0; i < 4; i++)
        {
            if (wurf[i] + 1 != wurf[i + 1])
                return 0;
        }
        return zahl * 10;
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

    static int GetStreetNumber(int[] rolls)
    {
      int maxNumber = 1;
      int currentNumber = 1;
      for (int i = 1; i < rolls.Length; i++)
        switch (rolls[i] - rolls[i - 1]) {
          case 1:
            currentNumber++;
            break;
          case 0:
            break;
          default:
            maxNumber = Math.Max(maxNumber, currentNumber);
            currentNumber = 1;
            break;
        }

      return Math.Max(maxNumber, currentNumber);
    }                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

        public int GetStreetPoints(int[] rolls)
        {
            int result = 0, value = -100;
            foreach (int i in rolls.Distinct().OrderBy(n => n))
            {
                result = (value + 1 < i) ? ((result < 4) ? 1 : result) : result + 1;
                value = i;
            }
            return (result == 5) ? 40 : ((result == 4) ? 30 : 0);
        }                    

1:
2:
3:
4:
5:
6:

result = a ? b : c;
// entspricht;
if (a)
    result = b;
else
    result = c;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

         int zaehler, i, altes_i, neues_i;
            zaehler = 1;
             List<int> Zahlen = new List<int> {1,2,2,3,4 };

            for (i = 1; i < Zahlen.Count; i++)
            {
                neues_i = Zahlen[i];
                altes_i = Zahlen[i - 1];
                if ((altes_i + 1 != neues_i)&&(altes_i!=neues_i))
                {
                    break;
                }
                if (altes_i != neues_i)
                {
                    zaehler++;
                }
                    if (zaehler == 4)
                {
                    Console.WriteLine("Es ist eine kleine Straße vorhanden");
                    //Mache irgendwas.
                    break;
                }
            }
            if (zaehler != 4)
            {
                Console.WriteLine("Sie haben keine Straße gewürfelt");
            }                    

1:
2:
3:
4:
5:
6:
7:
8:

    static int GetStreetNumber(IEnumerable<int> rolls)
    {
      return
        rolls.Distinct().OrderBy(r => r)
        .Select((r, i) => r - i)
        .GroupBy(r => r)
        .Max(g => g.Count());
    }                    

1:
2:

let streetNo : int seq -> int =
    Seq.distinct >> Seq.sort >> Seq.mapi (-) >> Seq.countBy id >> Seq.map snd >> Seq.max                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

public int strasse(int[] wurf, int art)    // Berechnet kleine,große Straße
{
    wurf.Distinct();
    Array.Sort(wurf);
    int i, zaehler = 0;
    for (i = 0; i < 4; i++)
        zaehler = (wurf[i] + 1 < wurf[i + 1]) ? ((zaehler < 3) ? 0 : zaehler) : zaehler + 1
    return (art == 3) ? ((zaehler > 2) ? art * 10 : 0) : ((zaehler == 4) ? art * 10 : 0);
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

zaehler = (wurf[i] + 1 < wurf[i + 1]) ? ((zaehler < 3) ? 0 : zaehler) : zaehler + 1;
// das obere müsste das gleich wie das untere sein
if (wurf[i] + 1 < wurf[i + 1])  
{
    if (zaehler < 3)
        zaehler = 0;
}
else                         
    zaehler++;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

return (art == 3) ? ((zaehler > 2) ? art * 10 : 0) : ((zaehler == 4) ? art * 10 : 0);
// das obere müsste das gleich wie das untere sein
if (art == 3)
{
    if (zaehler > 2)
        return art * 10;
    else
        return 0;
}
else
{
    if (zaehler == 4)
        return art * 10;
    else
        return 0;
}