Défi

Poteau de bac à sable

Étant donné un entier positif, (K)affichez un entier uniformément aléatoire (Y)entre [0, K).

Si Y > 0supposez K = Yet répétez le processus jusqu'à Y = 0.

Règles

• L'entrée doit être imprimée au début
• Format de sortie comme vous le souhaitez
• Votre programme doit se terminer.
• 0 doit être la sortie finale, éventuellement une ligne vide à la place 0

Pyth , 6 5 4 octets

.uOW

Essayez-le ici!

Comment ça marche

.uOW Programme complet. Prend un entier de STDIN et sort une liste vers STDOUT.
.u Point fixe cumulatif. Appliquer la fonction donnée avec une valeur initiale donnée,
        qui est implicitement affecté à l'entrée, jusqu'à ce qu'un résultat qui se soit produit 
        avant est trouvé. Renvoie la liste des résultats intermédiaires.
   W Application conditionnelle. Si l'argument (la valeur actuelle) est vrai, alors
        appliquez la fonction ci-dessous, sinon laissez-la inchangée.
  O Entier aléatoire dans la plage [0, N).
        IOW: à chaque itération de .u, affectez une variable N à la valeur courante, en commençant
        avec l'entrée. Si N n'est pas 0, choisissez un entier aléatoire dans [0, N), sinon
        retourne N inchangé. Chaque fois que nous rencontrons un 0, la prochaine itération doit également
        entraîner un 0, et donc la boucle s'arrête là.

C (gcc) , 42 octets

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

Essayez-le en ligne!

Utilise les circuits logique et court-circuités.

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 octets (sans impression de la valeur initiale)

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

Essayez-le en ligne!

Utilise les circuits logique et court-circuités.

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 octets

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

Essayez-le en ligne!

MATL , 6 octets

`tYrqt

Essayez-le en ligne!

Explication

`        % 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 octets

Pepe est un langage de programmation créé par l'utilisateur Soaku .

REeErEErReEEreeEREEeEEree 

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui renvoie une liste de valeurs. Si cela ne vous dérange pas que les nombres soient des plages, vous pouvez faire:

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

pour 17 octets. Curieusement, une autre fonction aléatoire intégrée,, rolla le même comportement dans ce cas pour la même quantité d'octets.

Perl 5 .10.0 -pl, 26 octets

say;say while$_=int rand$_

Essayez-le en ligne!

Gelée ,  4  3 octets

XƬ0

Il s'agit d'un lien monadique (fonction) qui imprime un tableau et renvoie 0 .

Essayez-le en ligne!

Comment ça marche

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 octets

ẉ?ℕ₁-₁ṙ↰

Essayez-le en ligne!

Explication

ẉ          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

La récursivité s'arrêtera en cas d' ?ℕ₁échec, c'est-à-dire lorsque l'entrée est 0.

05AB1E , 8 7 octets

Δ=L<Ω0M

Essayez-le en ligne!

Explication

Δ         # 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 octets

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

Dans le métro, donc excuses pour le manque de TIO (j'espère qu'il n'y a pas de manque de justesse).

Affiche une liste de valeurs.

On peut supposer que l'approche APL sera plus courte, mais c'est ce à quoi j'ai pensé.

Comment ça marche

^:a: appliquer à plusieurs reprises jusqu'à la convergence, en stockant les résultats intermédiaires dans un tableau.

?entier aléatoire dans la plage [0, K)pour Ksupérieure à 0. Pour 0, il donne un nombre entier aléatoire dans la gamme (0,1). Pour un nombre à virgule flottante, il génère des erreurs.

::]attraper une erreur pour une entrée ?et au lieu de l'erreur, sortir l'entrée qui a causé l'erreur.

}: se débarrasser de la dernière valeur du tableau (c'est pour qu'un nombre à virgule flottante ne soit pas affiché).

Essayez-le en ligne!

JavaScript (ES6), 38 37 octets

-1 octet grâce à @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 octets

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

Essayez-le en ligne

Non golfé

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

Pyth , 4 octets

W
~O

Essayez-le en ligne!

Cela implémente essentiellement l'algorithme:

$\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}$

