Randomize a List T

Question

What is the best way to randomize the order of a generic list in C   I ve got a finite set of 75 numbers in a list I would like to assign a random order to  in order to draw them for a lottery type application

User · Answer

public Deck IEnumerable lt Card gt  initialCards             cards   new List lt Card gt  initialCards       public void Shuffle                         List lt Card gt  NewCards   new List lt Card gt             while  cards Count  gt  0                         int CardToMove   random Next cards Count               NewCards Add cards CardToMove                cards RemoveAt CardToMove                     cards   NewCards         public IEnumerable lt string gt  GetCardNames           string   CardNames   new string cards Count       for  int i   0  i  lt  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  lt  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  gt   0      if  deck2 Count  gt  0        deck1 Add deck2 Deal listBox2 SelectedIndex            RedrawDeck 1       RedrawDeck 2

User · Answer

A very simple approach to this kind of problem is to use a number of random element swap in the list   In pseudo-code this would look like this   do      r1   randomPositionInList       r2   randomPositionInList       swap elements at index r1 and index r2  for a certain number of times

User · Answer

I have found an interesting solution online   Courtesy  https   improveandrepeat com 2018 08 a-simple-way-to-shuffle-your-lists-in-c   var shuffled   myList OrderBy x    Guid NewGuid    ToList

User · Answer

I usually use   var list   new List lt T gt      fillList  list   var randomizedList   new List lt T gt      var rnd   new Random     while  list Count    0        var index   rnd Next  0  list Count       randomizedList Add  list  index        list RemoveAt  index

User · Answer

A very simple approach to this kind of problem is to use a number of random element swap in the list   In pseudo-code this would look like this   do      r1   randomPositionInList       r2   randomPositionInList       swap elements at index r1 and index r2  for a certain number of times

User · Answer

public static List lt T gt  Randomize lt T gt  List lt T gt  list                List lt T gt  randomizedList   new List lt T gt             Random rnd   new Random            while  list Count  gt  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

User · Answer

A very simple approach to this kind of problem is to use a number of random element swap in the list   In pseudo-code this would look like this   do      r1   randomPositionInList       r2   randomPositionInList       swap elements at index r1 and index r2  for a certain number of times

User · Answer

I m bit surprised by all the clunky versions of this simple algorithm here  Fisher-Yates  or Knuth shuffle  is bit tricky but very compact  Why is it tricky  Because your need to pay attention to whether your random number generator r a b  returns value where b is inclusive or exclusive  I ve also edited Wikipedia description so people don t blindly follow pseudocode there and create hard to detect bugs  For  Net  Random Next a b  returns number exclusive of b so without further ado  here s how it can be implemented in C   Net   public static void Shuffle lt T gt  this IList lt T gt  list  Random rnd        for var i list Count  i  gt  0  i--          list Swap 0  rnd Next 0  i       public static void Swap lt T gt  this IList lt T gt  list  int i  int j        var temp   list i       list i    list j       list j    temp      Try this code

User · Answer

Here is an implementation of the Fisher-Yates shuffle that allows specification of the number of elements to return  hence  it is not necessary to first sort the whole collection before taking your desired number of elements  The sequence of swapping elements is reversed from default  and proceeds from the first element to the last element  so that retrieving a subset of the collection yields the same  partial  sequence as shuffling the whole collection  collection TakeRandom 5  SequenceEqual collection Shuffle   Take 5       true  This algorithm is based on Durstenfeld s  modern  version of the Fisher-Yates shuffle on Wikipedia  public static IList lt T gt  TakeRandom lt T gt  this IEnumerable lt T gt  collection  int count  Random random    gt  shuffle collection  count  random   public static IList lt T gt  Shuffle lt T gt  this IEnumerable lt T gt  collection  Random random    gt  shuffle collection  null  random   private static IList lt T gt  shuffle lt T gt  IEnumerable lt T gt  collection  int  take  Random random        var a   collection ToArray        var n   a Length      if  take  lt   0    take  gt  n  throw new ArgumentException  quot Invalid number of elements to return  quot        var end   take    n      for  int i   0  i  lt  end  i                  var j   random Next i  n            a i   a j      a j   a i               if  take HasValue  return new ArraySegment lt T gt  a  0  take Value       return a

