リストをランダム化する<T>


855

C#でジェネリックリストの順序をランダム化する最良の方法は何ですか?宝くじタイプのアプリケーション用にそれらを描画するために、ランダムな順序を割り当てたいリストに75の有限セットがあります。


3
この機能を.NETに統合するための未解決の問題があります:github.com/dotnet/corefx/issues/461
Natan

5
このNuGetパッケージに興味があるかもしれません。このパッケージには、以下で説明するフィッシャーイェーツアルゴリズムを使用してIList <T>とIEnumerable <T>をシャッフルするための拡張メソッドが含まれています
ChaseMedallion

3
@ナタンは、誰かが「多くのプロジェクトに取り組み、多くのライブラリを開発し、そのような方法を必要としたことがなかった」ために問題を解決しました。今、私たちは自分自身を調査し、最良の実装を探し、時間を無駄にして、車輪を再発明する必要があります。
Vitalii Isaenko

1
私はこれを正しく見ていますか?10年後に有効な機能的な答えは1つではありませんか?たぶん、75の数値を持つリストをシャッフルする$ log2(75!)= 364 $と、これをどのように得ることができるかについて、必要なエントロピーの量に対処するソリューションのための別の賞金が必要かもしれません。fisher-yatesのシャッフル中に、少なくとも1回は256ビットのエントロピーを持つ暗号で保護されたRNGでも再シードする必要があります。
Falco

1
そして、通常のコーダーがこの問題を解決できない場合、私たちは皆、可能な限り同じソリティアゲームの0.01%を永遠にプレイしてきましたか?
Falco

回答:


1137

フィッシャーイェーツのシャッフルに(I)List基づく拡張メソッドを使用して、任意のものをシャッフルします。

private static Random rng = new Random();  

public static void Shuffle<T>(this IList<T> list)  
{  
    int n = list.Count;  
    while (n > 1) {  
        n--;  
        int k = rng.Next(n + 1);  
        T value = list[k];  
        list[k] = list[n];  
        list[n] = value;  
    }  
}

使用法:

List<Product> products = GetProducts();
products.Shuffle();

上記のコードは、非常に批判されているSystem.Randomメソッドを使用してスワップ候補を選択しています。高速ですが、ランダムではありません。シャッフルでより良い品質のランダム性が必要な場合は、System.Security.Cryptographyの乱数ジェネレーターを次のように使用します。

using System.Security.Cryptography;
...
public static void Shuffle<T>(this IList<T> list)
{
    RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider();
    int n = list.Count;
    while (n > 1)
    {
        byte[] box = new byte[1];
        do provider.GetBytes(box);
        while (!(box[0] < n * (Byte.MaxValue / n)));
        int k = (box[0] % n);
        n--;
        T value = list[k];
        list[k] = list[n];
        list[n] = value;
    }
}

このブログ(WayBack Machine)簡単な比較ができます。

編集:数年前にこの回答を書いて以来、多くの人がコメントしたり、私に書いたりして、私の比較における大きなばかげた欠陥を指摘しています。彼らはもちろん正しいです。System.Randomが意図したとおりに使用されていれば、何も問題はありません。上記の最初の例では、Shuffleメソッド内でrng変数をインスタンス化します。これにより、メソッドが繰り返し呼び出されるかどうかの問題が発生します。以下は、今日ここ@westonからSOで受け取った本当に役立つコメントに基づいた修正済みの完全な例です。

Program.cs:

using System;
using System.Collections.Generic;
using System.Threading;

namespace SimpleLottery
{
  class Program
  {
    private static void Main(string[] args)
    {
      var numbers = new List<int>(Enumerable.Range(1, 75));
      numbers.Shuffle();
      Console.WriteLine("The winning numbers are: {0}", string.Join(",  ", numbers.GetRange(0, 5)));
    }
  }

  public static class ThreadSafeRandom
  {
      [ThreadStatic] private static Random Local;

      public static Random ThisThreadsRandom
      {
          get { return Local ?? (Local = new Random(unchecked(Environment.TickCount * 31 + Thread.CurrentThread.ManagedThreadId))); }
      }
  }

