C# :: Aufgabe #303

6 Lösungen Lösungen öffentlich

Häufigkeit einer 6 beim Würfeln?!

Anfänger - C# von DragStar - 06.04.2020 um 08:34 Uhr
Verfassen Sie ein Programm, welches 25.000 mal, jeweils so lange das Würfeln mit einem Würfel simuliert, bis eine 6 erscheint.
Auszugeben ist, wie oft man dabei schlimmstenfalls würfeln musste.

Lösungen:

vote_ok
von JKooP (18090 Punkte) - 11.04.2020 um 19:14 Uhr
NET Core 3.x

Quellcode ausblenden C#-Code
using System;

namespace CS_Aufgabe_303_Wuerfeln
{
    class Program
    {
        static void Main(string[] args)
        {
            var counterMax = 0;
            var counter = 0;

            for (var i = 0; i < 25_000; i++)
            {
                if (new Random().Next(1, 7) != 6)
                    counter++;
                else
                {
                    if(counter > counterMax)
                        counterMax = counter;
                    counter = 0;
                }
            }

            Console.WriteLine($"Im schlimmsten Fall wurde {counterMax}x gewürfelt bis eine Sechs fiel.");
        }
    }
}
vote_ok
von Waldgeist (2310 Punkte) - 20.04.2020 um 15:14 Uhr
Hallo,

habe mir das auch mal programmiert.
Ist interessant da herum zu spielen.

Quellcode ausblenden C#-Code
using System;

namespace Aufgabe_303
{
    internal class Program
    {
        private static void Main(string[] args)
        {

                       
            int maximum = 1;
            int durchschnitt = 1;
            int totalzaehler = 0;
            int anzahl = 0;

            int wuerfeln()
            {
                Random rnd = new Random();
                int zufallszahl = rnd.Next(0, 7);
                return zufallszahl;
            }

                        
            Console.WriteLine("Hallo!  Wie viele Versuche wollen Sie machen?");
            anzahl = Convert.ToInt32(Console.ReadLine());

            for (int i = 0; i <= anzahl; i++)
            {
                int zaehler = 0;
                do
                {
                    zaehler += 1;
                } while (wuerfeln() != 6);

                totalzaehler += zaehler;

                if (zaehler > maximum)
                {
                    maximum = zaehler;
                }
            }
            durchschnitt = totalzaehler / anzahl;

            Console.WriteLine("Man muss man maximal {0} mal Würfeln bis eine 6 erscheint", maximum);
            Console.WriteLine("Der Durchschnitt beträgt {0} mal Würfeln", durchschnitt);
            Console.ReadKey();
         
        }
    }
}
vote_ok
von DavidDev024 (250 Punkte) - 20.04.2020 um 16:48 Uhr
Quellcode ausblenden C#-Code
using System;

namespace Wuerfel6
{
    class Program
    {
        private static Random rnd = new Random();
        static void Main(string[] args)
        {
            int count = 0;
            int maxCount = 0;

            for(int i = 0; i < 25000; i++)
            {
                if (Wuerfel())
                {
                    if (count > maxCount)
                        maxCount = count;

                    count = 0;
                    continue;
                }

                count++;
            }

            Console.Write("Maximale Anzahl die benoetigt wurde eine 6 zu wuerfeln: " + maxCount);
            Console.ReadKey();
        }

        private static bool Wuerfel()
        {
            int augenZahl = rnd.Next(1, 7);
            if (augenZahl == 6)
                return true;
            return false;
        }
    }
}
vote_ok
von soma (150 Punkte) - 20.04.2020 um 21:45 Uhr
Quellcode ausblenden C#-Code
using System;

namespace Wuerfeln
{
    class Program
    {
        static void Main(string[] args)
        {
            int zaehler;
            int ergebnis = 0;
            int anzahl = 0;
            Random rnd = new Random();

            for (int i = 1; i <= 25000; i++)
            {
                zaehler = 0;
                
                do
                {
                    ergebnis = (rnd.Next(1, 7));
                    zaehler++;
                }
                while (ergebnis != 6);
                
                if (zaehler > anzahl)
                {
                    anzahl = zaehler;
                }
            }
            Console.WriteLine(anzahl);
        }
    }
}
vote_ok
von krokiritter (220 Punkte) - 01.09.2020 um 11:13 Uhr
Quellcode ausblenden C#-Code
using System;
using System.Collections.Generic;
using System.Linq;

namespace Unlucky6
{
    class Program
    {
        static void Main(string[] args)
        {
            int counter = 0;
            int throws = 0;
            int currentThrow = 0;
            Random rnd = new Random();      //Initialisierung von Random
            List<int> tries = new List<int>();      //Erstellung einer Liste für die Maximalwürfe
            do
            {
                currentThrow = rnd.Next(1, 7);      //Random 1,7 bedeutet beginnend bei 1 und endet bei 6!
                throws++;                   //1 extra Wurf
                if (currentThrow == 6)      //Wenn eine 6 gewürfelt wurde
                {
                    tries.Add(throws);      //Hinzufügen wieviele Würfe --> Liste
                    throws = 0;             //Zurücksetzen von Wurf-Counter
                }
                counter++;                  //Allgemeiner Counter

            } while (counter < 25000);
            int max = tries.Max();          //Der größte Wert der Liste
            Console.WriteLine(max);         //Ausgabe
            Console.ReadKey();
        }
    }
}
vote_ok
von JKooP (18090 Punkte) - 24.10.2020 um 12:09 Uhr
// NET Core 3.x

Quellcode ausblenden C#-Code
using System;
using System.Linq;

namespace CS_Aufgabe_303_Wuerfeln_bis_zur_Sechs
{
    class Program
    {
        static void Main(string[] args)
        {
            var lst = Enumerable.Range(1, 25_000).Select(x => (x, new Random().Next(1, 7))).Where(x => x.Item2 == 6).Select(n => n.x).ToList();
            var max = Enumerable.Range(0, lst.Count - 1).Select(i => lst[i + 1] - lst[i]).Max();
            Console.WriteLine($"Im schlechtesten Fall wurde {max}x gewürfelt bis eine 6 fiel!");
        }
    }
}