User · Answer

Shuffle any  I List with an extension method based on the Fisher-Yates shuffle   private static Random rng   new Random       public static void Shuffle lt T gt  this IList lt T gt  list            int n   list Count        while  n  gt  1              n--            int k   rng Next n   1             T value   list k             list k    list n             list n    value                Usage   List lt Product gt  products   GetProducts    products Shuffle      The code above uses the much criticised System Random method to select swap candidates  It s fast but not as random as it should be  If you need a better quality of randomness in your shuffles use the random number generator in System Security Cryptography like so   using System Security Cryptography      public static void Shuffle lt T gt  this IList lt T gt  list        RNGCryptoServiceProvider provider   new RNGCryptoServiceProvider        int n   list Count      while  n  gt  1                byte   box   new byte 1           do provider GetBytes box           while    box 0   lt  n    Byte MaxValue   n             int k    box 0    n           n--          T value   list k           list k    list n           list n    value            A simple comparison is available at this blog  WayBack Machine    Edit  Since writing this answer a couple years back  many people have commented or written to me  to point out the big silly flaw in my comparison  They are of course right  There s nothing wrong with System Random if it s used in the way it was intended  In my first example above  I instantiate the rng variable inside of the Shuffle method  which is asking for trouble if the method is going to be called repeatedly  Below is a fixed  full example based on a really useful comment received today from  weston here on 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 lt int gt  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 lt T gt  this IList lt T gt  list              int n   list Count        while  n  gt  1                  n--          int k   ThreadSafeRandom ThisThreadsRandom Next n   1           T value   list k           list k    list n           list n    value

User · Answer

Idea is get anonymous object with item and random order and then reorder items by this order and return value   var result   items Select x   gt  new   value   x  order   rnd Next                   OrderBy x   gt  x order  Select x   gt  x value  ToList

User · Answer

A very simple approach to this kind of problem is to use a number of random element swap in the list   In pseudo-code this would look like this   do      r1   randomPositionInList       r2   randomPositionInList       swap elements at index r1 and index r2  for a certain number of times

User · Answer

List lt T gt  OriginalList   new List lt T gt         List lt T gt  TempList   new List lt T gt         Random random   new Random        int length   OriginalList Count      int TempIndex   0       while  length  gt  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  lt T gt  length             OriginalList   new List lt T gt         OriginalList   TempList     copy all items from temp list to original list

User · Answer

Extension method for IEnumerable   public static IEnumerable lt T gt  Randomize lt T gt  this IEnumerable lt T gt  source        Random rnd   new Random        return source OrderBy lt T  int gt   item    gt  rnd Next

User · Answer

Your question is how to randomize a list  This means   All unique combinations should be possible of happening All unique combinations should occur with the same distribution  AKA being non-biased    A large number of the answers posted for this question do NOT satisfy the two requirements above for being  quot random quot   Here s a compact  non-biased pseudo-random function following the Fisher-Yates shuffle method  public static void Shuffle lt T gt  this IList lt T gt  list  Random rnd        for  var i   list Count-1  i  gt  0  i--                var randomIndex   rnd Next i   1     maxValue  i   1  is EXCLUSIVE         list Swap i  randomIndex             public static void Swap lt T gt  this IList lt T gt  list  int indexA  int indexB       var temp   list indexA      list indexA    list indexB      list indexB    temp

User · Answer

If you have a fixed number  75   you could create an array with 75 elements  then enumerate your list  moving the elements to randomized positions in the array   You can generate the mapping of list number to array index using the Fisher-Yates shuffle

User · Answer