  static class MyExtensions
  {
    public static void Shuffle<T>(this IList<T> list)
    {
      int n = list.Count;
      while (n > 1)
      {
        n--;
        int k = ThreadSafeRandom.ThisThreadsRandom.Next(n + 1);
        T value = list[k];
        list[k] = list[n];
        list[n] = value;
      }
    }
  }
}

32
list.Countが> Byte.MaxValueの場合はどうなりますか?n = 1000の場合、255/1000 = 0です。したがって、box [0] <0は常にfalseであるため、doループは無限ループになります。
AndrewS

18
比較に欠陥があることを指摘したいと思います。ループ内で<code> new Random()</ code>を使用するのは問題であり、<code> Random </ code>のランダム性ではありません。説明
Sven

9
ランダムなインスタンスを内部で作成するのではなく、シャッフルメソッドに渡すことをお勧めします。連続して何度もシャッフルを呼び出す場合(たとえば、多数の短いリストをシャッフルする場合)は、リストがすべて同じようにシャッフルされるためです。方法(たとえば、最初の項目は常に位置3に移動されます)。
マークヒース

7
を作成Random rng = new Random();するだけstaticで、比較ポストの問題が解決します。後続の各呼び出しは、前の呼び出しから続くため、最後のランダムな結果になります。
ウェストン

5
#2、バイトの最大範囲が255であるため、Cryptoジェネレーターを備えたバージョンが機能するかどうかは明確ではないため、それより大きいリストは正しくシャッフルされません。
Mark Sowul 2013年

336

アイテムを完全にランダムな順序で並べ替えるだけでよい場合は(リスト内のアイテムを混合するためだけ)、GUIDでアイテムを並べ替えるこのシンプルで効果的なコードを使用します...

var shuffledcards = cards.OrderBy(a => Guid.NewGuid()).ToList();

40
GUIDはランダムではなく一意であることを意図しています。その一部はマシンベースであり、別の一部は時間ベースであり、ランダムなのはほんの一部です。blogs.msdn.com/b/oldnewthing/archive/2008/06/27/8659071.aspx
Despertar

99
これは素晴らしいエレガントなソリューションです。GUID以外のものでランダム性を生成したい場合は、他のもので注文してください。例:var shuffledcards = cards.OrderBy(a => rng.Next()); compilr.com/grenade/sandbox/Program.cs
grenade

20
いいえ。これは間違っています。「ランダムな順序付け」は完全にシャッフルではありません。バイアスを導入し、さらに悪いことに、無限ループに陥るリスクがあります
Vito De Tullio 2013

78
@VitoDeTullio:あなたは覚えていません。ランダム比較関数を提供すると、無限ループのリスクがあります。一貫した合計順序を生成するには、比較関数が必要です。ランダムなで結構です。GUIDがランダムであることが保証されていないため、この提案は間違っています。ランダムなキーでソートする手法が間違っているからではありません
Eric Lippert 2013

24
@Doug:NewGuid一意のGUIDを提供することのみを保証します。ランダム性は保証されません。一意の値を作成する以外の目的でGUIDを使用している場合、それは間違っています。
エリックリッペルト2013

120

ここにあるこの単純なアルゴリズムの不格好なバージョンすべてに少し驚いています。Fisher-Yates(またはKnuth shuffle)は少しトリッキーですが、非常にコンパクトです。なぜそれが難しいのですか?乱数ジェネレータがを含むかr(a,b)bを含まない場合に値を返すかを注意する必要があるからです。また、ウィキペディアの説明を編集して、人々が盲目的に疑似コードを追跡したり、バグを検出するのが困難になったりしないようにしています。.Netの場合、これ以上の手間をかけずにRandom.Next(a,b)bその数を除いた数を返します。C#/。Netに実装する方法は次のとおりです。

public static void Shuffle<T>(this IList<T> list, Random rnd)
{
    for(var i=list.Count; i > 0; i--)
        list.Swap(0, rnd.Next(0, i));
}

