Sfida

Posta sandbox

Dato un numero intero positivo Emette un numero intero (K)uniformemente casuale (Y)tra [0, K).

Se Y > 0supponi K = Ye ripeti il ​​processo fino al Y = 0.

Regole

• L'input deve essere stampato all'inizio
• Formato di output come desideri
• Il tuo programma deve terminare.
• 0 deve essere l'output finale, facoltativamente invece una riga vuota 0

Pyth , 6 5 4 byte

.uOW

Provalo qui!

Come funziona

.uOW Programma completo. Prende un numero intero da STDIN e restituisce un elenco a STDOUT.
.u Punto fisso cumulativo. Applica la funzione data con un dato valore iniziale,
        che è implicitamente assegnato all'input, fino a quando non si è verificato un risultato 
        prima è stato trovato. Restituisce l'elenco dei risultati intermedi.
   W Applicazione condizionale. Se l'argomento (il valore corrente) è veritiero, allora
        applica la seguente funzione, altrimenti lascia invariata.
  O Numero intero casuale nell'intervallo [0, N).
        IOW: ad ogni iterazione di .u, assegnare una variabile N al valore corrente, iniziando
        con l'input. Se N non è 0, scegli un numero intero casuale in [0, N), altrimenti
        restituisce N invariato. Ogni volta che incontriamo uno 0, anche la prossima iterazione deve
        risulta in uno 0 e quindi il ciclo si ferma qui.

C (gcc) , 42 byte

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

Provalo online!

Usa logica e 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 byte (senza valore iniziale di stampa)

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

Provalo online!

Usa logica e 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 byte

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

Provalo online!

MATL , 6 byte

`tYrqt

Provalo online!

Spiegazione

`        % 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 è un linguaggio di programmazione creato dall'utente Soaku .

REeErEErReEEreeEREEeEEree 

Provalo online!

Spiegazione:

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}

Provalo online!

Blocco di codice anonimo che restituisce un elenco di valori. Se non ti dispiace che i numeri siano intervalli, puoi fare:

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

per 17 byte. Stranamente, un'altra funzione casuale incorporata roll, ha lo stesso comportamento in questa istanza per la stessa quantità di byte.

Perl 5-pl , 10,0 , 26 byte

say;say while$_=int rand$_

Provalo online!

Gelatina ,  4  3 byte

XƬ0

Questo è un collegamento monadico (funzione) che stampa un array e restituisce 0 .

Provalo online!

Come funziona

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

ẉ?ℕ₁-₁ṙ↰

Provalo online!

Spiegazione

ẉ          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 ricorsione si interromperà una volta ?ℕ₁fallita, cioè quando l'input è 0.

05AB1E , 8 7 byte

Δ=L<Ω0M

Provalo online!

Spiegazione

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

In metropolitana, quindi mi scuso per la mancanza di TIO (speriamo non ci sia mancanza di correttezza).

Emette un elenco di valori.

Presumibilmente l'approccio APL sarà più breve, ma è quello che ho pensato.

Come funziona

^:a: applicare ripetutamente fino alla convergenza, memorizzando i risultati intermedi in un array.

?intero casuale nell'intervallo [0, K)per Kmaggiore di 0. Per 0, fornisce un numero intero casuale nell'intervallo (0,1). Per un numero in virgola mobile, si tratta di errori.

::]rileva un errore per un input ?e invece di errori, genera l'input che ha causato l'errore.

}: sbarazzarsi dell'ultimo valore nell'array (questo è in modo che non venga emesso un numero in virgola mobile).

Provalo online!

JavaScript (ES6), 38 37 byte

-1 byte grazie 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 byte

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

Provalo online

Ungolfed

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

Pyth , 4 byte

W
~O

Provalo online!

Questo implementa sostanzialmente l'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}$

Per tradurre il Pyth nell'algoritmo, possiamo principalmente esaminare solo cosa significa ogni personaggio. Dato che Pyth è scritto in notazione con prefisso (cioè * + 1 2 3è (1 + 2) * 3) possiamo iniziare da sinistra e riempire gli argomenti mentre procediamo.

Winizia un ciclo while tradizionale. La prima istruzione dopo è la condizione del ciclo e la seconda istruzione dopo è il corpo del ciclo. Se la seconda istruzione è vuota diventa no-op . Questo mentre funziona esattamente come Python mentre, quindi valuterà numeri interi diversi da zero come Vero e zero come falso.

La prima affermazione dopo il tempo inizia con il carattere di nuova riga. Ciò corrisponde alla funzione "stampa e ritorna con una nuova riga" di Pyth. Questo richiede un argomento, che viene quindi stampato e restituito anche non modificato. Questo ci consente di stampare i passaggi intermedi eseguendo anche le operazioni necessarie.

L'argomento passato a questa funzione di stampa inizia con il ~quale è un po 'speciale. Se il carattere immediatamente successivo ~è una variabile, accetta due argomenti, altrimenti ne accetta uno. Poiché Onon è una variabile ~consumerà solo un argomento. ~funziona un po 'come +=in molte lingue convenzionali, anche se l'operatore più vicino sarebbe l'operatore post-incremento ++di C. Potresti sapere che x++sarà come usare xcome valore corrente, ma in seguito xlo sarà x+1. ~è la stessa idea, ma generalizzata a qualunque sia il risultato del primo argomento. In che modo verrà scelta la variabile da assegnare in seguito.

L'argomento di ~è Oche è molto semplice. Quando il suo unico argomento è un numero intero Orestituisce un valore compreso tra 0 e uno inferiore a quello intero uniformemente a caso.

