1027

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

4

26 に答える 26

1311

Fisher-Yates shuffle(I)Listに基づく拡張メソッドでanyをシャッフルします。

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 変数をインスタンス化しています。これは、メソッドが繰り返し呼び出される場合に問題を引き起こします。以下は、SO で @weston から今日受け取った非常に有用なコメントに基づいた修正済みの完全な例です。

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;
      }
    }
  }
}
于 2009-08-11T20:07:57.797 に答える
433

完全にランダムな順序でアイテムをシャッフルする必要がある場合 (リスト内のアイテムを混在させるだけ)、GUID でアイテムを並べ替えるこのシンプルで効果的なコードを好みます...

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

コメントで指摘されているように、GUID はランダムであることが保証されていないため、代わりに実際の乱数ジェネレーターを使用する必要があります。

private static Random rng = new Random();
...
var shuffledcards = cards.OrderBy(a => rng.Next()).ToList();
于 2010-11-23T23:34:14.907 に答える
81

IEnumerableの拡張メソッド：

public static IEnumerable<T> Randomize<T>(this IEnumerable<T> source)
{
    Random rnd = new Random();
    return source.OrderBy<T, int>((item) => rnd.Next());
}
于 2010-08-11T08:54:59.893 に答える
13 
    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;
    }
于 2008-11-07T21:18:36.337 に答える
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]];
}

于 2011-10-27T08:43:07.820 に答える
5

two を使用してもかまわない場合は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);
于 2013-12-22T01:33:59.693 に答える
4

私は通常使用します：

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);
}
于 2008-11-07T19:35:30.087 に答える
3

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

于 2008-11-07T19:35:19.960 に答える
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.
于 2019-07-01T13:32:57.033 に答える
0

以下は、シャッフルされた値のバイト配列を返す効率的な Shuffler です。必要以上にシャッフルすることはありません。中断したところから再開できます。私の実際の実装 (表示されていません) は、ユーザー指定の置換シャフラーを可能にする 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;
    }

`

于 2013-01-24T21:26:56.207 に答える
-1 
 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);

}
于 2014-06-16T18:52:15.177 に答える
-1

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

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());
    }
}
于 2013-03-28T17:29:12.197 に答える
-4

確かに古い投稿ですが、GUID を使用しているだけです。 

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

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

于 2015-04-11T16:24:55.323 に答える
-8

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

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

do 
    r1 = randomPositionInList()
    r2 = randomPositionInList()
    swap elements at index r1 and index r2 
for a certain number of times
于 2008-11-07T19:36:14.250 に答える