I have an array like this:

    var arr1 = [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot;];

How can I randomize / shuffle it?

How to randomize (shuffle) a JavaScript array?

I have a list of objects and I want to shuffle them. I thought I could use the `random.shuffle` method, but this seems to fail when the list is of objects. Is there a method for shuffling objects or another way around this?

    import random
    
    class A:
        foo = &quot;bar&quot;

    a1 = a()
    a2 = a()
    b = [a1, a2]

    print(random.shuffle(b))

This will fail.

Shuffling a list of objects

I have the following DataFrame:

        Col1  Col2  Col3  Type
    0      1     2     3     1
    1      4     5     6     1
    ...
    20     7     8     9     2
    21    10    11    12     2
    ...
    45    13    14    15     3
    46    16    17    18     3
    ...

The DataFrame is read from a CSV file. All rows which have `Type` 1 are on top, followed by the rows with `Type` 2, followed by the rows with `Type` 3, etc.

I would like to shuffle the order of the DataFrame&#39;s rows so that all `Type`&#39;s are mixed. A possible result could be:

        Col1  Col2  Col3  Type
    0      7     8     9     2
    1     13    14    15     3
    ...
    20     1     2     3     1
    21    10    11    12     2
    ...
    45     4     5     6     1
    46    16    17    18     3
    ...

How can I achieve this?

Shuffle DataFrame rows

What&#39;s the easiest way to shuffle an array with python?

Shuffle an array with python, randomize array item order with python

How do I randomize or shuffle the elements within an array in Swift? For example, if my array consists of 52 playing cards, I want to **shuffle** the array in order to shuffle the deck.

How do I shuffle an array in Swift?

I want to shuffle the lines of a text file randomly and create a new file. The file may have several thousands of lines.

How can I do that with `cat`, `awk`, `cut`, etc?

How can I shuffle the lines of a text file on the Unix command line or in a shell script?

I have two numpy arrays of different shapes, but with the same length (leading dimension). I want to shuffle each of them, such that corresponding elements continue to correspond -- i.e. shuffle them in unison with respect to their leading indices.

This code works, and illustrates my goals:
    

    def shuffle_in_unison(a, b):
        assert len(a) == len(b)
        shuffled_a = numpy.empty(a.shape, dtype=a.dtype)
        shuffled_b = numpy.empty(b.shape, dtype=b.dtype)
        permutation = numpy.random.permutation(len(a))
        for old_index, new_index in enumerate(permutation):
            shuffled_a[new_index] = a[old_index]
            shuffled_b[new_index] = b[old_index]
        return shuffled_a, shuffled_b

For example:

    &gt;&gt;&gt; a = numpy.asarray([[1, 1], [2, 2], [3, 3]])
    &gt;&gt;&gt; b = numpy.asarray([1, 2, 3])
    &gt;&gt;&gt; shuffle_in_unison(a, b)
    (array([[2, 2],
           [1, 1],
           [3, 3]]), array([2, 1, 3]))

However, this feels clunky, inefficient, and slow, and it requires making a copy of the arrays -- I&#39;d rather shuffle them in-place, since they&#39;ll be quite large.

Is there a better way to go about this? Faster execution and lower memory usage are my primary goals, but elegant code would be nice, too.

One other thought I had was this:

    def shuffle_in_unison_scary(a, b):
        rng_state = numpy.random.get_state()
        numpy.random.shuffle(a)
        numpy.random.set_state(rng_state)
        numpy.random.shuffle(b)

This works...but it&#39;s a little scary, as I see little guarantee it&#39;ll continue to work -- it doesn&#39;t look like the sort of thing that&#39;s guaranteed to survive across numpy version, for example.



Better way to shuffle two numpy arrays in unison

I need to randomly shuffle the following Array:

    int[] solutionArray = {1, 2, 3, 4, 5, 6, 6, 5, 4, 3, 2, 1};

Is there any function to do that?

Random shuffling of an array

If you have an `NSMutableArray`, how do you shuffle the elements randomly?

