16
\$\begingroup\$

You must fill an array with every number from 0-n inclusive. No numbers should repeat. However they must be in a random order.

Rules

All standard rules and standard loopholes are banned

The array must be generated pseudo-randomly. Every possible permutation should have a equal probability.

Input

n in any way allowed in the I/O post on meta.

Output

The array of numbers scrambled from 0-n inclusive.

\$\endgroup\$
8
  • \$\begingroup\$ the output can be separated by newlines? \$\endgroup\$
    – DrnglVrgs
    Commented May 30, 2017 at 20:48
  • \$\begingroup\$ @Riley opps that was meant to be gone sorry. \$\endgroup\$
    – user63187
    Commented May 31, 2017 at 0:48
  • \$\begingroup\$ @DrnglVrgs yes it can \$\endgroup\$
    – user63187
    Commented May 31, 2017 at 0:48
  • \$\begingroup\$ By "numbers" I assume you mean "integers"? \$\endgroup\$
    – Adalynn
    Commented Aug 10, 2017 at 1:12
  • 1
    \$\begingroup\$ @KevinCruijssen IMO lists = array but with searching support. So sure use a list \$\endgroup\$
    – user63187
    Commented Aug 11, 2017 at 14:59

37 Answers 37

9
\$\begingroup\$

Perl 6, 14 bytes

{pick *,0..$_}

Try it

Expanded:

{           # bare block lambda with implicit parameter 「$_」

  pick      # choose randomly without repeats
    *,      # Whatever (all)
    0 .. $_ # Range from 0, to the input (inclusive)
}
\$\endgroup\$
8
\$\begingroup\$

05AB1E, 3 bytes

Ý.r

Try it online!

Ý   # Make a list from 0 to input
 .r # Shuffle it randomly
\$\endgroup\$
8
\$\begingroup\$

Pyth, 3 bytes

.Sh

Demonstration

.S is shuffle. It implicitly casts an input integer n to the range [0, 1, ..., n-1]. h is +1, and the input is taken implicitly.

\$\endgroup\$
7
\$\begingroup\$

R, 16 bytes

sample(0:scan())

reads from stdin. sample randomly samples from the input vector, returning a (pseudo)random sequence.

Try it online!

\$\endgroup\$
6
\$\begingroup\$

Jelly, 3 bytes

0rẊ

Try it online!

Explanaion:

0rẊ 
0r  Inclusive range 0 to input.
  Ẋ Shuffle.
    Implicit print.

Alternate solution, 3 bytes

‘ḶẊ

Explanation:

‘ḶẊ
‘   Input +1
 Ḷ  Range 0 to argument.
  Ẋ Shuffle.

Try it online!

\$\endgroup\$
5
\$\begingroup\$

Python 2, 51 bytes

lambda n:sample(range(n+1),n+1)
from random import*

Try it online!

There is random.shuffle() but it modifies the argument in place instead of returning it...

\$\endgroup\$
2
  • \$\begingroup\$ You can use random.shuffle \$\endgroup\$ Commented Apr 9, 2018 at 17:01
  • \$\begingroup\$ @cairdcoinheringaahing Yeah, but that wouldn't work. For example, lambda n:shuffle(range(n+1)) wouldn't write the output anywhere. \$\endgroup\$ Commented Apr 9, 2018 at 19:18
5
\$\begingroup\$

PHP, 42 Bytes

$r=range(0,$argn);shuffle($r);print_r($r);

Try it online!

\$\endgroup\$
5
\$\begingroup\$

Bash, 18 11 bytes

shuf -i0-$1

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ If newlines are allowed we can forget the echo part \$\endgroup\$
    – DrnglVrgs
    Commented May 30, 2017 at 20:53
3
\$\begingroup\$

Mathematica, 24 bytes

