0-n포함 부터 모든 숫자로 배열을 채워야 합니다. 숫자는 반복해서는 안됩니다. 그러나 무작위 순서 여야합니다.

규칙

모든 표준 코드 골프 규칙 및 표준 허점은 금지되어 있습니다.

배열은 의사 랜덤으로 생성되어야합니다. 가능한 모든 순열은 같은 확률을 가져야합니다.

입력

n 메타에 대한 I / O 포스트에 어떤 식 으로든 허용됩니다.

산출

0-n포괄적 인 숫자의 배열입니다 .

펄 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를 암시 적으로 범위로 캐스트합니다 [0, 1, ..., n-1]. his +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.

온라인으로 사용해보십시오!

파이썬 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);

온라인으로 사용해보십시오!

배쉬, 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 바이트

Outgolfer Erik 덕분에 1 바이트가 제거되었습니다 .

{),mr}

이것은 스택에서 정수를 가져와 결과로 대체하는 익명 블록 (함수)입니다. 온라인으로 사용해보십시오!

설명

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

자바 (8), 114 (111) 97 바이트

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

@ OlivierGrégoire 덕분에 -3 바이트 및 버그 수정 . @Jakob
덕분에 -4 바이트 . 를 제거하여 -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

옴 , 2 바이트

#╟

온라인으로 사용해보십시오!

피 이스, 4 바이트

.S}0

여기 사용해보십시오!

C, 75 바이트

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;}}

도중에 배열의 끝에서 초기화하고 나가기 전에 임의의 요소로 교체하는 재귀 함수.

숯 , 33 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다.

분명히 Charcoal의 목록에서 요소를 제거하는 데 17 바이트가 걸립니다.

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!