[naak2803]

Hej,
behöver lite hjälp med att skapa ett litet script i C# där man ska kunna generera en lista på 20 random siffor med minst 10 tal emallan.

ex.

randomsiffran blir 55
lägg den i listan

nästa randomsiffra blir 50
slumpa om så det minst skiljer sig +- 10 från nån annan siffra i listan
nya randomsiffra blir 84
lägg den i listan

gör om 20 gånger...

efter 20 gånger ska det finns 20 random siffror i listan där alla siffror har ett avstånd på minst +-10 tal emallan sig.

[Knockout]

int startnumber = 55;
Random rand = new Random((int)DateTime.Now.Ticks);
int RandomNumber = rand.Next(startnumber + 20, startnumber + 1000);

Nåt sånt borde väl funka.
Bara lägga det i någon loop för att få ut flera värden.

[naak2803]

Ursprungligen postat av Knockout

int startnumber = 55;
Random rand = new Random((int)DateTime.Now.Ticks);
int RandomNumber = rand.Next(startnumber + 20, startnumber + 1000);

Nåt sånt borde väl funka.
Bara lägga det i någon loop för att få ut flera värden.

hur menar du att den där skulle fungera? det finns inget som säger att två siffror inte får vara närmare än 10

[jayzee]

Alltid kul med starta dagen med en tankeställare

    class Program
    {
        static void Main(string[] args)
        {
            Random randomGenerator = new Random();
            List<int> numbersList = new List<int>();
            int generatedValue = 0;
            int maxValue = 300;
            bool passed = false;

            // main loop
            while (numbersList.Count != 20)
            {
                while (!passed)
                {
                    generatedValue = randomGenerator.Next(0, maxValue);
                    passed = !numbersList.Any(x => (x > (generatedValue - 10)) && (x < (generatedValue + 10)));
                }

                passed = false; // reset passed flag
                numbersList.Add(generatedValue);
            }

            // sort list in ascending order
            numbersList.Sort();

            // print-out
            foreach (int value in numbersList)
            {
                Console.WriteLine(value.ToString());
            }

            Console.ReadKey();
        }
    }

[naak2803]

tackar! var exakt det jag leta efter!

[Nerix]

Ursprungligen postat av jayzee

Alltid kul med starta dagen med en tankeställare

    class Program
    {
        static void Main(string[] args)
        {
            Random randomGenerator = new Random();
            List<int> numbersList = new List<int>();
            int generatedValue = 0;
            int maxValue = 300;
            bool passed = false;

            // main loop
            while (numbersList.Count != 20)
            {
                while (!passed)
                {
                    generatedValue = randomGenerator.Next(0, maxValue);
                    passed = !numbersList.Any(x => (x > (generatedValue - 10)) && (x < (generatedValue + 10)));
                }

                passed = false; // reset passed flag
                numbersList.Add(generatedValue);
            }

            // sort list in ascending order
            numbersList.Sort();

            // print-out
            foreach (int value in numbersList)
            {
                Console.WriteLine(value.ToString());
            }

            Console.ReadKey();
        }
    }

Bra lösning! Tänkte något liknande själv först. Tror dock att den ändrar sannolikhetsfördelning en del.

- Givet
- Vi slumpar en siffra mellan 0 och 99 (vi kallar maxvärdet x)
- Distributionen är uniform, det är alltså lika stor chans att få 1 som 10 (givet att x >= 10).
- Ett 'försök' nedan är ett anrop till 'randomGenerator.Next'.
- Vi vill hitta y siffror, te.x 5 och 15.

- Exempel:
- Försök 1: 0 returnerades. Ok
- 1 till 10 är nu inte längre giltiga nummer.
- Försök 2 till 10: De ogiltiga siffrorna 2 till 10 returnerades.
- Försök 11: 11 returnerades. Ok.

- Alltså:
- Vid försök 1 är sannolikheten att få 0: 1/100 (100 siffror totalt mellan 0 och 99)
- Chansen att få 11 är nu (10 / 100 - 1), alltså 11% då siffrorna 2 till 10 betyder att vi måste välja på nytt.
- Tredje gången: (20 / 100 - 2).
- Sista gången: 10 * (y - 1) / (x - y - 1)

Det är alltså större chans att få en senare vald siffra än en tidigare. Generellt sett skulle ja inte rekommendera den här metoden.