(I have my own answer for this, which is posted below, but I&#39;m new to Cocoa and I&#39;m interested to know if there is a better way.)

----

Update: As noted by @Mukesh, as of iOS 10+ and macOS 10.12+, there is an `-[NSMutableArray shuffledArray]` method that can be used to shuffle. See &lt;https://developer.apple.com/documentation/foundation/nsarray/1640855-shuffledarray?language=objc&gt; for details. (But note that this creates a new array, rather than shuffling the elements in place.)

What&#39;s the Best Way to Shuffle an NSMutableArray?

I have read [an article][1] about various shuffle algorithms over at [Coding Horror][2]. I have seen that somewhere people have done this to shuffle a list:

    var r = new Random();
    var shuffled = ordered.OrderBy(x =&gt; r.Next());

Is this a good shuffle algorithm? How does it work exactly? Is it an acceptable way of doing this?

  [1]: http://www.codinghorror.com/blog/archives/001015.html
  [2]: http://www.codinghorror.com/

Is using Random and OrderBy a good shuffle algorithm?

I&#39;d like to have my array items scrambled.
Something like this:

    [1,2,3,4].scramble =&gt; [2,1,3,4]
    [1,2,3,4].scramble =&gt; [3,1,2,4]
    [1,2,3,4].scramble =&gt; [4,2,3,1]

and so on, randomly

How to randomly sort (scramble) an array in Ruby?

In Map Reduce programming the reduce phase has shuffling, sorting and reduce as its sub-parts. Sorting is a costly affair.

*What is the purpose of shuffling and sorting phase in the reducer in Map Reduce Programming?*
  

What is the purpose of shuffling and sorting phase in the reducer in Map Reduce Programming?

I was helping somebody out with his JavaScript code and my eyes were caught by a section that looked like that:

    function randOrd(){
      return (Math.round(Math.random())-0.5);
    }
    coords.sort(randOrd);
    alert(coords);

My first though was: **hey, this can&#39;t possibly work!** But then I did some experimenting and found that it indeed at least seems to provide nicely randomized results.

Then I did some web search and almost at the top found an [article][1] from which this code was most ceartanly copied. Looked like a pretty respectable site and author...

But my gut feeling tells me, that this must be wrong. Especially as the sorting algorithm is not specified by ECMA standard. I think different sorting algoritms will result in different non-uniform shuffles. Some sorting algorithms may probably even loop infinitely...

But what do you think?

And as another question... how would I now go and measure how random the results of this shuffling technique are?

**update:** I did some measurements and posted the results below as one of the answers.

  [1]: http://javascript.about.com/library/blsort2.htm

Is it correct to use JavaScript Array.sort() method for shuffling?

Why is `random.shuffle` returning `None` in Python?

    &gt;&gt;&gt; x = [&#39;foo&#39;,&#39;bar&#39;,&#39;black&#39;,&#39;sheep&#39;]
    &gt;&gt;&gt; from random import shuffle
    &gt;&gt;&gt; print shuffle(x)
    None

How do I get the shuffled value instead of `None`?

Why does random.shuffle return None?

I am looking for a generic, reusable way to shuffle a `std::vector` in C++. This is how I currently do it, but I think it&#39;s not very efficient because it needs an intermediate array and it needs to know the item type (DeckCard in this example):

	srand(time(NULL));
	
	cards_.clear();
	
	while (temp.size() &gt; 0) {
		int idx = rand() % temp.size();
		DeckCard* card = temp[idx];
		cards_.push_back(card);
		temp.erase(temp.begin() + idx);
	}

How to shuffle a std::vector?

I&#39;m using the `nltk` library&#39;s `movie_reviews` corpus which contains a large number of documents. My task is get  predictive performance of these reviews with pre-processing of the data and without pre-processing. But there is problem, in lists `documents` and `documents2` I have the same documents and I need shuffle them in order to keep same order in both lists. I cannot shuffle them separately because each time I shuffle the list, I get other results. That is why I need to shuffle the at once with same order because I need compare them in the end (it depends on order). I&#39;m using python 2.7

Example (in real are strings tokenized, but it is not relative):

    documents = [([&#39;plot : two teen couples go to a church party , &#39;], &#39;neg&#39;),
                 ([&#39;drink and then drive . &#39;], &#39;pos&#39;),
                 ([&#39;they get into an accident . &#39;], &#39;neg&#39;),
                 ([&#39;one of the guys dies&#39;], &#39;neg&#39;)]
    
    documents2 = [([&#39;plot two teen couples church party&#39;], &#39;neg&#39;),
                  ([&#39;drink then drive . &#39;], &#39;pos&#39;),
                  ([&#39;they get accident . &#39;], &#39;neg&#39;),
                  ([&#39;one guys dies&#39;], &#39;neg&#39;)]

And I need get this result after shuffle both lists:

    documents = [([&#39;one of the guys dies&#39;], &#39;neg&#39;),
                 ([&#39;they get into an accident . &#39;], &#39;neg&#39;),
                 ([&#39;drink and then drive . &#39;], &#39;pos&#39;),
                 ([&#39;plot : two teen couples go to a church party , &#39;], &#39;neg&#39;)]
    
    documents2 = [([&#39;one guys dies&#39;], &#39;neg&#39;),
                  ([&#39;they get accident . &#39;], &#39;neg&#39;),
                  ([&#39;drink then drive . &#39;], &#39;pos&#39;),
                  ([&#39;plot two teen couples church party&#39;], &#39;neg&#39;)]


I have this code:

    def cleanDoc(doc):
        stopset = set(stopwords.words(&#39;english&#39;))
        stemmer = nltk.PorterStemmer()
        clean = [token.lower() for token in doc if token.lower() not in stopset and len(token) &gt; 2]
        final = [stemmer.stem(word) for word in clean]
        return final
    
    documents = [(list(movie_reviews.words(fileid)), category)
                 for category in movie_reviews.categories()
                 for fileid in movie_reviews.fileids(category)]
    
    documents2 = [(list(cleanDoc(movie_reviews.words(fileid))), category)
                 for category in movie_reviews.categories()
                 for fileid in movie_reviews.fileids(category)]
    
    random.shuffle( and here shuffle documents and documents2 with same order) # or somehow

Shuffle two list at once with same order

How can I randomize the lines in a file using standard tools on Red Hat Linux?

I don&#39;t have the `shuf` command, so I am looking for something like a `perl` or `awk` one-liner that accomplishes the same task.

How can I randomize the lines in a file using standard tools on Red Hat Linux?

I would like to randomly reorganize the order of the numbers in a vector, in a simple one-line command?

My particular vector V has 150 entries for each value from 1 to 10:

    V &lt;- rep(1:10, each=150)

How to randomize a vector

What is the difference between `numpy.random.shuffle(x)` and `numpy.random.permutation(x)`?

I have read the doc pages but I could not understand if there was any difference between the two when I just want to randomly shuffle the elements of an array.

To be more precise suppose I have an array `x=[1,4,2,8]`.

If I want to generate random permutations of x, then what is the difference between `shuffle(x)` and `permutation(x)`?

shuffle vs permute numpy

Just as background, I&#39;m aware of the [Fisher-Yates][1] perfect shuffle.  It is a great shuffle with its O(n) complexity and its guaranteed uniformity and I&#39;d be a fool not to use it ... in an environment that permits in-place updates of arrays (so in most, if not all, *imperative* programming environments).

Sadly the functional programming world doesn&#39;t give you access to mutable state.

Because of Fisher-Yates, however, there&#39;s not a lot of literature I can find on how to design a shuffling algorithm.  The few places that address it at all do so briefly before saying, in effect, &quot;so here&#39;s Fisher-Yates which is all the shuffling you need to know&quot;.  I had to, in the end, come up with my own solution.

The solution I came up with works like this to shuffle any list of data:

* If the list is empty, return the empty set.
* If the list has a single item, return that single item.
* If the list is non-empty, partition the list with a random number generator and apply the algorithm recursively to each partition, assembling the results.

In Erlang code it looks something like this:

    shuffle([])  -&gt; [];
    shuffle([L]) -&gt; [L];
    shuffle(L)   -&gt;
      {Left, Right} = lists:partition(fun(_) -&gt; 
                                        random:uniform() &lt; 0.5 
                                      end, L),
      shuffle(Left) ++ shuffle(Right).

(If this looks like a deranged quick sort to you, well, that&#39;s what it is, basically.)

So here&#39;s my problem: the same situation that makes finding shuffling algorithms that aren&#39;t Fisher-Yates difficult makes finding tools to **analyse** a shuffling algorithm equally difficult.  There&#39;s lots of literature I can find on analysing PRNGs for uniformity, periodicity, etc. but not a lot of information out there on how to analyse a shuffle.  (Indeed some of the information I found on analysing shuffles was just plain wrong -- easily deceived through simple techniques.)

So my question is this: how do I analyse my shuffling algorithm (assuming that the `random:uniform()` call up there is up to the task of generating apropriate random numbers with good characteristics)?  What mathematical tools are there at my disposal to judge whether or not, say, 100,000 runs of the shuffler over a list of integers ranging 1..100 has given me plausibly good shuffling results?  I&#39;ve done a few tests of my own (comparing increments to decrements in the shuffles, for example), but I&#39;d like to know a few more.

And if there&#39;s any insight into that shuffle algorithm itself that would be appreciated too.

[1]:http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle (Fisher-Yates shuffle)

What, if anything, is wrong with this shuffling algorithm and how can I know?

The famous Fisher-Yates shuffle algorithm can be used to randomly permute an array A of length N:

    For k = 1 to N
        Pick a random integer j from k to N
        Swap A[k] and A[j]

A common mistake that I&#39;ve been told over and over again not to make is this:

    For k = 1 to N
        Pick a random integer j from 1 to N
        Swap A[k] and A[j]

That is, instead of picking a random integer from k to N, you pick a random integer from 1 to N.

What happens if you make this mistake?  I know that the resulting permutation isn&#39;t uniformly distributed, but I don&#39;t know what guarantees there are on what the resulting distribution will be.  In particular, does anyone have an expression for the probability distributions over the final positions of the elements?

What distribution do you get from this broken random shuffle?

How can I shuffle a multidimensional array by row only in Python (so do not shuffle the columns).

**I am looking for the most efficient solution, because my matrix is very huge. Is it also possible to do this highly efficient on the original array (to save memory)?** 

Example:

    import numpy as np
    X = np.random.random((6, 2))
    print(X)
    Y = ???shuffle by row only not colls???
    print(Y)

What I expect now is original matrix:

    [[ 0.48252164  0.12013048]
     [ 0.77254355  0.74382174]
     [ 0.45174186  0.8782033 ]
     [ 0.75623083  0.71763107]
     [ 0.26809253  0.75144034]
     [ 0.23442518  0.39031414]]

Output shuffle the rows not cols e.g.:

    [[ 0.45174186  0.8782033 ]
     [ 0.48252164  0.12013048]
     [ 0.77254355  0.74382174]
     [ 0.75623083  0.71763107]
     [ 0.23442518  0.39031414]
     [ 0.26809253  0.75144034]]


Numpy shuffle multidimensional array by row only, keep column order unchanged

I need to randomly &#39;sort&#39; a list of integers (0-1999) in the most efficient way possible.  Any ideas?

Currently, I am doing something like this:

    bool[] bIndexSet = new bool[iItemCount];

    for (int iCurIndex = 0; iCurIndex &lt; iItemCount; iCurIndex++)
    {
        int iSwapIndex = random.Next(iItemCount);
        if (!bIndexSet[iSwapIndex] &amp;&amp; iSwapIndex != iCurIndex)
        {
            int iTemp = values[iSwapIndex];
            values[iSwapIndex] = values[iCurIndex];
            values[iCurIndex] = values[iSwapIndex];
            bIndexSet[iCurIndex] = true;
            bIndexSet[iSwapIndex] = true;
        }
    }

All Shuffle Solutions on Gang of Coders

Total of 23 Shuffle Solutions