140byt.es -- Array Shuffle

README.md

Shuffle an array in-place using Fisher–Yates shuffle

var shuffle = function(a,b,c){for(b=a.length;b;c=0|b*Math.random(),a[c]=[a[--b],a[b]=a[c]][0]);}

var a = [1, 2, 3, 4, 5, 6, 7];

shuffle(a); console.log(a);
// [2, 3, 6, 7, 4, 1, 5]

shuffle(a); console.log(a);
// [3, 6, 5, 2, 1, 4, 7]

annotated.js

function // Shuffle
  (a,    // Array

// Local variables:
   i,    // Element iterator
   j)    // Element to swap
{

  for (
    i = a.length;          // Start at the end
    i;                     // Iterate over the whole array except the first element

    j = 0 |                // Pick (Math.floor)
        i * Math.random(), // A random position before the current element

                           // --i
                           // Swap a[i] and a[j]
    a[j] = [a[--i], a[i] = a[j]] [0]
  );

}

index.js

function(a,b,c){for(b=a.length;b;c=0|b*Math.random(),a[c]=[a[--b],a[b]=a[c]][0]);}

LICENSE.txt

Copyright (c) 2011 Christopher Chedeau, http://blog.vjeux.com/
 
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
 
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package.json

{
  "name": "array_shuffle",

  "description": "Shuffle an Array",

  "keywords": [
    "140bytes",
    "shuffle",
    "array" 
  ]
}

@mattpass will donate 3 Euro to charity for each character golfed away from this function. We found a solution worth 78 81 Euro (thanks to tsaniel and p01) but I'm not sure if using sort is acceptable. What do you think?

function(a){a.sort(function(){return.5-Math.random()})}

This works perfectly for all kinds of arrays but is about 5 times slower than the original Fisher–Yates implementation.

Edit: About being original. Come on. I'm sure this was done a million times before. Nevertheless, I came up with the idea myself without using Google.

My early snippet:
https://gist.github.com/1345090

function(a){with(a)for(a=length;a;)push(splice(Math.random()*a--,1)[0])}

Updated.

By the way, maybe we can save 1 byte for the sort version by

function(a){a.sort(function(){return.5-Math.random()})}

?

@tsaniel, I didn't know that, thanks. I tried function f(a,b){return b?.5-Math.random():a.sort(f)} (edit: fixed, thanks @vjeux) but this will turn into an endless loop if the array contains something that coerces to false.

We can save one more byte on the short version ;)

function c(a,b){return b||a.sort(c)&&.5-Math.random()}

EDIT: Nice twist @maettig also I didn't think of the edge case.

@maettig Shouldn't the condition be inverted?

function c(a,b){return b?Math.random()-.5:a.sort(c)}

a=[1, 2, 3, 4, 5, 6, 7, 8]
c(a)
> [1, 3, 4, 5, 7, 6, 2, 8]

c([1,0])
> TypeError: Object 1 has no method 'sort'

I'm afraid all of this will turn into an endless loop if called with e.g. [1,0,2] (or will fail as mentioned by @tsaniel above). Here is an other idea to save a byte, but this also shuffles nested arrays (except for the last one): function f(a){a.pop&&a.sort(f);return.5-Math.random()}

@maettig Same byte count but returns the array instead of a random number. However it doesn't compare well nested arrays.

function c(a){return a.pop?a.sort(c):Math.random()-.5}

@maettig, Looks like I wasn't clear. My version does not have the same "semantics" as yours. It doesn't shuffle the inner arrays but instead returns an invalid value in the comparison function (a.sort().toString()).

@vjeux, I'm sorry, I don't understand. The version function c(a){return a.pop?a.sort(c):Math.random()-.5} does shuffle the inner arrays, but not the outer one (because of the invalid value). Calling var a=[[1,2],[3,4],[5,6]]; a=shuffle(a); changes the array to [[2,1],[4,3],[5,6]], for example, no matter if it's called with or without a=. My version always returns a random number and therefor shuffles the outer array too. But it's a bad implementation anyway, it's not worth the trouble for saving a single byte. ;-)

Yes, you are right! I spoke too fast :) Sorry

I played around with pseudorandom numbers and it works but is longer than simply calling Math.random(). And it's not self contained, it needs to be called with an initial value for the generator, e.g. shuffle(a, new Date().getTime()). Without, it will create the same result every time.

function(a,b){a.sort(function(){return.5-(b=b*7%99)%2})}

In the end I came up with a solution worth 108 Euro. No, not really. It's clearly a fake but it kind of shuffles all types of arrays. For example, the array [1,2,3,4,5,6,7,8,9,10] becomes [2,7,8,3,9,6,4,10,1,5]. Looks random but isn't. It's the same every time. The function also accepts an initial value but since it's boolean there are only two possibilities how a specific array is ordered.

function(a,b){a.sort(function(){return b=!b})}