Ora potresti aver notato Oche non ha argomenti. Qui l'interprete Pyth compila gentilmente un'ipotesi, che qui è la variabile Q. Qha un significato speciale in Pyth: ogni volta che è presente in un programma, il programma Pyth inizia con l'assegnazione Qall'ingresso del programma. Dato che questa è la prima variabile che si presenta ~nell'argomento Qè anche la variabile a cui ~assegnare un valore.

Riassumendo il nostro programma "leggibile" potrebbe apparire come:

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

E un "run-through" di esempio potrebbe apparire come:

1. Q = 5
2. Oritorna 3, ~ritorna 5, \nritorna e stampa 5 che è vero
3. Q = 3
4. Oritorna 0, ~ritorna 3, \nritorna e stampa 3 che è vero
5. Q = 0
6. Orestituisce qualcosa di irrilevante, ~restituisce 0, \nrestituisce e stampa 0 che è falso
7. Q = qualcosa di irrilevante
8. Terminare

APL (Dyalog Unicode) , 12 9 byte

Funzione prefisso tacito anonimo. Assume ⎕IO( I NDICE O rigine) di essere 0, che è di default su molti sistemi. Restituisce il valore finale (0) oltre alla stampa durante l'esecuzione.

{⌊?⎕←⍵}⍣=

Provalo online!

{... }⍣= applica la seguente funzione fino a stabile:

 ⎕←⍵ emette l'argomento

 ? restituisce un numero casuale uniformemente distribuito nell'intervallo da 0 a quello – 1

 ⌊ arrotondare per difetto (perché ?0dà un (0,1) float)

C (gcc) , 40 42 byte

Alcuni idiot ™ si sono dimenticati di stampare prima il valore iniziale.

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

Non fatevi prendere dal panico.

x86 + rdrand, 19 byte

Implementazione semplice. Porta input K in ecxe output a un 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 byte

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

Probabilmente non è il generatore di numeri casuali crittograficamente più sicuro ma all'occhio umano sembra abbastanza casuale ...

Provalo online!

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

While Ans
Disp Ans
int(randAns
End
Ans

-4 byte da Misha Lavrov

Accetta input Anscome 50:prgmNAME.

TI-Basic è un linguaggio tokenizzato . Tutti i token utilizzati qui sono un byte.

Spiegazione:

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 soluzione a 11 byte suggerita da Misha Lavrov che richiede di premere enterdopo ogni riga successiva alla prima.

Ans
While Ans
Pause int(randAns
End

Python 2 , 64 62 60 byte

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

Provalo online!

Salvato

• -2 byte, grazie a Jonathan Allan

C ++ (gcc), 98 byte

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

Provalo qui!

uso

int main() {
    p(100);
}

Questo è il mio primo tentativo di golf con codice. Qualsiasi commento o commento sono ben accetti.

Modifica: rimossa la funzione principale come suggerito per renderla valida.

> <>, 92 + 2 byte

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

+ 2B per -v flag

Provalo online!

L'unica fonte di casualità di> <> deriva dall'istruzione "x", che imposta la direzione del puntatore dell'istruzione su un valore casuale. Pertanto, generare un numero casuale da 0 a n non è banale.

In primo luogo calcolo quanti bit sono necessari per rappresentare un numero nell'intervallo [0, n), quindi generare bit casuali per generare un numero casuale. Questo lascia la possibilità che genererà un numero leggermente più grande di n, nel qual caso lo scartiamo e riproviamo.

Spiegazione:

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

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

Uscita campione:

>> @(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 byte

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

Provalo online! Spiegazione:

+

Ripetere fino a quando il valore non smette di cambiare (ovvero 0).

¶<)

Stampa il valore prima di ogni passaggio attraverso il ciclo.

.+
*

Converti in unario.

L$`.
$.`

Crea l'intervallo e converti in decimale.

G?`

Scegli un elemento casuale.

Pyth , 6 7 byte

QWQ=OQQ

Provalo online!

+1 per stampare il valore di input iniziale.

Mentre Q è vero, imposta Q in modo che sia un numero intero casuale compreso tra 0 e Q e stampa Q.

Non è la risposta Pyth più breve, ma sto solo imparando e pubblicando solo a causa della recente discussione su nessuno che utilizza Pyth più :)

Haskell , 74 71 byte

^{-3 byte facendo effettivamente ciò che le specifiche dicono che dovrebbe fare.}

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

Provalo online!

Formula IBM / Lotus Notes, 48 ​​byte

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

Formula di campo che accetta input da un altro campo i.

Non esiste un TIO per la formula, quindi ecco uno screenshot di un output di esempio:

Powershell, 36 32 byte

-4 byte grazie AdmBorkBork

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

testscript:

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

100 |f

Produzione:

100
61
20
8
6
3
0

PowerShell , 35 byte

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

Provalo online!

Programma completo. Prende input $args, lo memorizza $aed entra in un forloop. Ogni iterazione che stiamo verificando $aè ancora positiva (come lo 0è false in PowerShell). Quindi lasciamo $asulla pipeline e passiamo alla successiva iterazione, dove impostiamo $aper essere il risultato Get-Random $a, che restituisce un numero intero nell'intervallo 0..($a-1).

(Ab) utilizza il fatto che PowerShell genera un'ulteriore riga finale in sostituzione anziché emettere lo zero finale (consentito dalle regole come attualmente scritto).

Lua , 58 byte

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

Provalo online!

Per un po 'più di amore Lua qui :)