Reto

Publicación de sandbox

Dado un entero positivo (K)Produce un entero uniformemente aleatorio (Y)entre [0, K).

Si Y > 0asume K = Yy repite el proceso hasta Y = 0.

Reglas

• La entrada debe imprimirse al principio
• Formato de salida como desee
• Tu programa debe terminar.
• 0 debe ser la salida final, opcionalmente una línea vacía en su lugar 0

Pyth , 6 5 4 bytes

.uOW

Pruébalo aquí!

Cómo funciona

.uOW Programa completo. Toma un número entero de STDIN y genera una lista en STDOUT.
.u Punto fijo acumulativo. Aplicar la función dada con un valor inicial dado,
        que se asigna implícitamente a la entrada, hasta que se produce un resultado 
        antes se encuentra. Devuelve la lista de resultados intermedios.
   W Aplicación condicional. Si el argumento (el valor actual) es verdadero, entonces
        aplique la función a continuación, de lo contrario no la cambie.
  O Entero aleatorio en el rango [0, N).
        IOW: en cada iteración de .u, asigne una variable N al valor actual, comenzando
        con la entrada Si N no es 0, elija un entero aleatorio en [0, N), de lo contrario
        devuelve N sin cambios. Siempre que encontremos un 0, la siguiente iteración también debe
        da como resultado un 0 y, por lo tanto, el ciclo se detiene allí.

C (gcc) , 42 bytes

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

Pruébalo en línea!

Utiliza lógica y cortocircuito.

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 bytes (sin imprimir el valor inicial)

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

Pruébalo en línea!

Utiliza lógica y cortocircuito.

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 bytes

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

Pruébalo en línea!

MATL , 6 bytes

`tYrqt

Pruébalo en línea!

Explicación

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

Pepe es un lenguaje de programación creado por el usuario Soaku .

REeErEErReEEreeEREEeEEree 

Pruébalo en línea!

Explicación:

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 bytes

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

Pruébalo en línea!

Bloque de código anónimo que devuelve una lista de valores. Si no le importa que los números sean rangos, puede hacer:

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

por 17 bytes. Curiosamente, otra función aleatoria incorporada roll, tiene el mismo comportamiento en esta instancia para la misma cantidad de bytes.

Perl 5 .10.0 -pl, 26 bytes

say;say while$_=int rand$_

Pruébalo en línea!

Gelatina ,  4  3 bytes

XƬ0

Este es un enlace monádico (función) que imprime una matriz y devuelve 0 .

Pruébalo en línea!

Cómo funciona

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 bytes

ẉ?ℕ₁-₁ṙ↰

Pruébalo en línea!

Explicación

ẉ          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 recursión se detendrá una vez que ?ℕ₁falle, es decir, cuando la entrada sea 0.

05AB1E , 8 7 bytes

Δ=L<Ω0M

Pruébalo en línea!

Explicación

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

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

En el metro, disculpas por falta de TIO (espero que no haya falta de corrección).

Emite una lista de valores.

Presumiblemente, el enfoque APL será más corto, pero esto es lo que pensé.

Cómo funciona

^:a: aplicar repetidamente hasta la convergencia, almacenando resultados intermedios en una matriz.

?entero aleatorio en el rango [0, K)de Kmayor que 0. Para 0, da un entero aleatorio en el rango (0,1). Para un número de coma flotante, errores.

::]detectar un error para una entrada ?y, en lugar de generar un error , generar la entrada que causó el error.

}: deshacerse del último valor en la matriz (esto es para que no se genere un número de coma flotante).

Pruébalo en línea!

JavaScript (ES6), 38 37 bytes

-1 byte gracias a @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 bytes

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

Pruébalo en línea

Sin golf

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

Pyth , 4 bytes

W
~O

Pruébalo en línea!

Básicamente, esto implementa el algoritmo:

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

Para traducir Pyth al algoritmo, podemos examinar principalmente lo que significa cada personaje. Dado que Pyth está escrito en notación de prefijo ( * + 1 2 3es decir, es (1 + 2) * 3), podemos comenzar desde la izquierda y completar los argumentos a medida que avanzamos.

Wcomienza un ciclo while tradicional. La primera declaración después es la condición del bucle y la segunda declaración después es el cuerpo del bucle. Si la segunda declaración está vacía, se convierte en un no-op . Esto funciona exactamente igual que Python while, por lo que evaluará enteros distintos de cero como Verdadero y cero como falso.

La primera declaración después del tiempo comienza con el carácter de nueva línea. Esto corresponde a la función "imprimir y volver con una nueva línea" de Pyth. Esto requiere un argumento, que luego se imprime y también se devuelve sin modificar. Esto nos permite imprimir los pasos intermedios mientras realizamos las operaciones necesarias.

El argumento pasado a esta función de impresión comienza con lo ~que es un poco especial. Si el carácter inmediatamente posterior ~es una variable, toma dos argumentos; de lo contrario, toma uno. Como Ono es una variable ~, solo se consumirá un argumento. ~funciones un poco como +=lo hace en muchos lenguajes convencionales, aunque el operador más cercano sería el operador de incremento ++de C. Puede saber que x++será como usarlo xcomo valor actual, pero a partir de entonces xlo será x+1. ~es la misma idea, pero generalizada a cualquiera que sea el resultado del primer argumento. La forma en que elige a qué variable asignar se abordará más adelante.

El argumento de ~es Oque es muy simple. Cuando su único argumento es un entero, Odevuelve un valor de 0 a uno menos que ese entero de manera uniforme al azar.

Ahora puede haber notado Oque no tiene un argumento. Aquí el intérprete de Pyth rellena amablemente una suposición, que aquí es la variable Q. Qtiene un significado especial en Pyth: cada vez que está presente en un programa, el programa Pyth comienza con la asignación Qa la entrada del programa. Como esta es la primera variable que ocurre en ~el argumento de '', Qahora también es la variable a la que se ~le asignará un valor.

En resumen, nuestro programa "legible" podría verse así:

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

Y una muestra de "ejecución" podría verse así:

1. Q = 5
2. Odevuelve 3, ~devuelve 5,\n devuelve e imprime 5, lo cual es cierto
3. Q = 3
4. Odevuelve 0, ~devuelve 3, \ndevuelve e imprime 3, lo cual es cierto
5. Q = 0
6. Odevuelve algo irrelevante, ~devuelve 0, \ndevuelve e imprime 0 que es falso
7. Q = algo irrelevante
8. Terminar

APL (Dyalog Unicode) , 12 9 bytes

Función de prefijo tácito anónimo. Asume ⎕IO( I ndex O rigin) para ser0 , que es predeterminado en muchos sistemas. Devuelve el valor final (0) además de imprimir mientras se ejecuta.

{⌊?⎕←⍵}⍣=

Pruébalo en línea!

{...}⍣=  aplique la siguiente función hasta que sea estable:

 ⎕←⍵ dar salida al argumento

 ? devuelve un número aleatorio distribuido uniformemente en el rango de 0 a ese – 1

 ⌊ redondear hacia abajo (porque ?0da un flotador (0,1))

C (gcc) , 40 42 bytes

Some idiot ™ olvidó imprimir primero el valor inicial.

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

No entres en pánico.

x86 + rdrand, 19 bytes

Implementación directa. Toma la entrada K ecxy las salidas a una memoria intermedia 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)

Probablemente no sea el generador de números aleatorios más seguro criptográficamente, pero para el ojo humano parece lo suficientemente aleatorio ...

Pruébalo en línea!

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

While Ans
Disp Ans
int(randAns
End
Ans

-4 bytes de Misha Lavrov

Toma entrada Anscomo50:prgmNAME .

TI-Basic es un lenguaje tokenizado . Todas las fichas utilizadas aquí son de un byte.

Explicación:

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

Una solución de 11 bytes sugerida por Misha Lavrov que requiere presionar enterdespués de cada línea que sigue a la primera.

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)

Pruébalo en línea!

Salvado

• -2 bytes, gracias a 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);}

Pruébalo aquí!

Uso

int main() {
    p(100);
}

Este es mi primer intento de código de golf. Cualquier comentario o comentario son bienvenidos.

Editar: se eliminó la función principal como se sugiere para que sea válida.

> <>, 92 + 2 bytes

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

+ 2B para la bandera -v

Pruébalo en línea!

La única fuente de aleatoriedad de> <> proviene de la instrucción 'x', que establece la dirección del puntero de la instrucción en un valor aleatorio. Como tal, generar un número aleatorio de 0 a n no es trivial.

Primero calculo cuántos bits se requieren para representar un número en el rango [0, n), luego genero bits aleatorios para generar un número aleatorio. Esto deja la posibilidad de que genere un número ligeramente mayor que n, en cuyo caso simplemente lo descartamos e intentamos nuevamente.

Explicación:

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

Salida de muestra:

>> @(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?`