RandomSample@Range[0,#]&
\$\endgroup\$
3
\$\begingroup\$

MATL, 4 bytes

QZ@q

Try it online!

Explanation

Q     % Implicitly input n. Add 1
Z@    % Random permutation of [1 2 ... n+1]
q     % Subtract 1, element-wise. Implicitly display
\$\endgroup\$
3
\$\begingroup\$

Brachylog, 2 bytes

⟦ṣ

Try it online!

Explanation

⟦     Range from 0 to Input
 ṣ    Shuffle
\$\endgroup\$
3
\$\begingroup\$

Japt, 4 bytes

ò öx

Try it online


    :Implicit input of integer U
ò   :Generate array of 0 to U.
öx  :Generate random permutation of array.
    :Implicit output of result.
\$\endgroup\$
2
  • \$\begingroup\$ Gosh darn it, I thought öx would be enough until I noticed the "inclusive" part. (You could replace the x with almost anything else, btw) \$\endgroup\$ Commented May 30, 2017 at 20:38
  • \$\begingroup\$ @ETHproductions, that was my first thought too. \$\endgroup\$
    – Shaggy
    Commented May 30, 2017 at 20:55
3
\$\begingroup\$

C#, 76 bytes

using System.Linq;i=>new int[i+1].Select(x=>i--).OrderBy(x=>Guid.NewGuid());

This returns an IOrderedEnumerable, I hope that's okay, or else I need a few more bytes for a .ToArray()

\$\endgroup\$
3
\$\begingroup\$

CJam, 7 6 bytes

1 byte removed thanks to Erik the Outgolfer.

{),mr}

This is an anonymous block (function) that takes an integer from the stack and replaces it with the result. Try it online!

Explanation

{     e# Begin block
)     e# Increment: n+1
,     e# Range: [0 1 ... n]
mr    e# Shuffle
}     e# End block
\$\endgroup\$
2
  • \$\begingroup\$ Isn't {),mr} 1 byte shorter? \$\endgroup\$ Commented May 31, 2017 at 18:43
  • \$\begingroup\$ @EriktheOutgolfer Indeed! Thanks \$\endgroup\$
    – Luis Mendo
    Commented May 31, 2017 at 21:19
3
\$\begingroup\$

Java 8, 114 111 97 bytes

import java.util.*;n->{List l=new Stack();for(;n>=0;l.add(n--));Collections.shuffle(l);return l;}

-3 bytes and bug-fixed thanks to @OlivierGrégoire.
-4 bytes thanks to @Jakob.
-10 bytes by removing .toArray().

Explanation:

Try it here.

import java.util.*;        // Required import for List, Stack and Collections
n->{                       // Method with integer parameter and Object-array return-type
  List l=new Stack();      //  Initialize a List
  for(;n>=0;l.add(n--));   //  Loop to fill the list with 0 through `n`
  Collections.shuffle(l);  //  Randomly shuffle the List
  return l;                //  Convert the List to an Object-array and return it
}                          // End of method
\$\endgroup\$
4
  • 2
    \$\begingroup\$ Bug: doesn't include n. Fix and golf: for(n++;--n>=0;l.add(n));. Also, I say you don't need to return an array. Array and list are the same in most language, so just return the list. \$\endgroup\$ Commented Aug 10, 2017 at 13:23
  • \$\begingroup\$ @OlivierGrégoire Woops.. That's what you get for not checking properly and just posting.. Thanks for the bug-fix (and 4 bytes saved in the process). \$\endgroup\$ Commented Aug 10, 2017 at 13:27
  • 1
    \$\begingroup\$ Well, three actually, because I edited again, having myself introduced another bug: > should be >=. \$\endgroup\$ Commented Aug 10, 2017 at 13:28
  • 1
    \$\begingroup\$ -4 bytes: use a Stack instead of a Vector and change your loop to for(;n>=0;l.add(n--));. And returning a java.util.List is definitely fine. \$\endgroup\$
    – Jakob
    Commented Aug 10, 2017 at 14:10
2
\$\begingroup\$

Ohm, 2 bytes

#╟

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ This is a better link. \$\endgroup\$ Commented May 31, 2017 at 10:20
2
\$\begingroup\$

Pyth, 4 Bytes

.S}0

Try it here!