A simple modification of the accepted answer that returns a new list instead of working in-place  and accepts the more general IEnumerable lt T gt  as many other Linq methods do   private static Random rng   new Random          lt summary gt      Returns a new list where the elements are randomly shuffled      Based on the Fisher-Yates shuffle  which has O n  complexity       lt  summary gt  public static IEnumerable lt T gt  Shuffle lt T gt  this IEnumerable lt T gt  list        var source   list ToList        int n   source Count      var shuffled   new List lt T gt  n       shuffled AddRange source       while  n  gt  1            n--          int k   rng Next n   1           T value   shuffled k           shuffled k    shuffled n           shuffled n    value            return shuffled

User · Answer

Here s an efficient Shuffler that returns a byte array of shuffled values  It never shuffles more than is needed  It can be restarted from where it previously left off  My actual implementation  not shown  is a MEF component that allows a user specified replacement shuffler       public byte   Shuffle byte   array  int start  int count                int n   array Length - start          byte   shuffled   new byte count           for int i   0  i  lt  count  i    start                          int k   UniformRandomGenerator Next n--    start              shuffled i    array k               array k    array start               array start    shuffled i                     return shuffled

User · Answer

If we only need to shuffle items in a completely random order  just to mix the items in a list   I prefer this simple yet effective code that orders items by guid     var shuffledcards   cards OrderBy a   gt  Guid NewGuid    ToList

User · Answer

One can use the Shuffle extension methond from morelinq package  it works on IEnumerables  install-package morelinq  using MoreLinq          var randomized   list Shuffle

User · Answer

Idea is get anonymous object with item and random order and then reorder items by this order and return value   var result   items Select x   gt  new   value   x  order   rnd Next                   OrderBy x   gt  x order  Select x   gt  x value  ToList

User · Answer

A simple modification of the accepted answer that returns a new list instead of working in-place  and accepts the more general IEnumerable lt T gt  as many other Linq methods do   private static Random rng   new Random          lt summary gt      Returns a new list where the elements are randomly shuffled      Based on the Fisher-Yates shuffle  which has O n  complexity       lt  summary gt  public static IEnumerable lt T gt  Shuffle lt T gt  this IEnumerable lt T gt  list        var source   list ToList        int n   source Count      var shuffled   new List lt T gt  n       shuffled AddRange source       while  n  gt  1            n--          int k   rng Next n   1           T value   shuffled k           shuffled k    shuffled n           shuffled n    value            return shuffled

User · Answer

This is my preferred method of a shuffle when it s desirable to not modify the original  It s a variant of the Fisher   Yates  inside-out  algorithm that works on any enumerable sequence  the length of source does not need to be known from start    public static IList lt T gt  NextList lt T gt  this Random r  IEnumerable lt T gt  source      var list   new List lt T gt       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      This algorithm can also be implemented by allocating a range from 0 to length - 1 and randomly exhausting the indices by swapping the randomly chosen index with the last index until all indices have been chosen exactly once  This above code accomplishes the exact same thing but without the additional allocation  Which is pretty neat   With regards to the Random class it s a general purpose number generator  and If I was running a lottery I d consider using something different   It also relies on a time based seed value by default  A small alleviation of the problem is to seed the Random class with the RNGCryptoServiceProvider or you could use the RNGCryptoServiceProvider in a method similar to this  see below  to generate uniformly chosen random double floating point values but running a lottery pretty much requires understanding randomness and the nature of the randomness source   var bytes   new byte 8    secureRng GetBytes bytes   var v   BitConverter ToUInt64 bytes  0   return  double v     double ulong MaxValue   1     The point of generating a random double  between 0 and 1 exclusively  is to use to scale to an integer solution  If you need to pick something from a list based on a random double x that s always going to be 0  lt   x  amp  amp  x  lt  1 is straight forward   return list  int  x   list Count      Enjoy

User · Answer

public static List lt T gt  Randomize lt T gt  List lt T gt  list                List lt T gt  randomizedList   new List lt T gt             Random rnd   new Random            while  list Count  gt  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

