您必须使用每个数字（0-n含）来填充数组。没有数字应该重复。但是，它们必须是随机顺序的。

规则

禁止所有标准代码高尔夫球规则和标准漏洞

该数组必须是伪随机生成的。每个可能的排列都应具有相等的概率。

输入值

n 以meta的I / O帖子中允许的任何方式。

输出量

数字数组从0-n包容性开始逐渐增加。

Perl 6、14个字节

{pick *,0..$_}

尝试一下

展开：

{           # bare block lambda with implicit parameter ｢$_｣

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

05AB1E，3个字节

Ý.r

在线尝试！

Ý   # Make a list from 0 to input
 .r # Shuffle it randomly

Pyth，3个字节

.Sh

示范

.S洗牌。它隐式地将输入整数强制转换n为range [0, 1, ..., n-1]。h是+1，并且输入是隐式的。

R，16个字节

sample(0:scan())

从读取stdin。sample从输入向量中随机采样，返回一个（伪）随机序列。

在线尝试！

果冻，3个字节

0rẊ

在线尝试！

说明：

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

备用解决方案，3个字节

‘ḶẊ

说明：

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

在线尝试！

Python 2，51个字节

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

在线尝试！

有，random.shuffle()但是它修改了参数而不是返回参数。

PHP，42字节

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

在线尝试！

Bash，18 11个字节

shuf -i0-$1

在线尝试！

Mathematica，24个字节

RandomSample@Range[0,#]&

MATL，4个字节

QZ@q

在线尝试！

说明

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

Brachylog，2个字节

⟦ṣ

在线尝试！

说明

⟦     Range from 0 to Input
 ṣ    Shuffle

Japt，4个字节

ò öx

在线尝试

    :Implicit input of integer U
ò   :Generate array of 0 to U.
öx  :Generate random permutation of array.
    :Implicit output of result.

C＃，76个字节

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

这将返回一个IOrderedEnumerable，我希望可以，否则我需要更多字节用于.ToArray（）

CJam，7 6字节

多亏了Egg the Outgolfer删除了1个字节。

{),mr}

这是一个匿名块（函数），它从堆栈中获取一个整数并将其替换为结果。 在线尝试！

说明

{     e# Begin block
)     e# Increment: n+1
,     e# Range: [0 1 ... n]
mr    e# Shuffle
}     e# End block

Java 8，114 111 97字节

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

-3个字节，并通过@OlivierGrégoire修复了错误。
-4个字节，感谢@Jakob。
删除-10个字节.toArray()。

说明：

在这里尝试。

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

Ohm, 2 bytes

#╟

Try it online!

Pyth, 4 Bytes

.S}0

Try it here!

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.

Charcoal, 33 bytes

Ａ…·⁰ＮβＦβ«ＡβδＡ‽δθＰＩθ↓Ａ⟦⟧βＦδ¿⁻θκ⊞βκ

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!

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

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'

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.

JavaScript (ES6), 51 bytes

n=>[...Array(n+1).keys()].sort(_=>.5-Math.random())

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.)

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!

Ruby, 20 bytes

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

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]

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

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

Tcl, 90 bytes

proc R n {lsort -c {try expr\ rand()>.5 on 9} [if [incr n -1]+2 {concat [R $n] [incr n]}]}

Try it online!

proc R n {proc f a\ b {expr rand()>.5}
set i -1
while \$i<$n {lappend L [incr i]}
lsort -c f $L}

Try it online!