\$\endgroup\$
3
  • \$\begingroup\$ You can golf to 3 bytes. .S with an integer argument is the same as .SU, and [0..n] can be coded as Uh, so you can use .SUh, which then becomes .Sh. \$\endgroup\$ Commented May 31, 2017 at 18:46
  • \$\begingroup\$ @EriktheOutgolfer thanks for the hint, but as someone has alread posted the solution you propose I will leave this as this. \$\endgroup\$
    – KarlKastor
    Commented May 31, 2017 at 21:32
  • \$\begingroup\$ Well, it's borderline whether that should've been a separate answer or not, but I believe it counts as a dupe, so even it being allowed, I'd consider it just builtin substitution, so nah, I didn't want to post separate, but isaacg did. \$\endgroup\$ Commented Jun 1, 2017 at 9:30
2
\$\begingroup\$

C, 75 bytes

a[99],z,y;f(n){if(n){a[n]=--n;f(n);z=a[n];a[n]=a[y=rand()%(n+1)];a[y]=z;}}

Recursive function that initializes from the array's end on the way in, and swaps with a random element before it on the way out.

\$\endgroup\$
4
  • \$\begingroup\$ What if n > 98? \$\endgroup\$ Commented May 31, 2017 at 15:11
  • \$\begingroup\$ It would fail, of course, but input range wasn't specified in the problem. Please don't make me malloc :) \$\endgroup\$ Commented May 31, 2017 at 15:40
  • \$\begingroup\$ change a into a para to fit the rule more? \$\endgroup\$
    – l4m2
    Commented Apr 9, 2018 at 16:00
  • \$\begingroup\$ 67 bytes \$\endgroup\$
    – ceilingcat
    Commented Apr 1, 2019 at 3:57
2
\$\begingroup\$

Ruby, 20 bytes

->n{[*0..n].shuffle}

\$\endgroup\$
2
\$\begingroup\$

Charcoal, 33 bytes

A…·⁰NβFβ«AβδA‽δθPIθ↓A⟦⟧βFδ¿⁻θκ⊞βκ

Try it online! Link is to verbose version of code.

Apparently it takes 17 bytes to remove an element from a list in Charcoal.

Edit: These days it only takes three bytes, assuming you want to remove all occurrences of the item from the list. This plus other Charcoal changes cut the answer down to 21 bytes: Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ Yikes that is a lot \$\endgroup\$
    – user63187
    Commented Jun 1, 2017 at 1:16
2
\$\begingroup\$

APL (Dyalog), 5 bytes

?⍨1+⊢

Try it online!

Assumes ⎕IO←0, which is default on many machines.

Explanation

the right argument

1+ add 1 to it

?⍨ generate numbers 0 .. 1+⊢-1 and randomly deal them in an array so that no two numbers repeat

\$\endgroup\$
2
\$\begingroup\$

q/kdb+, 11 bytes

Solution:

{(0-x)?1+x}

Example:

q){(0-x)?1+x}10
5 9 7 1 2 4 8 0 3 10
q){(0-x)?1+x}10
6 10 2 8 4 5 9 0 7 3
q){(0-x)?1+x}10
9 6 4 1 10 8 2 7 0 5

Explanation:

Use the ? operator with a negative input to give the full list of 0->n without duplicates:

{(0-x)?1+x} / solution
{         } / lambda expression
         x  / implicit input
       1+   / add one
      ?     / rand
 (0-x)      / negate x, 'dont put item back in the bag'
\$\endgroup\$
2
\$\begingroup\$

TI-83 BASIC, 5 bytes (boring)