public static void Swap<T>(this IList<T> list, int i, int j)
{
    var temp = list[i];
    list[i] = list[j];
    list[j] = temp;
}

このコードを試してください


カードを交換できるように、rnd(i、list.Count)をrnd(0、list.Count)に変更する方が良いでしょうか?
ドーナツ2014

16
@Donuts-いいえ。そうする場合は、シャッフルにバイアスを追加します。
Shital Shah 2014

2
Swap <T>を別のメソッドに分離すると、tempに多くの不要なT割り当てが発生するように見えます。
クレイ

2
LINQはシャッフルのパフォーマンスを潜在的に低下させる可能性があると私は主張します。これは、特にコードが比較的単純であることを考えると、それを使用しない理由となるでしょう。
winglerw28

7
ときi = list.Count - 1、つまり最後の反復でrnd.Next(i, list.Count)は、iが返されます。したがってi < list.Count -1、ループ条件として必要です。まあ、あなたはそれを「必要とする」必要はありませんが、それは1回の繰り返しを節約します;)
ポッド

78

IEnumerableの拡張メソッド:

public static IEnumerable<T> Randomize<T>(this IEnumerable<T> source)
{
    Random rnd = new Random();
    return source.OrderBy<T, int>((item) => rnd.Next());
}

3
これは、スレッドセーフリストで使用されていても、スレッドセーフではないことに注意してください
BlueRaja-Danny Pflughoeft

1
この関数にlist <string>をどのように与えるのですか?
MonsterMMORPG 2013年

8
このアルゴリズムには2つの重要な問題があります。- OrderByQuickSortバリアントを使用して、(見かけ上はランダムな)キーでアイテムをソートします。QuickSortのパフォーマンスはO(N log N)です。対照的に、Fisher-YatesシャッフルはO(N)です。75要素のコレクションの場合、これは大した問題ではないかもしれませんが、大きなコレクションでは違いが顕著になります。
John Beyer 2013年

10
...- Random.Next()値の合理的な疑似ランダム分布を生成する可能性がありますが、値が一意であることは保証されませ。重複キーの確率は、Nが2 ^ 32 + 1に達したときに確実になるまで、Nとともに(非線形的に)増加します。クイックソートは安定ソート。したがって、複数の要素に偶然に同じ擬似ランダムインデックス値が割り当てられた場合、出力シーケンスでのそれらの順序は入力シーケンスと同じになります。したがって、バイアスが「シャッフル」に導入されます。OrderBy
John Beyer 2013年

27
@JohnBeyer:バイアスの原因よりもはるかに大きな問題があります。Randomに使用できるシードは40億しかありません。これは、適度なサイズのセットの可能なシャッフルの数よりはるかに少ないものです。可能なシャッフルのごく一部しか生成できません。そのバイアスは、偶発的な衝突によるバイアスを小さくします。
エリックリッペルト

16

アイデアは、アイテムとランダムな順序で匿名オブジェクトを取得してから、この順序と戻り値でアイテムを並べ替えます。

var result = items.Select(x => new { value = x, order = rnd.Next() })
            .OrderBy(x => x.order).Select(x => x.value).ToList()

3
最高のワンライナーソリューション
vipin8169

1
最後のファイにセミコロンがありません
reggaeguitar

rndについて不明な点がある場合は、上記のコードの前にこれを追加してください。Random rnd = new Random();
Greg Trevellick

10
    public static List<T> Randomize<T>(List<T> list)
    {
        List<T> randomizedList = new List<T>();
        Random rnd = new Random();
        while (list.Count > 0)
        {
            int index = rnd.Next(0, list.Count); //pick a random item from the master list
            randomizedList.Add(list[index]); //place it at the end of the randomized list
            list.RemoveAt(index);
        }
        return randomizedList;
    }


4
var listCopy = list.ToList()入ってくるリストからすべてのアイテムをポップすることを避けるようなことをしませんか?これらのリストを空に変更する理由がよくわかりません。
Chris Marisic 14

9

