È necessario riempire un array con ogni numero 0-ncompreso. Nessun numero dovrebbe ripetere. Tuttavia, devono essere in ordine casuale.

Regole

Sono vietate tutte le regole standard di code-golf e scappatoie standard

L'array deve essere generato in modo pseudo casuale. Ogni possibile permutazione dovrebbe avere la stessa probabilità.

Ingresso

n in alcun modo consentito nel post I / O su meta.

Produzione

L'array di numeri è composto da 0-ninclusivo.

Perl 6 , 14 byte

{pick *,0..$_}

Provalo

Allargato:

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

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

05AB1E , 3 byte

Ý.r

Provalo online!

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

Pyth, 3 byte

.Sh

Dimostrazione

.Sè shuffle. Si getta implicitamente un numero intero di ingresso nalla gamma [0, 1, ..., n-1]. hè +1, e l'input è preso implicitamente.

R , 16 byte

sample(0:scan())

legge da stdin. samplecampiona casualmente dal vettore di input, restituendo una sequenza (pseudo) casuale.

Provalo online!

Gelatina , 3 byte

0rẊ

Provalo online!

Explanaion:

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

Soluzione alternativa, 3 byte

‘ḶẊ

Spiegazione:

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

Provalo online!

Python 2 , 51 byte

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

Provalo online!

C'è random.shuffle()ma modifica l'argomento in atto invece di restituirlo ...

PHP, 42 byte

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

Provalo online!

Bash, 18 11 byte

shuf -i0-$1

Provalo online!

Mathematica, 24 byte

RandomSample@Range[0,#]&

MATL , 4 byte

QZ@q

Provalo online!

Spiegazione

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

Brachylog , 2 byte

⟦ṣ

Provalo online!

Spiegazione

⟦     Range from 0 to Input
 ṣ    Shuffle

Japt , 4 byte

ò öx

Provalo online

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

C #, 76 byte

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

Questo restituisce un IOrderedEnumerable, spero che vada bene, altrimenti ho bisogno di qualche byte in più per un .ToArray ()

CJam , 7 6 byte

1 byte rimosso grazie a Erik the Outgolfer .

{),mr}

Questo è un blocco (funzione) anonimo che prende un numero intero dallo stack e lo sostituisce con il risultato. Provalo online!

Spiegazione

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

Java 8, 114 111 97 byte

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

-3 byte e correzione di errori grazie a @ OlivierGrégoire .
-4 byte grazie a @Jakob .
-10 byte rimuovendo .toArray().

Spiegazione:

Provalo qui.

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 byte

#╟

Provalo online!

Pyth, 4 byte

.S}0

Provalo qui!

C, 75 byte

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

Funzione ricorsiva che si inizializza dall'estremità dell'array al momento dell'ingresso e si scambia con un elemento casuale prima che esso venga espulso.

Carbone , 33 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice.

Apparentemente sono necessari 17 byte per rimuovere un elemento da un elenco in Carbone.

Modifica: in questi giorni ci vogliono solo tre byte, supponendo che si desideri rimuovere tutte le occorrenze dell'elemento dall'elenco. Questo più altre modifiche al carbone riducono la risposta a 21 byte: provala online!

APL (Dyalog) , 5 byte

?⍨1+⊢

Provalo online!

Presuppone ⎕IO←0, che è predefinito su molte macchine.

Spiegazione

⊢ l'argomento giusto

1+ aggiungere 1 ad esso

?⍨generare numeri 0 .. 1+⊢-1 e distribuirli casualmente in un array in modo che non si ripetano due numeri

q / kdb +, 11 byte

Soluzione:

{(0-x)?1+x}

Esempio:

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

Spiegazione:

Utilizzare l' ? operatore con un input negativo per fornire l'elenco completo di 0->nsenza duplicati:

{(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 byte (noioso)

randIntNoRep(0,Ans

Sì, incorporato. randIntNoRep(è un token a due byte ed Ansè un byte.

Più divertente, 34 byte:

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

Direttamente da tibasicdev . Probabilmente giocabile a golf, ma non ho ancora trovato nulla.

Cosa fa: ordina un array casuale, spostando gli elementi del secondo arg ( L₁qui) allo stesso modo dei loro elementi corrispondenti.

JavaScript (ES6), 51 byte

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

Aceto , 15 14 16 byte

@lXp
Y!`n
zi&
0r

Premi zero sullo stack, leggi un numero intero, costruisci un intervallo e mescolalo:

Y
zi
0r

Impostare un segno di cattura, la lunghezza del test per 0 e (in tal caso) uscire:

@lX
 !`

Altrimenti stampa il valore, una nuova riga e torna al test di lunghezza:

   p
   n
  &

(Ho dovuto cambiare il codice perché mi sono reso conto di aver letto male la domanda e avevo costruito un intervallo da 1-n, non 0-n.)

Vai , 92 byte

Per lo più perdere la necessità di seminare il PRNG.

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

Provalo online!

Rubino, 20 byte

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

8 , 42 36 34 byte

Codice

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

SED (Stack Effect Diagram) è n -- a

Uso ed esempio

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

Javascript (ES6), 68 byte

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

Crea una matrice di moduli

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

Quindi lo ordina e restituisce gli ultimi elementi nel nuovo ordine

J, 11 byte

(?@!A.i.)>:

Spiegazione:

         >:   | 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

Esempi:

    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 byte

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

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

Provalo online!