randIntNoRep(0,Ans

Yep, a builtin. randIntNoRep( is a two-byte token, and Ans is one byte.

More fun, 34 bytes:

Ans→N
seq(X,X,0,N→L₁
rand(N+1→L₂
SortA(L₂,L₁
L₁

Straight from tibasicdev. Probably golfable, but I haven't found anything yet.

What this does: Sorts a random array, moving elements of the second arg (L₁ here) in the same way as their corresponding elements.

\$\endgroup\$
1
\$\begingroup\$

JavaScript (ES6), 51 bytes

n=>[...Array(n+1).keys()].sort(_=>.5-Math.random())
\$\endgroup\$
6
  • 2
    \$\begingroup\$ I don't think this is uniform; I've tried f(5) 10 times and 5 has been one of the last two items every time. \$\endgroup\$ Commented May 30, 2017 at 21:47
  • \$\begingroup\$ Just ran it again a couple of times myself and got 1,5,4,0,2,3 & 1,0,2,5,3,4. EDIT: And a few more prnt.sc/fe0goe \$\endgroup\$
    – Shaggy
    Commented May 30, 2017 at 22:27
  • 4
    \$\begingroup\$ Just ran a quick test which runs f(5) 1e5 times and finds the average position of each number in the results. The resulting array was [ 1.42791, 1.43701, 2.00557, 2.6979, 3.3993, 4.03231 ], so I don't think it's uniform. (code) \$\endgroup\$ Commented May 30, 2017 at 22:35
  • \$\begingroup\$ I think I have a 93 byte solution that could work. n=>(a=[...Array(n).keys(),n++]).reduce((a,v,i)=>([a[i],a[j]]=[a[j=n*Math.random()|0],v],a),a)? \$\endgroup\$
    – kamoroso94
    Commented May 31, 2017 at 7:39
  • \$\begingroup\$ Sorting on the result of random() isn't uniform. See (for example) en.wikipedia.org/wiki/BrowserChoice.eu#Criticism \$\endgroup\$
    – Neil
    Commented May 31, 2017 at 9:07
1
\$\begingroup\$

Aceto, 15 14 16 bytes

@lXp
Y!`n
zi&
0r

Push zero on the stack, read an integer, construct a range and shuffle it:

Y
zi
0r

Set a catch mark, test length for 0, and (in that case) exit:

@lX
 !`

Else print the value, a newline, and jump back to the length test:

   p
   n
  &

(I had to change the code because I realized I misread the question and had constructed a range from 1-n, not 0-n.)

\$\endgroup\$
1
\$\begingroup\$

Go, 92 bytes

Mostly losing to the need to seed the PRNG.

import(."fmt";."math/rand";."time")
func f(n int){Seed(Now().UnixNano());Println(Perm(n+1))}

Try it online!

\$\endgroup\$
1
\$\begingroup\$

8th, 42 36 34 bytes

Code

>r [] ' a:push 0 r> loop a:shuffle

SED (Stack Effect Diagram) is n -- a

Usage and example

ok> 5 >r [] ' a:push 0 r> loop a:shuffle .
[2,5,0,3,1,4]
\$\endgroup\$
1
\$\begingroup\$

Javascript (ES6), 68 bytes

n=>[...Array(n+1)].map((n,i)=>[Math.random(),i]).sort().map(n=>n[1])

Creates an array of form

[[Math.random(), 0],
 [Math.random(), 1],
 [Math.random(), 2],...]

Then sorts it and returns the last elements in the new order

\$\endgroup\$
1
\$\begingroup\$

J, 11 Bytes

(?@!A.i.)>:

Explanation:

         >:   | Increment
(?@!A.i.)     | Fork, (f g h) n is evaluated as (f n) g (h n)
      i.      | Integers in range [0,n) inclusive
 ?@!          | Random integer in the range [0, n!)
    A.        | Permute right argument according to left

Examples:

    0 A. i.>:5
0 1 2 3 4 5
    1 A. i.>:5
0 1 2 3 5 4
    (?@!A.i.)>: 5
2 3 5 1 0 4
    (?@!A.i.)>: 5
0 3 5 1 2 4
\$\endgroup\$
1
\$\begingroup\$

JavaScript ES6, 60 bytes, uniform distribute

f=n=>n?(z=f(n-1),z[n]=z[y=Math.random()*-~n|0],z[y]=n,z):[0]

s={};
for(i=0; i<1000; i++) k=f(2), s[k]=-~s[k];
for(i in s) console.log(i, s[i]);

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.