Pruébalo en línea! Explicación:

+

Repita hasta que el valor deje de cambiar (es decir, 0).

¶<)

Imprima el valor antes de cada pasada a través del bucle.

.+
*

Convierte a unario.

L$`.
$.`

Crea el rango y convierte a decimal.

G?`

Elige un elemento aleatorio.

Pyth , 6 7 bytes

QWQ=OQQ

Pruébalo en línea!

+1 para imprimir el valor de entrada inicial.

Si bien Q es verdadero, configure Q para que sea un entero aleatorio entre 0 y Q e imprima Q.

No es la respuesta más corta de Pyth, pero solo estoy aprendiendo y solo publicando debido a la reciente discusión sobre que ya nadie usa Pyth :)

Haskell , 74 71 bytes

^{-3 bytes haciendo realmente lo que las especificaciones dicen que debería hacer.}

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

Pruébalo en línea!

Fórmula IBM / Lotus Notes, 48 ​​bytes

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

Fórmula de campo que toma datos de otro campo i.

No hay TIO para la fórmula, así que aquí hay una captura de pantalla de una salida de muestra:

Powershell, 36 32 bytes

-4 bytes gracias AdmBorkBork

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

Testscript:

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

100 |f

Salida:

100
61
20
8
6
3
0

PowerShell , 35 bytes

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

Pruébalo en línea!

Programa completo Toma datos $args, los almacena $ay entra en un forbucle. Cada iteración que estamos verificando si $asigue siendo positiva (como lo 0es falsey en PowerShell). Luego lo dejamos $aen la tubería y pasamos a la siguiente iteración, donde establecemos $ael resultado Get-Random $a, que devuelve un número entero en el rango0..($a-1) .

(Ab) utiliza el hecho de que PowerShell genera una nueva línea final adicional en lugar de generar el cero final (permitido por las reglas tal como están escritas actualmente).

Lua , 58 bytes

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

Pruébalo en línea!

Para más amor Lua aquí :)