User · Answer

Just wanted to suggest a variant using an IComparer lt T gt  and List Sort    public class RandomIntComparer   IComparer lt int gt        private readonly Random  random   new Random             public int Compare int x  int y                return  random Next -1  2            Usage  list Sort new RandomIntComparer

User · Answer

Your question is how to randomize a list  This means   All unique combinations should be possible of happening All unique combinations should occur with the same distribution  AKA being non-biased    A large number of the answers posted for this question do NOT satisfy the two requirements above for being  quot random quot   Here s a compact  non-biased pseudo-random function following the Fisher-Yates shuffle method  public static void Shuffle lt T gt  this IList lt T gt  list  Random rnd        for  var i   list Count-1  i  gt  0  i--                var randomIndex   rnd Next i   1     maxValue  i   1  is EXCLUSIVE         list Swap i  randomIndex             public static void Swap lt T gt  this IList lt T gt  list  int indexA  int indexB       var temp   list indexA      list indexA    list indexB      list indexB    temp

User · Answer

List lt T gt  OriginalList   new List lt T gt         List lt T gt  TempList   new List lt T gt         Random random   new Random        int length   OriginalList Count      int TempIndex   0       while  length  gt  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  lt T gt  length             OriginalList   new List lt T gt         OriginalList   TempList     copy all items from temp list to original list

User · Answer

If you don t mind using two Lists  then this is probably the easiest way to do it  but probably not the most efficient or unpredictable one    List lt int gt  xList   new List lt int gt      1  2  3  4  5    List lt int gt  deck   new List lt int gt      foreach  int xInt in xList      deck Insert random Next 0  deck Count   1   xInt

User · Answer

If you have a fixed number  75   you could create an array with 75 elements  then enumerate your list  moving the elements to randomized positions in the array   You can generate the mapping of list number to array index using the Fisher-Yates shuffle

User · Answer

private List lt GameObject gt  ShuffleList List lt GameObject gt  ActualList          List lt GameObject gt  newList   ActualList      List lt GameObject gt  outList   new List lt GameObject gt          int count   newList Count       while  newList Count  gt  0             int rando   Random Range 0  newList Count            outList Add newList rando             newList RemoveAt rando                      return  outList       usage   List lt GameObject gt  GetShuffle   ShuffleList ActualList

User · Answer

EDIT The RemoveAt is a weakness in my previous version  This solution overcomes that   public static IEnumerable lt T gt  Shuffle lt T gt           this IEnumerable lt T gt  source          Random generator   null        if  generator    null                generator   new Random               var elements   source ToArray        for  var i   elements Length - 1  i  gt   0  i--                var swapIndex   generator Next i   1           yield return elements swapIndex           elements swapIndex    elements i             Note the optional Random generator  if the base framework implementation of Random is not thread-safe or cryptographically strong enough for your needs  you can inject your implementation into the operation   A suitable implementation for a thread-safe cryptographically strong Random implementation can be found in this answer     Here s an idea  extend IList in a  hopefully  efficient way   public static IEnumerable lt T gt  Shuffle lt T gt  this IList lt T gt  list        var choices   Enumerable Range 0  list Count  ToList        var rng   new Random        for int n   choices Count  n  gt  1  n--                int k   rng Next n           yield return list choices k            choices RemoveAt k              yield return list choices 0

User · Answer

Here is an implementation of the Fisher-Yates shuffle that allows specification of the number of elements to return  hence  it is not necessary to first sort the whole collection before taking your desired number of elements  The sequence of swapping elements is reversed from default  and proceeds from the first element to the last element  so that retrieving a subset of the collection yields the same  partial  sequence as shuffling the whole collection  collection TakeRandom 5  SequenceEqual collection Shuffle   Take 5       true  This algorithm is based on Durstenfeld s  modern  version of the Fisher-Yates shuffle on Wikipedia  public static IList lt T gt  TakeRandom lt T gt  this IEnumerable lt T gt  collection  int count  Random random    gt  shuffle collection  count  random   public static IList lt T gt  Shuffle lt T gt  this IEnumerable lt T gt  collection  Random random    gt  shuffle collection  null  random   private static IList lt T gt  shuffle lt T gt  IEnumerable lt T gt  collection  int  take  Random random        var a   collection ToArray        var n   a Length      if  take  lt   0    take  gt  n  throw new ArgumentException  quot Invalid number of elements to return  quot        var end   take    n      for  int i   0  i  lt  end  i                  var j   random Next i  n            a i   a j      a j   a i               if  take HasValue  return new ArraySegment lt T gt  a  0  take Value       return a

