Generieren unterschiedliche zufällige zahlen in C#

Nur Fragen, ob Sie bestätigen könnten, dass der folgende code ist gültig und zu beraten, wenn es bessere alternativen gibt?

Ich bin versucht zu generieren, die eine Sammlung von unterschiedlichen Zufallszahlen zwischen 1 und 100000.

Random rand = new Random();
List<Int32> result = new List<Int32>();
for (Int32 i = 0; i < 300; i++)
{
    Int32 curValue = rand.Next(1, 100000);
    while (result.Exists(value => value == curValue))
    {
        curValue = rand.Next(1, 100000);
    }
    result.Add(curValue);
}

InformationsquelleAutor der Frage Maxim Gershkovich | 2011-04-06

algorithm c#code-review predicate random

Ja, soweit ich das beurteilen kann, der code macht genau das, was Sie wollen.

Schleife durch die Liste, um zu überprüfen, jeder Wert ist nicht sehr effizient. Sie können die Werte in einem HashSet<int> zu beschleunigen, die ckeck.

Als die HashSet nicht beibehalten die Reihenfolge der Elemente, müssen Sie noch die List obwohl:

Random rand = new Random();
List<int> result = new List<int>();
HashSet<int> check = new HashSet<int>();
for (Int32 i = 0; i < 300; i++) {
    int curValue = rand.Next(1, 100000);
    while (check.Contains(curValue)) {
        curValue = rand.Next(1, 100000);
    }
    result.Add(curValue);
    check.Add(curValue);
}

InformationsquelleAutor der Antwort Guffa

5

Nicht, dass es viel aus, wenn Sie nur gelegentlich brauchen 300 zahlen, aber es wäre effizienter zu nutzen, HashSet, die nicht o(1) - lookups statt o(n) mit der Liste
```
Random rand = new Random();
HashSet<int> result = new HashSet<int>();
while (result.Count < 300)
{
    result.Add(rand.Next(1, 1000000));
}
```
InformationsquelleAutor der Antwort Ghostrider
4

Re-use Mann. Nachdem was Sie tun möchten, ist eine Sammlung von numebers (Enumerable.Bereich tun wird), die zweite Sache, ist das mischen (willkürlich) diese zahlen. Finden Sie Antwort auf dieses problem, auf SO, und Dank LINQ-Lösung ist schön, aber vielleicht nicht die Schnellste, trotzdem benutze ich es, weil ich mag die Schönheit.

Linq mischen:
http://www.code56.com/2009/02/lets-do-some-shuffling.html (Toter link).
Sehr ähnliche Umsetzung: http://csharpsimple.blogspot.com/2012/01/shuffle-in-linq-part-2.html

Kurz:
```
var rand = new Random();
        return source.Select(t => new {
                Index = rand.Next(),
                Value = t })
            .OrderBy(p => p.Index)
            .Select(p => p.Value);
```
InformationsquelleAutor der Antwort greenoldman
2

Dies zu tun, was Sie wollen, es sei denn, dass zu werfen, eine Zahl, weil Sie es vorher gesehen habe, reduziert die Entropie (Zufälligkeit) der Sequenz.

InformationsquelleAutor der Antwort Andrew Cooper

Deine version funktioniert, was ich Vorschlage, ist nur eine fun-alternative:

List<Int32> result = new List<Int32>();
Queue<int> working = new Queue<int>(new int[2] {1, 100000});
Random rand = new Random();

while (result.Count < 300) {
    int lower = working.Dequeue();
    int upper = working.Dequeue();
    int pivot = rand.Next(lower,upper);
    result.Add(pivot);
    if(lower < pivot) { working.Enqueue(lower); working.Enqueue(pivot); }
    if(pivot+1 < upper) { working.Enqueue(pivot + 1); working.Enqueue(upper); }
}

InformationsquelleAutor der Antwort Jeff Meatball Yang

2

In solchen Fällen denke ich immer, dass Sie nicht wirklich brauchen random zahlen. Stattdessen, Sie sind mehr going to shuffle einige der vorhandenen Nummern.

Also, was über den Bereich, den Sie gerne mit etwas wie var range = Enumerable.Range(1, 100000)mische Sie und nehmen Sie die Anzahl der Elemente, die Sie brauchen, indem Sie so etwas wie range.ToArray().Shuffle().Take(300)?

Einer Umsetzung des shuffle Algorithmus -finden Sie hier. Ich weiß, es ist nicht eine Erweiterung Methode, die verwendet werden können, wie oben beschrieben, aber die änderung der Signatur ist ganz einfach.

InformationsquelleAutor der Antwort Oliver

Wenn Sie bereit sind, eine up-front-Treffer zu pre-erstellen Sie eine Liste von 100.000 ints, diese Methode ist sehr schnell:

static IList<int> GetRandoms(int[] sample)
{
    var rand = new Random();
    var result = new int[300];
    var count = sample.Length;

    for (int i = 0; i < 300; i++)
    {
        var index = rand.Next(count);
        result[i] = sample[index];
        sample[index] = sample[--count];
    }
    return result;
}

Also man würde es so nennen:

var sample = Enumerable.Range(1, 100000).ToArray();
var data = GetRandoms(sample);

InformationsquelleAutor der Antwort Matt Hamilton

Änderte meine schlampige Antwort!

var result = new HashSet<int>();
var random = new Random();
var seq = Enumerable.Range(1, 30).GetEnumerator();
while(seq.MoveNext()) {
  while(!result.Add(random.Next(1, 100000)));
}

InformationsquelleAutor der Antwort James Kyburz

1

Ich weiß, dies ist eine wirklich alte post aber, in meinem letzten Erlebnis mit dem Gedanken, etwas entlang den gleichen Linien (ich hatte zu generieren 100k random Dokument-Id 's mit fremde Id' s, in welcher beide hatten eindeutig sein, Listen von #'s).

Es zu beschleunigen möchten Sie vielleicht, um multithread-es eine parallele.wenn ja,können Sie nicht verwenden ein hashset. Stattdessen verwenden Sie eine where-byte wird nur sein, Z. B. concurrentdictionary von <int,byte - > wo das byte wird ein 'new byte()'

nahm der Laufzeit von ~1.5 Stunden, um die etwa 20 Minuten für mich. Wenn es sein muss, würde ich vorschlagen, mit einer linkedList speichern, anstatt einer Warteschlange oder Liste, es sei denn, Sie haben eine spezifische Notwendigkeit für wahlfreien Zugriff.

InformationsquelleAutor der Antwort Jeremy Little

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.