編集 これRemoveAtは私の以前のバージョンの弱点です。このソリューションはそれを克服します。

public static IEnumerable<T> Shuffle<T>(
        this IEnumerable<T> source,
        Random generator = null)
{
    if (generator == null)
    {
        generator = new Random();
    }

    var elements = source.ToArray();
    for (var i = elements.Length - 1; i >= 0; i--)
    {
        var swapIndex = generator.Next(i + 1);
        yield return elements[swapIndex];
        elements[swapIndex] = elements[i];
    }
}

オプションのRandom generatorに注意してください。の基本フレームワークの実装Randomが、スレッドセーフではない、または暗号学的にニーズに対して十分に強力でない場合は、実装を操作に挿入できます。

スレッドセーフで暗号学的に強力な実装に適した実装は、Randomこの回答にあります。


ここにアイデアがあります、(うまくいけば)効率的な方法でIListを拡張します。

public static IEnumerable<T> Shuffle<T>(this IList<T> list)
{
    var choices = Enumerable.Range(0, list.Count).ToList();
    var rng = new Random();
    for(int n = choices.Count; n > 1; n--)
    {
        int k = rng.Next(n);
        yield return list[choices[k]];
        choices.RemoveAt(k);
    }

    yield return list[choices[0]];
}


stackoverflow.com/questions/4412405/…を参照してください。あなたはすでに気づいている必要があります。
nawfal 2013年

@nawfalは私の改善された実装を参照してください。
Jodrell、2014

1
ふむふむ。それはありますGetNextNext
nawfal 14

4

あなたはこの簡単な拡張方法を使用してそれを達成することができます

public static class IEnumerableExtensions
{

    public static IEnumerable<t> Randomize<t>(this IEnumerable<t> target)
    {
        Random r = new Random();

        return target.OrderBy(x=>(r.Next()));
    }        
}

次のようにして使用できます

// use this on any collection that implements IEnumerable!
// List, Array, HashSet, Collection, etc

List<string> myList = new List<string> { "hello", "random", "world", "foo", "bar", "bat", "baz" };

foreach (string s in myList.Randomize())
{
    Console.WriteLine(s);
}

3
Random関数の外のクラスインスタンスをstatic変数として保持します。それ以外の場合、すばやく連続して呼び出された場合、タイマーから同じランダム化シードを取得することがあります。
レモンシード

おもしろいことに、Randomクラスをループ内ですばやくインスタンス化すると、たとえば0ミリ秒から200ミリ秒の間で、同じランダム化シードを取得する可能性が非常に高くなります。その結果、結果が繰り返されます。ただし、Random rand = new Random(Guid.NewGuid()。GetHashCode());を使用してこれを回避できます。これにより、無作為化がGuid.NewGuid()から効果的に強制的に行われます
Baaleos

4

これは、オリジナルを変更しないことが望ましい場合のシャッフルの推奨方法です。これは、列挙可能なシーケンスで機能するフィッシャー・イェーツの「裏返し」アルゴリズムの変形です(長さはsource最初から知っている必要はありません)。

public static IList<T> NextList<T>(this Random r, IEnumerable<T> source)
{
  var list = new List<T>();
  foreach (var item in source)
  {
    var i = r.Next(list.Count + 1);
    if (i == list.Count)
    {
      list.Add(item);
    }
    else
    {
      var temp = list[i];
      list[i] = item;
      list.Add(temp);
    }
  }
  return list;
}

このアルゴリズムは、すべてのインデックスが1回だけ選択されるまで、ランダムに選択されたインデックスを最後のインデックスと交換することにより、インデックスをから割り当て、ランダムにインデックスを使い果たす0ことによっても実装できlength - 1ます。この上のコードは、まったく同じことを実現しますが、追加の割り当てはありません。それはかなりすっきりしています。

Randomクラスに関しては、それは汎用の数値ジェネレーターです(そして、私が宝くじを実行している場合は、別のものを使用することを検討します)。また、デフォルトでは時間ベースのシード値に依存しています。問題を少し軽減するには、RandomクラスにをシードするRNGCryptoServiceProviderRNGCryptoServiceProvider、これと同様の方法(以下を参照)でを使用して、一様に選択されたランダムな倍精度浮動小数点値を生成しますが、宝くじを実行するには、ランダム性とランダムソース。