User · Answer

Old post for sure  but I just use a GUID     Items   Items OrderBy o   gt  Guid NewGuid   ToString    ToList      A GUID is always unique  and since it is regenerated every time the result changes each time

User · Answer

public static List lt T gt  Randomize lt T gt  List lt T gt  list                List lt T gt  randomizedList   new List lt T gt             Random rnd   new Random            while  list Count  gt  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

User · Answer

I usually use   var list   new List lt T gt      fillList  list   var randomizedList   new List lt T gt      var rnd   new Random     while  list Count    0        var index   rnd Next  0  list Count       randomizedList Add  list  index        list RemoveAt  index

User · Answer

One can use the Shuffle extension methond from morelinq package  it works on IEnumerables  install-package morelinq  using MoreLinq          var randomized   list Shuffle

User · Answer

Old post for sure  but I just use a GUID     Items   Items OrderBy o   gt  Guid NewGuid   ToString    ToList      A GUID is always unique  and since it is regenerated every time the result changes each time

User · Answer

Just wanted to suggest a variant using an IComparer lt T gt  and List Sort    public class RandomIntComparer   IComparer lt int gt        private readonly Random  random   new Random             public int Compare int x  int y                return  random Next -1  2            Usage  list Sort new RandomIntComparer

User · Answer

If you don t mind using two Lists  then this is probably the easiest way to do it  but probably not the most efficient or unpredictable one    List lt int gt  xList   new List lt int gt      1  2  3  4  5    List lt int gt  deck   new List lt int gt      foreach  int xInt in xList      deck Insert random Next 0  deck Count   1   xInt

User · Answer

If we only need to shuffle items in a completely random order  just to mix the items in a list   I prefer this simple yet effective code that orders items by guid     var shuffledcards   cards OrderBy a   gt  Guid NewGuid    ToList

User · Answer

public static List lt T gt  Randomize lt T gt  List lt T gt  list                List lt T gt  randomizedList   new List lt T gt             Random rnd   new Random            while  list Count  gt  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

User · Answer

I usually use   var list   new List lt T gt      fillList  list   var randomizedList   new List lt T gt      var rnd   new Random     while  list Count    0        var index   rnd Next  0  list Count       randomizedList Add  list  index        list RemoveAt  index

User · Answer

I m bit surprised by all the clunky versions of this simple algorithm here  Fisher-Yates  or Knuth shuffle  is bit tricky but very compact  Why is it tricky  Because your need to pay attention to whether your random number generator r a b  returns value where b is inclusive or exclusive  I ve also edited Wikipedia description so people don t blindly follow pseudocode there and create hard to detect bugs  For  Net  Random Next a b  returns number exclusive of b so without further ado  here s how it can be implemented in C   Net   public static void Shuffle lt T gt  this IList lt T gt  list  Random rnd        for var i list Count  i  gt  0  i--          list Swap 0  rnd Next 0  i       public static void Swap lt T gt  this IList lt T gt  list  int i  int j        var temp   list i       list i    list j       list j    temp      Try this code

User · Answer

private List lt GameObject gt  ShuffleList List lt GameObject gt  ActualList          List lt GameObject gt  newList   ActualList      List lt GameObject gt  outList   new List lt GameObject gt          int count   newList Count       while  newList Count  gt  0             int rando   Random Range 0  newList Count            outList Add newList rando             newList RemoveAt rando                      return  outList       usage   List lt GameObject gt  GetShuffle   ShuffleList ActualList

