C#でジェネリックリストの順序をランダム化する最良の方法は何ですか?宝くじタイプのアプリケーション用にそれらを描画するために、ランダムな順序を割り当てたいリストに75の有限セットがあります。
C#でジェネリックリストの順序をランダム化する最良の方法は何ですか?宝くじタイプのアプリケーション用にそれらを描画するために、ランダムな順序を割り当てたいリストに75の有限セットがあります。
回答:
フィッシャーイェーツのシャッフルに(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;
}
}
}
}
Random rng = new Random();
するだけstatic
で、比較ポストの問題が解決します。後続の各呼び出しは、前の呼び出しから続くため、最後のランダムな結果になります。
アイテムを完全にランダムな順序で並べ替えるだけでよい場合は(リスト内のアイテムを混合するためだけ)、GUIDでアイテムを並べ替えるこのシンプルで効果的なコードを使用します...
var shuffledcards = cards.OrderBy(a => Guid.NewGuid()).ToList();
var shuffledcards = cards.OrderBy(a => rng.Next());
compilr.com/grenade/sandbox/Program.cs
NewGuid
一意のGUIDを提供することのみを保証します。ランダム性は保証されません。一意の値を作成する以外の目的でGUIDを使用している場合、それは間違っています。
ここにあるこの単純なアルゴリズムの不格好なバージョンすべてに少し驚いています。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;
}
i = list.Count - 1
、つまり最後の反復でrnd.Next(i, list.Count)
は、iが返されます。したがってi < list.Count -1
、ループ条件として必要です。まあ、あなたはそれを「必要とする」必要はありませんが、それは1回の繰り返しを節約します;)
IEnumerableの拡張メソッド:
public static IEnumerable<T> Randomize<T>(this IEnumerable<T> source)
{
Random rnd = new Random();
return source.OrderBy<T, int>((item) => rnd.Next());
}
OrderBy
QuickSortバリアントを使用して、(見かけ上はランダムな)キーでアイテムをソートします。QuickSortのパフォーマンスはO(N log N)です。対照的に、Fisher-YatesシャッフルはO(N)です。75要素のコレクションの場合、これは大した問題ではないかもしれませんが、大きなコレクションでは違いが顕著になります。
Random.Next()
値の合理的な疑似ランダム分布を生成する可能性がありますが、値が一意であることは保証されません。重複キーの確率は、Nが2 ^ 32 + 1に達したときに確実になるまで、Nとともに(非線形的に)増加します。クイックソートは安定ソート。したがって、複数の要素に偶然に同じ擬似ランダムインデックス値が割り当てられた場合、出力シーケンスでのそれらの順序は入力シーケンスと同じになります。したがって、バイアスが「シャッフル」に導入されます。OrderBy
アイデアは、アイテムとランダムな順序で匿名オブジェクトを取得してから、この順序と戻り値でアイテムを並べ替えます。
var result = items.Select(x => new { value = x, order = rnd.Next() })
.OrderBy(x => x.order).Select(x => x.value).ToList()
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;
}
var listCopy = list.ToList()
入ってくるリストからすべてのアイテムをポップすることを避けるようなことをしませんか?これらのリストを空に変更する理由がよくわかりません。
編集
これ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]];
}
GetNext
かNext
?
あなたはこの簡単な拡張方法を使用してそれを達成することができます
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);
}
Random
関数の外のクラスインスタンスをstatic
変数として保持します。それ以外の場合、すばやく連続して呼び出された場合、タイマーから同じランダム化シードを取得することがあります。
これは、オリジナルを変更しないことが望ましい場合のシャッフルの推奨方法です。これは、列挙可能なシーケンスで機能するフィッシャー・イェーツの「裏返し」アルゴリズムの変形です(長さは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
クラスにをシードするRNGCryptoServiceProvider
かRNGCryptoServiceProvider
、これと同様の方法(以下を参照)でを使用して、一様に選択されたランダムな倍精度浮動小数点値を生成しますが、宝くじを実行するには、ランダム性とランダムソース。
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)];
楽しい!
固定数(75)がある場合は、75要素の配列を作成し、リストを列挙して、要素を配列内のランダムな位置に移動できます。Fisher-Yatesのshuffleを使用して、配列番号へのリスト番号のマッピングを生成できます。
私は通常使用します:
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<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.
以下は、シャッフルされた値のバイト配列を返す効率的なシャッフルです。必要以上にシャッフルすることはありません。以前に中断したところから再開できます。私の実際の実装(図には示されていません)は、ユーザー指定の交換用シャッフルを可能にする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;
}
`
これを行うスレッドセーフな方法は次のとおりです。
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());
}
}
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);
}
インプレースで作業するのではなく新しいリストを返し、他の多くの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;
}
オンラインで興味深い解決策を見つけました。
礼儀:https : //improveandrepeat.com/2018/08/a-simple-way-to-shuffle-your-lists-in-c/
var shuffled = myList.OrderBy(x => Guid.NewGuid())。ToList();
確かに古い投稿ですが、私はGUIDを使用しています。
Items = Items.OrderBy(o => Guid.NewGuid().ToString()).ToList();
GUIDは常に一意であり、結果が毎回変化するたびに再生成されるためです。
この種の問題への非常に単純なアプローチは、リスト内のランダムな要素の交換の数を使用することです。
擬似コードでは、これは次のようになります。
do
r1 = randomPositionInList()
r2 = randomPositionInList()
swap elements at index r1 and index r2
for a certain number of times