Thử thách

Bài Sandbox

Cho một số nguyên dương (K)Xuất ra một số nguyên ngẫu nhiên đồng nhất (Y)giữa [0, K).

Nếu Y > 0Giả sử K = Yvà lặp lại quá trình cho đến khi Y = 0.

Quy tắc

• Đầu vào phải được in lúc đầu
• Định dạng đầu ra như bạn muốn
• Chương trình của bạn phải kết thúc.
• 0 phải là đầu ra cuối cùng, thay vào đó là một dòng trống 0

Bình thường , 6 5 4 byte

.uOW

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

Làm thế nào nó hoạt động

.uOW Chương trình đầy đủ. Lấy một số nguyên từ STDIN và xuất danh sách thành STDOUT.
.u Điểm tích lũy cố định. Áp dụng hàm đã cho với giá trị ban đầu đã cho,
        được gán ngầm cho đầu vào, cho đến khi kết quả đã xảy ra 
        trước khi được tìm thấy. Trả về danh sách kết quả trung gian.
   W Ứng dụng có điều kiện. Nếu đối số (giá trị hiện tại) là trung thực, thì
        áp dụng các chức năng dưới đây, nếu không để nó không thay đổi.
  O Số nguyên ngẫu nhiên trong phạm vi [0, N).
        IOW: tại mỗi lần lặp của .u, gán một biến N cho giá trị hiện tại, bắt đầu
        với đầu vào. Nếu N không bằng 0, thì chọn số nguyên ngẫu nhiên trong [0, N), khác
        trả về N không đổi. Bất cứ khi nào chúng ta gặp 0, lần lặp tiếp theo cũng phải
        kết quả là 0 và do đó vòng lặp dừng ở đó.

C (gcc) , 42 byte

f(_){printf("%d\n",_);(_=rand()%_)&&f(_);}

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

Sử dụng logic ngắn mạch và.

f(_){                 // f(int _) {
    printf("%d\n",_); // print argument and a newline
    (_=rand()%_)      // set _ to rand()%_
    &&f(_);}          // short-circuit AND to recursively call f if _ not zero

C (gcc) , 40 byte (w / o in giá trị ban đầu)

f(_){printf("%d\n",_=rand()%_);_&&f(_);}

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

Sử dụng logic ngắn mạch và.

f(_){              // f(int _) {
    printf("%d\n", // print an integer and a newline 
    _=             // The integer is _ which we set to...
    rand()%_);     // a random value modulo the input _
    _&&f(_);}      // short-circuit AND to recursively call f if _ not zero

R , 66 60 56 43 41 byte

function(n)while(print(n))n=sample(n,1)-1

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

MATL , 6 byte

`tYrqt

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

Giải trình

`        % Do...while
  t      %   Duplicate. Takes input (implicit) the first time
  Yr     %   Uniform random integer from 1 to n, included
  q      %   Subtract 1
  t      %   Duplicate. This will be used as loop condition
         % End (implicit). Proceeds with next iteration if non-zero
         % Display stack (implicit)

Pepe , 25 byte

Pepe là ngôn ngữ lập trình được tạo bởi người dùng Soaku .

REeErEErReEEreeEREEeEEree 

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

Giải trình:

REeErEErReEEreeEREEeEEree # full program

REeE                      # input as num, in stack 1
    rEE                   # create loop in stack 2 with name 0
       rReEE              # - output and preserve the number in stack 1
            reeE          # - output a newline "\n"
                REEeEE    # - random number by 0 to input
                      ree # goto loop with name 0 if stack 1 is not equal
                            to stack 2

Perl 6 , 18 byte

{$_,(^*).pick...0}

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

Khối mã ẩn danh trả về một danh sách các giá trị. Nếu bạn không quan tâm đến các số là phạm vi, bạn có thể làm:

{^$_,^*.pick...0}

cho 17 byte. Thật thú vị, một hàm ngẫu nhiên dựng sẵn khác roll, có cùng hành vi trong trường hợp này với cùng một lượng byte.

Perl 5 .10.0 -pl, 26 byte

say;say while$_=int rand$_

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

Thạch ,  4  3 byte

XƬ0

Đây là một liên kết đơn (hàm) in một mảng và trả về 0 .

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