User · Answer

You can achieve that be using this simple extension method  public static class IEnumerableExtensions        public static IEnumerable lt t gt  Randomize lt t gt  this IEnumerable lt t gt  target                Random r   new Random             return target OrderBy x  gt  r Next                        and you can use it by doing the following     use this on any collection that implements IEnumerable     List  Array  HashSet  Collection  etc  List lt string gt  myList   new List lt string gt     hello    random    world    foo    bar    bat    baz      foreach  string s in myList Randomize          Console WriteLine s

User · Answer

EDIT The RemoveAt is a weakness in my previous version  This solution overcomes that   public static IEnumerable lt T gt  Shuffle lt T gt           this IEnumerable lt T gt  source          Random generator   null        if  generator    null                generator   new Random               var elements   source ToArray        for  var i   elements Length - 1  i  gt   0  i--                var swapIndex   generator Next i   1           yield return elements swapIndex           elements swapIndex    elements i             Note the optional Random generator  if the base framework implementation of Random is not thread-safe or cryptographically strong enough for your needs  you can inject your implementation into the operation   A suitable implementation for a thread-safe cryptographically strong Random implementation can be found in this answer     Here s an idea  extend IList in a  hopefully  efficient way   public static IEnumerable lt T gt  Shuffle lt T gt  this IList lt T gt  list        var choices   Enumerable Range 0  list Count  ToList        var rng   new Random        for int n   choices Count  n  gt  1  n--                int k   rng Next n           yield return list choices k            choices RemoveAt k              yield return list choices 0

User · Answer

If you have a fixed number  75   you could create an array with 75 elements  then enumerate your list  moving the elements to randomized positions in the array   You can generate the mapping of list number to array index using the Fisher-Yates shuffle

User · Answer

You can achieve that be using this simple extension method  public static class IEnumerableExtensions        public static IEnumerable lt t gt  Randomize lt t gt  this IEnumerable lt t gt  target                Random r   new Random             return target OrderBy x  gt  r Next                        and you can use it by doing the following     use this on any collection that implements IEnumerable     List  Array  HashSet  Collection  etc  List lt string gt  myList   new List lt string gt     hello    random    world    foo    bar    bat    baz      foreach  string s in myList Randomize          Console WriteLine s

User · Answer

Extension method for IEnumerable   public static IEnumerable lt T gt  Randomize lt T gt  this IEnumerable lt T gt  source        Random rnd   new Random        return source OrderBy lt T  int gt   item    gt  rnd Next

User · Answer

I have found an interesting solution online   Courtesy  https   improveandrepeat com 2018 08 a-simple-way-to-shuffle-your-lists-in-c   var shuffled   myList OrderBy x    Guid NewGuid    ToList

User · Answer

I usually use   var list   new List lt T gt      fillList  list   var randomizedList   new List lt T gt      var rnd   new Random     while  list Count    0        var index   rnd Next  0  list Count       randomizedList Add  list  index        list RemoveAt  index

User · Answer

This is my preferred method of a shuffle when it s desirable to not modify the original  It s a variant of the Fisher   Yates  inside-out  algorithm that works on any enumerable sequence  the length of source does not need to be known from start    public static IList lt T gt  NextList lt T gt  this Random r  IEnumerable lt T gt  source      var list   new List lt T gt       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      This algorithm can also be implemented by allocating a range from 0 to length - 1 and randomly exhausting the indices by swapping the randomly chosen index with the last index until all indices have been chosen exactly once  This above code accomplishes the exact same thing but without the additional allocation  Which is pretty neat   With regards to the Random class it s a general purpose number generator  and If I was running a lottery I d consider using something different   It also relies on a time based seed value by default  A small alleviation of the problem is to seed the Random class with the RNGCryptoServiceProvider or you could use the RNGCryptoServiceProvider in a method similar to this  see below  to generate uniformly chosen random double floating point values but running a lottery pretty much requires understanding randomness and the nature of the randomness source   var bytes   new byte 8    secureRng GetBytes bytes   var v   BitConverter ToUInt64 bytes  0   return  double v     double ulong MaxValue   1     The point of generating a random double  between 0 and 1 exclusively  is to use to scale to an integer solution  If you need to pick something from a list based on a random double x that s always going to be 0  lt   x  amp  amp  x  lt  1 is straight forward   return list  int  x   list Count      Enjoy