var bytes = new byte[8];
_secureRng.GetBytes(bytes);
var v = BitConverter.ToUInt64(bytes, 0);
return (double)v / ((double)ulong.MaxValue + 1);

ランダムなdouble(0と1の間のみ)を生成するポイントは、整数解にスケーリングするために使用することです。ランダムなdoubleに基づいてリストから何かを選択する必要がある場合、それはx常に0 <= x && x < 1簡単です。

return list[(int)(x * list.Count)];

楽しい!


4

2つのを使用しても構わない場合Listsは、これがおそらく最も簡単な方法ですが、おそらく最も効率的または予測できない方法ではありません。

List<int> xList = new List<int>() { 1, 2, 3, 4, 5 };
List<int> deck = new List<int>();

foreach (int xInt in xList)
    deck.Insert(random.Next(0, deck.Count + 1), xInt);

3

固定数(75)がある場合は、75要素の配列を作成し、リストを列挙して、要素を配列内のランダムな位置に移動できます。Fisher-Yatesのshuffleを使用して、配列番号へのリスト番号のマッピングを生成できます。


3

私は通常使用します:

var list = new List<T> ();
fillList (list);
var randomizedList = new List<T> ();
var rnd = new Random ();
while (list.Count != 0)
{
    var index = rnd.Next (0, list.Count);
    randomizedList.Add (list [index]);
    list.RemoveAt (index);
}

list.RemoveAtはO(n)操作であるため、この実装は非常に遅くなります。
George Polevoy

1
    List<T> OriginalList = new List<T>();
    List<T> TempList = new List<T>();
    Random random = new Random();
    int length = OriginalList.Count;
    int TempIndex = 0;

    while (length > 0) {
        TempIndex = random.Next(0, length);  // get random value between 0 and original length
        TempList.Add(OriginalList[TempIndex]); // add to temp list
        OriginalList.RemoveAt(TempIndex); // remove from original list
        length = OriginalList.Count;  // get new list <T> length.
    }

    OriginalList = new List<T>();
    OriginalList = TempList; // copy all items from temp list to original list.

0

以下は、シャッフルされた値のバイト配列を返す効率的なシャッフルです。必要以上にシャッフルすることはありません。以前に中断したところから再開できます。私の実際の実装(図には示されていません)は、ユーザー指定の交換用シャッフルを可能にするMEFコンポーネントです。

    public byte[] Shuffle(byte[] array, int start, int count)
    {
        int n = array.Length - start;
        byte[] shuffled = new byte[count];
        for(int i = 0; i < count; i++, start++)
        {
            int k = UniformRandomGenerator.Next(n--) + start;
            shuffled[i] = array[k];
            array[k] = array[start];
            array[start] = shuffled[i];
        }
        return shuffled;
    }