Pour traduire le Pyth dans l'algorithme, nous pouvons principalement examiner ce que signifie chaque caractère. Puisque Pyth est écrit en notation préfixe (c'est-à * + 1 2 3- dire est (1 + 2) * 3), nous pouvons commencer par la gauche et remplir les arguments au fur et à mesure.

Wcommence une boucle while traditionnelle. La première instruction après c'est la condition de boucle et la deuxième instruction après c'est le corps de boucle. Si la deuxième instruction est vide, elle devient un no-op . Cela tandis que fonctionne exactement comme le tout Python, il évaluera donc les entiers non nuls comme Vrai et zéro comme faux.

La première instruction après le moment commence par le caractère de nouvelle ligne. Cela correspond à la fonction "imprimer et retourner avec une nouvelle ligne" de Pyth. Cela prend un argument, qui est ensuite imprimé et retourné non modifié. Cela nous permet d'imprimer les étapes intermédiaires tout en effectuant les opérations nécessaires.

L'argument passé à cette fonction d'impression commence par ~ce qui est un peu spécial. Si le caractère immédiatement après ~est une variable, il prend deux arguments, sinon il en prend un. Puisque On'est pas une variable ~ne consommera qu'un seul argument. ~fonctions un peu comme le +=fait dans de nombreuses langues classiques, bien que l'opérateur le plus proche serait l'opérateur de post-incrémentation ++de C. Vous savez peut-être que ce x++sera comme utiliser xcomme valeur actuelle, mais ce xsera le cas par la suite x+1. ~est la même idée, mais généralisée à quelque soit le résultat du premier argument. La façon dont il choisit la variable à attribuer sera traitée ultérieurement.

L'argument de ~est -ce Oqui est très simple. Lorsque son seul argument est un entier Oretourne une valeur de 0 à un de moins que cet entier uniformément au hasard.

Maintenant, vous avez peut-être remarqué qu'il On'a pas d'argument. Ici, l'interpréteur Pyth remplit gentiment une supposition, qui est ici la variable Q. Qa une signification particulière en Pyth: chaque fois qu'il est présent dans un programme, le programme Pyth commence par l'affectation Qà l'entrée du programme. Puisque c'est la première variable apparaissant dans ~l'argument de, Qc'est aussi maintenant la variable qui ~assignera une valeur à.

En résumé, notre programme "lisible" pourrait ressembler à ceci:

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

Et un échantillon "run-through" pourrait ressembler à:

1. Q = 5
2. Orenvoie 3, ~renvoie 5,\n retourne et imprime 5, ce qui est vrai
3. Q = 3
4. Oretourne 0, ~retourne 3, \nretourne et imprime 3 ce qui est vrai
5. Q = 0
6. Orenvoie quelque chose de non pertinent, ~retourne 0, \nretourne et imprime 0 ce qui est faux
7. Q = quelque chose de non pertinent
8. Mettre fin

APL (Dyalog Unicode) , 12 9 octets

Fonction de préfixe tacite anonyme. Suppose que ⎕IO( I ndex O rigin) est 0, ce qui est le cas par défaut sur de nombreux systèmes. Renvoie la valeur finale (0) en plus de l'impression pendant l'exécution.

{⌊?⎕←⍵}⍣=

Essayez-le en ligne!

{… }⍣= Appliquez la fonction suivante jusqu'à ce qu'elle soit stable:

 ⎕←⍵ sortir l'argument

 ? retourner un nombre aléatoire uniformément distribué dans la plage de 0 à ce – 1

 ⌊ arrondi (car ?0donne un flottant (0,1))

C (gcc) , 40 42 octets

Certains idiots ont oublié d'imprimer la valeur initiale en premier.

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

Pas de panique.

x86 + rdrand, 19 octets

Mise en œuvre simple. Prend l'entrée K ecxet les sorties dans un tampon 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 octets

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

Retina, 21 bytes

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

Try it online! Explanation:

+

Repeat until the value stops changing (i.e. 0).

¶<)

Print the value before each pass through the loop.

.+
*

Convert to unary.

L$`.
$.`

Create the range and convert to decimal.

G?`

Pick a random element.

Pyth, 6 7 bytes

QWQ=OQQ

Try it online!

+1 to print the initial input value.

While Q is truthy, set Q to be a random integer between 0 and Q and print Q.

Not the shortest Pyth answer but I'm just learning and only posting because of the recent discussion about no-one using Pyth any more :)

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