User · Answer

public Deck IEnumerable lt Card gt  initialCards             cards   new List lt Card gt  initialCards       public void Shuffle                         List lt Card gt  NewCards   new List lt Card gt             while  cards Count  gt  0                         int CardToMove   random Next cards Count               NewCards Add cards CardToMove                cards RemoveAt CardToMove                     cards   NewCards         public IEnumerable lt string gt  GetCardNames           string   CardNames   new string cards Count       for  int i   0  i  lt  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  lt  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  gt   0      if  deck2 Count  gt  0        deck1 Add deck2 Deal listBox2 SelectedIndex            RedrawDeck 1       RedrawDeck 2

User · Answer

Shuffle any  I List with an extension method based on the Fisher-Yates shuffle   private static Random rng   new Random       public static void Shuffle lt T gt  this IList lt T gt  list            int n   list Count        while  n  gt  1              n--            int k   rng Next n   1             T value   list k             list k    list n             list n    value                Usage   List lt Product gt  products   GetProducts    products Shuffle      The code above uses the much criticised System Random method to select swap candidates  It s fast but not as random as it should be  If you need a better quality of randomness in your shuffles use the random number generator in System Security Cryptography like so   using System Security Cryptography      public static void Shuffle lt T gt  this IList lt T gt  list        RNGCryptoServiceProvider provider   new RNGCryptoServiceProvider        int n   list Count      while  n  gt  1                byte   box   new byte 1           do provider GetBytes box           while    box 0   lt  n    Byte MaxValue   n             int k    box 0    n           n--          T value   list k           list k    list n           list n    value            A simple comparison is available at this blog  WayBack Machine    Edit  Since writing this answer a couple years back  many people have commented or written to me  to point out the big silly flaw in my comparison  They are of course right  There s nothing wrong with System Random if it s used in the way it was intended  In my first example above  I instantiate the rng variable inside of the Shuffle method  which is asking for trouble if the method is going to be called repeatedly  Below is a fixed  full example based on a really useful comment received today from  weston here on 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 lt int gt  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 lt T gt  this IList lt T gt  list              int n   list Count        while  n  gt  1                  n--          int k   ThreadSafeRandom ThisThreadsRandom Next n   1           T value   list k           list k    list n           list n    value

User · Answer

Here s a thread-safe way to do this     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 lt T gt  Shuffle lt T gt  this IEnumerable lt T gt  items                return items OrderBy  i   gt  rng Next

User · Answer

Here s an efficient Shuffler that returns a byte array of shuffled values  It never shuffles more than is needed  It can be restarted from where it previously left off  My actual implementation  not shown  is a MEF component that allows a user specified replacement shuffler       public byte   Shuffle byte   array  int start  int count                int n   array Length - start          byte   shuffled   new byte count           for int i   0  i  lt  count  i    start                          int k   UniformRandomGenerator Next n--    start              shuffled i    array k               array k    array start               array start    shuffled i                     return shuffled

User · Answer

If you have a fixed number  75   you could create an array with 75 elements  then enumerate your list  moving the elements to randomized positions in the array   You can generate the mapping of list number to array index using the Fisher-Yates shuffle

User · Answer

Here s a thread-safe way to do this     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 lt T gt  Shuffle lt T gt  this IEnumerable lt T gt  items                return items OrderBy  i   gt  rng Next

[c#] Randomize a List<T>

Examples related to c#

Examples related to generic-list