Làm thế nào nó hoạt động

XƬ0  Monadic link. Argument: n

XƬ   Pseudo-randomly pick (X) an integer k in [1, ..., n], set n = k, and repeat.
     Do this 'til (Ƭ) the results are no longer unique and return the array of
     unique results, including the initial value of n.
     This stops once X returns k with argument k. The second k will be omitted
     from the return value.
  0  Print the resulting array and set the return value to 0.

Brachylog , 8 byte

ẉ?ℕ₁-₁ṙ↰

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

Giải trình

ẉ          Write the input followed by a linebreak
 ?ℕ₁       The input must be in [1, …, +∞)
    -₁ṙ    Generate an integer in [0, …, input - 1] uniformly at random
       ↰   Recursive call with that random integer as the new input

Đệ quy sẽ dừng lại một lần ?ℕ₁thất bại, đó là khi đầu vào là 0.

05AB1E , 8 7 byte

Δ=L<Ω0M

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

Giải trình

Δ         # loop until value doesn't change
 =        # print current value
  L<Ω     # push a random number in ([1 ... X] - 1)
          # will return -1 when X=0
     0M   # push max of that and 0

J, 13 byte

[:}:? ::]^:a:

Trên tàu điện ngầm, vì vậy, xin lỗi vì thiếu TIO (hy vọng không có sự chính xác).

Xuất ra một danh sách các giá trị.

Có lẽ cách tiếp cận APL sẽ ngắn hơn, nhưng đây là những gì tôi nghĩ.

Làm thế nào nó hoạt động

^:a: áp dụng nhiều lần cho đến khi hội tụ, lưu trữ kết quả trung gian trong một mảng.

?số nguyên ngẫu nhiên trong phạm vi [0, K)cho Klớn hơn 0. Đối với 0, nó mang lại một số nguyên ngẫu nhiên trong phạm vi (0,1). Đối với một số dấu phẩy động, nó lỗi.

::]bắt lỗi cho đầu vào ?và thay vì lỗi, hãy xuất đầu vào gây ra lỗi.

}: loại bỏ giá trị cuối cùng trong mảng (điều này sao cho số dấu phẩy động không xuất ra).

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

JavaScript (ES6), 38 37 byte

-1 byte nhờ @Arnauld

f=n=>[n,...n?f(Math.random()*n|0):[]]

f=n=>[n,...n?f(Math.random()*n|0):[]]

<input type=number id=a><button onclick="console.log(f(+a.value))">Test</button>

C, 38 byte

f(k){printf("%d ",k);k?f(rand()%k):0;}

Dùng thử trực tuyến

Ung dung

void f(int k){
    printf("%d ",k);
    if(k)
        f(rand()%k);
}

Pyth, 4 bytes

W
~O

Try it online!

This basically implements the algorithm:

$\begin{align} % Unknown environment algorithm :( &Q \gets \text{input} \\ &\mathbf{Repeat} \\ &\begin{array}{cl} 1. & temp \gets Q \\ 2. & Q \gets \text{unif}\{ 0, Q - 1 \} \\ 3. & \mathtt{Print}(temp) \end{array} \\ &\mathbf{Until} \quad temp = 0 \end{align}$

To translate the Pyth into the algorithm, we can mostly just examine what each character means. Since Pyth is written in prefix notation (i.e. * + 1 2 3 is (1 + 2) * 3) we can start from the left and fill in the arguments as we go.

W begins a traditional while loop. The first statement after it is the loop condition and the second statement after it is the loop body. If the second statement is empty it becomes a no-op. This while works exactly like the Python while, so it will evaluate non-zero integers as True and zero as false.

The first statement after the while begins with the newline character. This corresponds to Pyth's "print and return with a newline" function. This takes one argument, which is then printed and also returned unmodified. This allows us to print the intermediate steps while also performing the needed operations.

The argument passed to this print function begins with ~ which is a bit special. If the character immediately after ~ is a variable it takes two arguments, otherwise it takes one. Since O is not a variable ~ will consume only one argument. ~ functions a bit like += does in many conventional languages, though the closest operator would be the post-increment operator ++ from C. You may know that x++ will be like using x as the current value, but thereafter x will be x+1. ~ is the same idea, but generalised to whatever the result of the first argument is. How it picks what variable to assign to will be addressed later.

The argument of ~ is O which is very simple. When its one argument is an integer O returns a value from 0 to one less than that integer uniformly at random.

Now you may have noticed O does not have an argument. Here the Pyth interpreter kindly fills in a guess, which here is the variable Q. Q has a special meaning in Pyth: whenever it is present in a program the Pyth program begins with assigning Q to the input of the program. Since this is the first variable occurring in ~'s argument Q is also now the variable that ~ will assign a value to.

Summed up our "readable" program might look like:

while print_and_return( assign_variable( Q, unif(0, Q-1) ) ):
    pass

And one sample "run-through" might look like:

1. Q = 5
2. O returns 3, ~ returns 5, \n returns and prints 5 which is true
3. Q = 3
4. O returns 0, ~ returns 3, \n returns and prints 3 which is true
5. Q=0
6. O returns something irrelevant, ~ returns 0, \n returns and prints 0 which is false
7. Q = something irrelevant
8. Terminate

APL (Dyalog Unicode), 12 9 bytes

Anonymous tacit prefix function. Assumes ⎕IO (Index Origin) to be 0, which is default on many systems. Returns the final value (0) in addition to printing while run.

{⌊?⎕←⍵}⍣=

Try it online!

{…}⍣= apply the following function until stable:

 ⎕←⍵ output the argument

 ? return a uniformly distributed random number in the range 0 through that–1

 ⌊ round down (because ?0 gives a (0,1) float)

C (gcc), 40 42 bytes

Some idiot™ forgot to print the initial value first.

f(K){while(K)printf("%d\n",K,K=rand()%K);}

Don't panic.

x86 + rdrand, 19 bytes

Straightforward implementation. Takes input K in ecx and outputs to a buffer in ebx.

0000000a <start>:
   a:   0f c7 f0                rdrand %eax
   d:   31 d2                   xor    %edx,%edx
   f:   f7 f1                   div    %ecx
  11:   89 13                   mov    %edx,(%ebx)
  13:   83 c3 04                add    $0x4,%ebx
  16:   89 d1                   mov    %edx,%ecx
  18:   85 c9                   test   %ecx,%ecx
  1a:   75 ee                   jne    a <start>
  1c:   c3                      ret  

Python 3, 39 bytes

f=lambda k:print(k)or f(hash('.'*k)%k)

Probably not the most cryptographically secure random number generator but to the human eye it looks random enough...

Try it online!

TI-Basic (TI-84 Plus CE), 17 13 bytes

While Ans
Disp Ans
int(randAns
End
Ans

-4 bytes from Misha Lavrov

Takes input in Ans as 50:prgmNAME.

TI-Basic is a tokenized language. All tokens used here are one byte.

Explanation:

While Ans    # 3 bytes, While the number we hold is not zero:
Disp Ans     # 3 bytes,   Display it on its own line
int(randAns  # 4 bytes,   and replace it with a number randomly
                        # chosen from 0 to one less than it (inclusive)
End          # 2 bytes, end While loop
Ans          # 1 byte,  Display (and return) zero

An 11-byte solution suggested by Misha Lavrov that requires pressing enter after each line following the first.

Ans
While Ans
Pause int(randAns
End

Python 2, 64 62 60 bytes

from random import*
k=input()
while k:print k;k=randrange(k)

Try it online!

Saved

• -2 bytes, thanks to Jonathan Allan

C++ (gcc), 98 bytes

#import<cstdio>
#import<cstdlib>
#define d printf("%i ",x 
int p(int x){d);while(x>0)d=rand()%x);}

Try it here!

Usage

int main() {
    p(100);
}

This is my first code golf attempt. Any feedback or remarks are welcome.

Edit: Removed the main function as suggested to make it valid.

><>, 92+2 Bytes

:nao:0=?;0_1>:{:}(?\\
}(?!\$2*1>x~\$+1$*2/\~00:{{:@}
8+1.\~:{:}\+>$1+f
~~@~~47*0.\(a2*1@@?!.

+2B for -v flag

Try it online!

><>'s only source of randomness comes from the 'x' instruction, which sets the instruction pointer's direction to a random value. As such, generating a random number from 0 to n isn't trivial.

I first calculate how many bits are required to represent a number in the range [0,n), then generate random bits to generate a random number. This leaves the possibility that it'll generate a number slightly larger than n, in which case we just discard it and try again.

Explanation:

:nao                              Print the current number followed by a newline
    :0=?;                         If the current n is 0, terminate

Calculate how many random bits we need to be generating:
         0 1                      Initialise the variables for this loop: 
                                      numberOfBits = 0, maxValue = 1
             :{:}(?\              If maxValue >= n, break out of the loop
                 *2               maxValue *= 2
             $+1$                 numberOfBits += 1

Generate the random number:
                     ~            Delete maxValue
                      00          Initialise randomNumber = 0, i = 0
}(?!\                   :{{:@}    If i >= numberOfBits, break out of the (inner) loop
     $2*                          randomNumber *= 2
          _
        1>x~\                     The random bit: If the IP goes up or 
          \+>                     left, it'll be redirected back onto the 'x', 
                                  if it goes down, it adds one to randomNumber
                                  If it goes right, it does nothing to randomNumber

             $1+                  increment i
8+1.            f                 Jump back to the start of the inner loop

After we've generated our number, check that it's actually below n
     ~                            Delete i
      :{:} (      ?               Test that the number is less than n
            a2*1    .             If it's not, jump back to the start 
                                  of the number generation section
  @~~                             Otherwise delete the old value of n, and numberOfBits
     47*0.                        Then jump back to the start of the program

MATLAB (49 46 bytes)

@(k)eval('while k;disp(k);k=randi(k)-1;end;0')

Sample output:

>> @(k)eval('while k;disp(k);k=randi(k)-1;end;0')
ans(5)

ans = 

    @(k)eval('while k;disp(k);k=randi(k)-1;end;0')

     5    
     3    
     2    
     1   

ans =    
     0

Võng mạc , 21 byte

.+
*
L$`.
$.`
+¶<)G?`

Hãy thử trực tuyến! Giải trình:

+

Lặp lại cho đến khi giá trị dừng thay đổi (tức là 0).

¶<)

In giá trị trước mỗi lần đi qua vòng lặp.

.+
*

Chuyển đổi sang unary.

L$`.
$.`

Tạo phạm vi và chuyển đổi thành thập phân.

G?`

Chọn một yếu tố ngẫu nhiên.

Bình thường , 6 7 byte

QWQ=OQQ

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

+1 để in giá trị đầu vào ban đầu.

Trong khi Q là trung thực, đặt Q là một số nguyên ngẫu nhiên giữa 0 và Q và in Q.

Không phải là câu trả lời ngắn nhất về Pyth nhưng tôi chỉ học và chỉ đăng bài vì các cuộc thảo luận gần đây về việc không có ai sử dụng Pyth nữa :)

Haskell, 74 71 bytes

^{-3 bytes by actually doing what the specs say it should do.}

import System.Random
f 0=pure[0]
f x=randomRIO(0::Int,x-1)>>=fmap(x:).f

Try it online!

IBM/Lotus Notes Formula, 48 bytes

o:=i;@While(i>0;i:=@Integer(i*@Random);o:=o:i);o

Field formula that takes input from another field i.

There's no TIO for formula so here's a screenshot of a sample output:

Powershell, 36 32 bytes

-4 bytes thanks AdmBorkBork

filter f{$_;if($_){Random $_|f}}

Testscript:

filter f{$_;if($_){Random $_|f}}

100 |f

Output:

100
61
20
8
6
3
0

PowerShell, 35 bytes

for($a="$args";$a;$a=Random $a){$a}

Try it online!

Full program. Takes input $args, stores it into $a, and enters a for loop. Each iteration we're checking whether $a is still positive (as 0 is falsey in PowerShell). Then we leave $a on the pipeline and move to the next iteration, where we set $a to be the result of Get-Random $a, which returns an integer in the range 0..($a-1).

(Ab)uses the fact that PowerShell outputs an additional trailing newline in lieu of outputting the final zero (allowed by the rules as currently written).

Lua, 58 bytes

p,r=print,...+0 p(r)while r>0 do r=math.random(0,r)p(r)end

Try it online!

For some more Lua love here :)