`


0

これを行うスレッドセーフな方法は次のとおりです。

public static class EnumerableExtension
{
    private static Random globalRng = new Random();

    [ThreadStatic]
    private static Random _rng;

    private static Random rng 
    {
        get
        {
            if (_rng == null)
            {
                int seed;
                lock (globalRng)
                {
                    seed = globalRng.Next();
                }
                _rng = new Random(seed);
             }
             return _rng;
         }
    }

    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> items)
    {
        return items.OrderBy (i => rng.Next());
    }
}

0
 public Deck(IEnumerable<Card> initialCards) 
    {
    cards = new List<Card>(initialCards);
    public void Shuffle() 
     }
    {
        List<Card> NewCards = new List<Card>();
        while (cards.Count > 0) 
        {
            int CardToMove = random.Next(cards.Count);
            NewCards.Add(cards[CardToMove]);
            cards.RemoveAt(CardToMove);
        }
        cards = NewCards;
    }

public IEnumerable<string> GetCardNames() 

{
    string[] CardNames = new string[cards.Count];
    for (int i = 0; i < cards.Count; i++)
    CardNames[i] = cards[i].Name;
    return CardNames;
}

Deck deck1;
Deck deck2;
Random random = new Random();

public Form1() 
{

InitializeComponent();
ResetDeck(1);
ResetDeck(2);
RedrawDeck(1);
 RedrawDeck(2);

}



 private void ResetDeck(int deckNumber) 
    {
    if (deckNumber == 1) 
{
      int numberOfCards = random.Next(1, 11);
      deck1 = new Deck(new Card[] { });
      for (int i = 0; i < numberOfCards; i++)
           deck1.Add(new Card((Suits)random.Next(4),(Values)random.Next(1, 14)));
       deck1.Sort();
}


   else
    deck2 = new Deck();
 }

private void reset1_Click(object sender, EventArgs e) {
ResetDeck(1);
RedrawDeck(1);

}

private void shuffle1_Click(object sender, EventArgs e) 
{
    deck1.Shuffle();
    RedrawDeck(1);

}

private void moveToDeck1_Click(object sender, EventArgs e) 
{

    if (listBox2.SelectedIndex >= 0)
    if (deck2.Count > 0) {
    deck1.Add(deck2.Deal(listBox2.SelectedIndex));

}

    RedrawDeck(1);
    RedrawDeck(2);

}

2
Stack Overflowへようこそ!コードの巨大なブロックではなく、回答に説明を追加することを検討してください。ここでの目標は、人々が答えを理解し、他の状況でそれを適用できるように人々を教育することです。コードにコメントを付けて説明を追加すると、今回質問した人だけでなく、同じ問題が発生する可能性のある将来の誰にとっても、より役立つ回答になります。
starsplusplus

4
このコードのほとんどは質問とはまったく無関係であり、唯一有用な部分は基本的にAdam Tegenの回答をほぼ6年前から繰り返しています。
TC

0

インプレースで作業するのではなく新しいリストを返し、他の多くのLinqメソッドと同様に、より一般的なものを受け入れる受け入れられた回答の単純な変更IEnumerable<T>

private static Random rng = new Random();

/// <summary>
/// Returns a new list where the elements are randomly shuffled.
/// Based on the Fisher-Yates shuffle, which has O(n) complexity.
/// </summary>
public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> list) {
    var source = list.ToList();
    int n = source.Count;
    var shuffled = new List<T>(n);
    shuffled.AddRange(source);
    while (n > 1) {
        n--;
        int k = rng.Next(n + 1);
        T value = shuffled[k];
        shuffled[k] = shuffled[n];
        shuffled[n] = value;
    }
    return shuffled;
}


-5

確かに古い投稿ですが、私はGUIDを使用しています。

Items = Items.OrderBy(o => Guid.NewGuid().ToString()).ToList();

GUIDは常に一意であり、結果が毎回変化するたびに再生成されるためです。


コンパクトですが、連続したnewGuidを高品質のランダムにするための並べ替えに関するリファレンスはありますか?quid / uuidの一部のバージョンには、タイムスタンプとその他のランダムでない部分があります。
Johan Lundberg

8
この答えはすでに与えられており、さらに悪いことに、ランダム性ではなく一意性のために設計されています。
Alex Angas

-7

この種の問題への非常に単純なアプローチは、リスト内のランダムな要素の交換の数を使用することです。

擬似コードでは、これは次のようになります。

do 
    r1 = randomPositionInList()
    r2 = randomPositionInList()
    swap elements at index r1 and index r2 
for a certain number of times

1
このアプローチの1つの問題は、いつ停止するかを知ることです。また、疑似乱数ジェネレータのバイアスを誇張する傾向があります。
Mark Bessey、

3
はい。非常に非効率的です。同じように単純で、より優れた、より高速なアプローチが存在する場合、このようなアプローチを使用する理由はありません。
PeterAllenWebb 2008年

1
あまり効率的でも効果的でもありません... N回実行すると、多くの要素が元の位置に残ります。
NSjonas
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.