Bạn phải điền một mảng với mỗi số từ 0-nbao gồm. Không có số nên lặp lại. Tuy nhiên, chúng phải theo thứ tự ngẫu nhiên.

Quy tắc

Tất cả các quy tắc golf-code tiêu chuẩn và sơ hở tiêu chuẩn đều bị cấm

Các mảng phải được tạo giả ngẫu nhiên. Mỗi hoán vị có thể nên có một xác suất bằng nhau.

Đầu vào

n theo bất kỳ cách nào được cho phép trong bài đăng I / O trên meta.

Đầu ra

Các dãy số được xáo trộn từ 0-nbao gồm.

Perl 6 , 14 byte

{pick *,0..$_}

Thử nó

Mở rộng:

{           # 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

Hãy thử trực tuyến!

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

Bình thường, 3 byte

.Sh

Trình diễn

.Slà xáo trộn. Nó ngầm định đưa một số nguyên đầu vào vào nphạm vi [0, 1, ..., n-1]. hlà +1, và đầu vào được thực hiện ngầm.

R , 16 byte

sample(0:scan())

đọc từ stdin. samplelấy mẫu ngẫu nhiên từ vectơ đầu vào, trả về một chuỗi ngẫu nhiên (giả).

Hãy thử trực tuyến!

Thạch , 3 byte

0rẊ

Hãy thử trực tuyến!

Giải thích:

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

Giải pháp thay thế, 3 byte

‘ḶẊ

Giải trình:

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

Hãy thử trực tuyến!

Python 2 , 51 byte

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

Hãy thử trực tuyến!

Có random.shuffle()nhưng nó sửa đổi đối số tại chỗ thay vì trả lại ...

PHP, 42 byte

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

Hãy thử trực tuyến!

Bash, 18 11 byte

shuf -i0-$1

Hãy thử trực tuyến!

Toán học, 24 byte

RandomSample@Range[0,#]&

MATL , 4 byte

QZ@q

Hãy thử trực tuyến!

Giải trình

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

Brachylog , 2 byte

⟦ṣ

Hãy thử trực tuyến!

Giải trình

⟦     Range from 0 to Input
 ṣ    Shuffle

Japt , 4 byte

ò öx

Dùng thử trực tuyến

    :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());

Điều này trả về một IOrderedEnumerable, tôi hy vọng điều đó ổn, nếu không tôi cần thêm một vài byte cho một .ToArray ()

CJam , 7 6 byte

Đã xóa 1 byte nhờ Erik the Outgolfer .

{),mr}

Đây là một khối ẩn danh (hàm) lấy một số nguyên từ ngăn xếp và thay thế nó bằng kết quả. Hãy thử trực tuyến!

Giải trình

{     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 và được sửa lỗi nhờ @ OlivierGrégoire .
-4 byte nhờ @Jakob .
-10 byte bằng cách loại bỏ .toArray().

Giải trình:

Hãy thử nó ở đây.

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 byte

#╟

Hãy thử trực tuyến!

Bình, 4 byte

.S}0

Hãy thử nó ở đây!

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

Hàm đệ quy khởi tạo từ đầu của mảng trên đường vào và hoán đổi với một phần tử ngẫu nhiên trước khi nó xuất hiện.

Than , 33 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

Rõ ràng phải mất 17 byte để loại bỏ một phần tử khỏi danh sách trong Char than.

Chỉnh sửa: Ngày nay, nó chỉ mất ba byte, giả sử bạn muốn xóa tất cả các lần xuất hiện của mục khỏi danh sách. Điều này cộng với các thay đổi Char than khác đã cắt câu trả lời xuống còn 21 byte: Hãy thử trực tuyến!

APL (Dyalog) , 5 byte

?⍨1+⊢

Hãy thử trực tuyến!

Giả định ⎕IO←0 , được mặc định trên nhiều máy.

Giải trình

⊢ lập luận đúng

1+ thêm 1 vào nó

?⍨tạo các số 0 .. 1+⊢-1 và giải quyết ngẫu nhiên chúng trong một mảng để không có hai số lặp lại

q / kdb +, 11 byte

Giải pháp:

{(0-x)?1+x}

Thí dụ:

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

Giải trình:

Sử dụng ? toán tử với đầu vào phủ định để đưa ra danh sách đầy đủ 0->nmà không trùng lặp:

{(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 (nhàm chán)

randIntNoRep(0,Ans

Đúng, một nội dung. randIntNoRep(là mã thông báo hai byte và Anslà một byte.

Vui hơn, 34 byte:

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

Trực tiếp từ tibasicdev . Có thể chơi gôn, nhưng tôi chưa tìm thấy gì.

Điều này làm gì: Sắp xếp một mảng ngẫu nhiên, di chuyển các phần tử của đối số thứ hai ( L₁ở đây) theo cùng cách với các phần tử tương ứng của chúng.

JavaScript (ES6), 51 byte

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

Aceto , 15 14 16 byte

@lXp
Y!`n
zi&
0r

Nhấn số 0 trên ngăn xếp, đọc một số nguyên, xây dựng một phạm vi và xáo trộn nó:

Y
zi
0r

Đặt dấu bắt, độ dài kiểm tra cho 0 và thoát (trong trường hợp đó):

@lX
 !`

Khác in giá trị, một dòng mới và quay lại kiểm tra độ dài:

   p
   n
  &

(Tôi đã phải thay đổi mã vì tôi nhận ra mình đã đọc sai câu hỏi và đã xây dựng một phạm vi từ 1-n, không phải 0-n.)

Đi , 92 byte

Chủ yếu là thua nhu cầu gieo hạt PRNG.

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

Hãy thử trực tuyến!

Ruby, 20 byte

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

8 , 42 36 34 byte

Mã

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

SED (Sơ đồ hiệu ứng ngăn xếp) là n -- a

Cách sử dụng và ví dụ

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

Tạo một mảng của hình thức

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

Sau đó sắp xếp nó và trả về các phần tử cuối cùng theo thứ tự mới

J, 11 byte

(?@!A.i.)>:

Giải trình:

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

Ví dụ:

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!