Informazioni sulla serie

Prima di tutto, puoi trattarlo come qualsiasi altra sfida di golf del codice e rispondere senza preoccuparti della serie. Tuttavia, esiste una classifica in tutte le sfide. Puoi trovare la classifica insieme ad alcune ulteriori informazioni sulla serie nel primo post .

Buca 8: mescola un elenco infinito

È necessario scrivere una funzione o un programma che accetta un elenco infinito come input e restituisce una versione casuale di tale elenco.

Informazioni sull'I / O infinito

Esistono diversi modi per prendere input e produrre output per questa sfida:

• Puoi prendere un elenco di numeri interi positivi, o una loro rappresentazione in stringa, o una stringa o un elenco di caratteri ASCII stampabili (da 0x20 a 0x7E, inclusi). Il formato di output deve corrispondere al formato di input. D'ora in poi farò riferimento ai dati come "l'elenco", indipendentemente dall'opzione scelta.
• È possibile leggere l'elenco da un flusso di input standard infinito e scrivere l'output continuamente su un flusso di output standard infinito. La soluzione non dovrebbe dipendere da alcun valore particolare o sequenza di valori per garantire che il flusso di output sia regolarmente scritto e svuotato (ad es. Non è possibile semplicemente scrivere output ogni volta che c'è un 5nell'elenco di input). Naturalmente, se leggi una rappresentazione in forma di stringa di un elenco, è bene attendere fino a quando non si incontra il separatore di elenco.
• Nelle lingue che li supportano, è possibile scrivere una funzione che accetta e restituisce un elenco o una stringa infiniti pigri.
• Nelle lingue che li supportano è possibile implementare un generatore infinito che accetta un altro generatore come input.
• In alternativa, è possibile scrivere una funzione che non accetta argomenti e restituisce un valore di output ogni volta che viene chiamato. In questo caso, si può presumere che sia stata definita una funzione che non accetta argomenti e restituisce il valore di input successivo ogni volta che viene chiamato. Puoi scegliere liberamente il nome di quella funzione.

Si può presumere che il programma sia in esecuzione per sempre e che sia disponibile memoria infinita. (È possibile risolverlo con una quantità finita di memoria, ma ciò significa che è possibile perdere la memoria.)

A proposito della casualità

Per qualsiasi valore v che viene letto in una posizione i dell'input infinito, ci deve essere una probabilità positiva che finisca in una delle posizioni da i-9 a i + 9 dell'output infinito (a meno che quella posizione non sia negativa ). Queste probabilità non devono essere le stesse per posizioni di output diverse o anche per posizioni di input diverse. Va bene se la tua soluzione può anche mescolare i valori in altre posizioni più lontane.

Quindi, non è necessario che la tua soluzione possa mescolare il primo valore molto in fondo alla lista o che possa mescolare un valore molto tardi fino alla prima posizione, anche se va bene così, purché tutte le posizioni a 9 passi dalla sono possibili input.

Ad esempio, se hai preso la seguente stringa come input, ___indica tutte le posizioni che Xdevono essere in grado di finire nell'output:

                  ___________________
 abcdefghijklmnopqrstuvwxyzXabcdefghijklmnopqrstuvwxyz...

Se la tua lingua manca di un generatore di numeri casuali incorporato o non vuoi usarlo, puoi prendere un valore seed aggiuntivo come input e implementare il tuo RNG adatto usando il seed. Questa pagina può essere utile per questo.

Indipendentemente dalla distribuzione effettiva utilizzata dalla soluzione, deve quasi sicuramente produrre il valore successivo dopo un tempo finito (ma arbitrario).

Includi una breve spiegazione su come la tua implementazione soddisfa questi requisiti.

punteggio

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

Classifica

Il primo post della serie genera una classifica.

Per assicurarti che le tue risposte vengano visualizzate, inizia ogni risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

(La lingua non è attualmente visualizzata, ma lo snippet richiede e analizza, e in futuro potrei aggiungere una classifica linguistica).

Python 3 , 78 byte

from random import*
l=[]
while[shuffle(l)]:l[9:]and print(l.pop());l+=input(),

Provalo online!

Riceve input da STDIN (uno per riga), stampa su STDOUT.

Mantiene un buffer ldi massimo 10 elementi. Il buffer viene mischiato ad ogni passaggio. Quando la sua lunghezza è 10, l'ultimo elemento viene stampato e rimosso.

Se un elemento sembra essere stampato non appena è stato inserito, ha saltato prima di altri 9 elementi in attesa nel buffer, quindi appare 9 punti rimanenti. Un elemento può attendere arbitrariamente a lungo nel buffer, quindi la sua posizione può spostare qualsiasi importo a destra.

Non sembra esserci un buon modo per produrre e rimuovere un elemento casuale da un elenco. Mischiare sembra eccessivo. È più lungo di 2 byte l.pop(randint(0,9))(che utilizza che l'elenco ha 10 elementi).

from random import*
l=[]
while 1:l+=input(),;l[9:]and print(l.pop(randint(0,9)))

Non è meglio fare x=choice(l);l.remove(x). Una lingua con poprandomlike

poprandom = lambda l:l.pop(randrange(len(l)))

potrebbe fare molto chiaramente

from random import*
l=[]
while 1:l+=input(),;l[9:]and print(poprandom(l))

Befunge ( sapore strano ), 4 byte

?,?~

,legge un personaggio dal flusso e lo inserisce nella pila. ~estrae il personaggio principale dalla pila (se presente) e lo stampa. ?randomizza quale comando verrà eseguito successivamente. Quindi l'algoritmo qui è "In un ciclo infinito, con uguale probabilità o spingere un personaggio o pop un personaggio". Penso che questo soddisfi i requisiti: un personaggio può vedere arbitrariamente molti personaggi aggiunti sopra di esso nella pila, quindi può spostarsi arbitrariamente lontano a destra e può essere stampato quando la pila è arbitrariamente grande, quindi può spostarsi arbitrariamente lontano la sinistra.

C (gcc) , 94 byte

L;i;f(s){srand(s);int B[9]={0};for(L=0;;)L>9&&putchar(B[i=rand()%10]),B[L>9?i:L++]=getchar();}

Provalo online!

Ok, un collegamento TIO non ha molto senso. Per facilità di test, ho creato il seguente programma C che produrrà caratteri ASCII casuali o ripeterà una stringa all'infinito.

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
int main(int argc, char** argv){
    srand(time(NULL));
    if(argc < 1) {
        for(;;){
            printf("%c", rand() % 95 + 32);
        }
    } else {
        char* s = argv[1];
        int i = 0;
        for(;;){
            if(s[i] == 0)
                i = 0;
            printf("%c", s[i++]);
        }
    }
}

Questo programma verrà indicato come iro.

Correttezza del programma

Quello che faccio qui è leggere i 9valori in un buffer. Successivamente, gli indici casuali vengono scelti da questa matrice e vengono emessi, quindi sostituiti dal carattere successivo nel flusso.

SILOS , 149 byte

b=1
lbla
x=15+b*15
b=1
lblb
readIO
queue 0 i
x-1
if x b
a=0
lblx
x=rand*2
queuePop 0
if x X
printInt m
a+1
b=15-a
if b x
GOTO a
lblX
queue 0 m
GOTO x

Provalo online!

In sostanza continua a ricevere input (sull'interprete online tramite argomenti, ma sull'interprete ufficiale offline ti permetterà di digitare nella console (all'infinito)) in blocchi di 15 alla volta (30 il primo blocco).

Carica l'input in una coda temporanea e seleziona un fortunato 15 (in modo casuale, ma non equamente distribuito in termini di probabilità o distribuzione).

Il resto rimane mentre i nuovi input riempiono la coda, il primo input potrebbe essere mischiato fino alla fine (in pratica penso che i personaggi seguano una distribuzione normale). È interessante notare che questo programma è solo due volte più dettagliato di Python e forse "più golfista" di Java.

Per vedere meglio i risultati, ho una versione non conforme che accetta input come stringa (tuttavia può contenere solo 8.000 caratteri circa).

Provalo online!

Solo per divertimento, ecco questo post alimentato attraverso la versione di stringa.

 [.L.Ooy "9beS.IS]," 14 ts b1
 nly

  = ll
   x = 1b 15 1
5b a * b = lb rd # + lb eaI O e 
 X
 ifquu   
1 0x b
   =

    e
0
   i lblxa -d * 2
    quu x = rn 
   x Xea p0
   pnInt ora
   mf = iePit
  ba 1
   GTO 1 fb x + Oa


 qe -lblX u0 m GOOue  
[RLT 

 tnn5! I.STii] [S.LO ie

htpsgthyx]: iub.om/jhujh .. tcraa.IOo /TytonieSu:wl/.L lnn!: tt / iS
[In hsto.un / nuslprxRUCoDsio /]: e#NzZn6j4c/2xNQFnF7y0aLzkrosd9Dov2yxJNx774HBrgPUdi9CySI09sCLw5TJwB7jlB1XVeQFE7m1VMsIQvDOjBmdtME3umNzYXs9unFbqRamVDfUDw@RT3NHoL7/i04bz16DCoP4eulOU7jPD8OmYjATpynkuMDuBPYmtnIJzseyyhaNkMyQgXG2R782vqMDIiUm6Kq4Q3mJkxlUsR1rrldPw./l28Z SL.XS - IONuscOT "
senallyxMz.stiitkp ingN "
 eestaint on heeInliinrprt (oe e toghr tetgpnmntuon eruEuut rh ofi off, bhenecil inretea.atr ialoks tirilw upeitfleptly ty honso (e oote cenfine iwllbc 15 atly) nitloo aim (te) nikfte3 firs
hs 0It te 
 lodshipo alauttt.mpra quuet reanicks a lck eooy d randomyn p 15 (uo equl, untty drbutedaynistinems oftrly ordisrprob ill abition h ibttmin.Tet ri)
 a nwit u ree nusfil th queusen 
pte ftip, ae uldsfuesis ob hl rlelth weual t tc hdyoend, f tbaaly thi an elnkhecarcthe (sc ho noreiItrolwaaldibtio lmiru.t 'iereaf) tsng tetntiottssht prasnon hogosc
 tte s / "gt 
obterelIe tsvea non-omhTrehs a plntvesion hcahihk ine teuts sriprics at rwvritcaw aa g (hoee n onl kein n00 orscat, 0 cter).

[Tyauoas itine! Hrhrys :.ru] p // o / lsslo # JVD (tinnexi3E @ KDpit / LrhtwXwVEUuscxPmJjFFCaNimMzlHiQEcMmdVIT7vqs8mNgxU3mD / J1AwXq / ivbao1j @ nb4I6 / m93655bThmb4cy5TUX3xvI018cZzrXItuO5B @ NX5JD / HzyE @ G @ @ D5eqrGem3l0HPGRutZfpi2PzVA d3CVRTm4zJxnZdcFSTEO0JOT9KhDI6byjnLhS0cNmGz7hJrTdAgORT8Ndvv7DgZSbJdkp9v5al8qMyNCb9tXe0ChrShXRTOt @ @ 7fFgV3zTkbVbsD JpKina2oKgNVakjsjLCpD29u7l0XVRWalVTyArF1FqypQAxXb / BedqUqpJGOPVyxOjLj0jXup8cE277L2I6 @ lSowK5pA7nGldRBiJwyKxF6z2c3kW / sJ4EYBbbpSuBxs55nyI9sdnu @ nJJeGqtKprGEUbc6NDGMjjO2tN / KuKTWh2WWbbRRLVaq / P6KqkoMNWGRgTQZLlbXfQI050bY0rz0xmzCVZ4vowjpV0dCmkDFq0VNa5GSDzVn5Qw7idwPTxu5xTAtLQCDN / YIApfAn4dsDmYksCqUU27sRggpzRK4SmdjmPUPQO4j5FmgHMFRWS2eI1CfA2YIcf7JlylFjdZypVTH0IJu4ZJHiUviyBFKqhrkCjgXAAB8d710NhHgDwcJksuvPPprcfzHPTaJGFX8OIExW / cBZjaPiY7a4WD6rTYmOouBVucROlwvuBJiHWdJQjjbobNGTd7M1P6z8dw / A @ @ GU02hgjCcrjjQHkAdS6r7UjQ6wAPqB sIgxkKcbZDixeWS6mn160CKQpn7aUwGLK22u9I0oX6YIwPMhFVaX5uYon0AyoNTCZvnmtilVhV3 / pgTGc7r39lIS5PmqM / NGnUSLnTw9eTJ7qqrNQKsJHz @ Tt8mDZVWKCKTkBro1PuQAksDdN1yaVGiVXElRW9i5M11cINmxNGYAg9TD7sxtEDI2OkKMaBXgvO5dOplUQQIdpb2w66NePBScMmEnAX8ydGSiiHlss @ hOLZzInnIoTevRtEm / TGHWOkly5ljMK4FkgDDSWCWBW3YwmEVYCIBV @ GMIg3TZtGwMFWXVxQwBb5iD6PfS7h7Sric1ib5ZYIvW6n3tlaK7 / 6 @ @ 3OAHy4LjOuW tzaBP3 @ mFbJpHsVsQKPfeui / o1 @ @ aBcbZ4TK96T8tp3QjeA1vDXMKBIqdK HZs2vsMlQE36YmrBEnVRUvAGNuCt44e0RB0sL0MkNu1Q5wOwliTT2JQzVrOnHAmSXIU // sqjdG6jdT2r1v @@ lGjouzkGWoD4zhnzJBxo0OT6OTbBDgeDFRnY8TMXZbMPdxsCtbXeUxIBqST4VRwkpbgwChBcJxMx6hLIVZhfuylDvF1l26Nbl3xRLgQnatSCMigx @ PCT6lcG1ebdk / 86UBUFp9UkxjoCGSJnlxMtUdHf6IjkMnil5aua9L @ xXsdHEKW @ @ 8JpVqlgKsr12bAKG2Typfv Yy4CkUydETWphcdmdpWq7egtxqP8pYI2rSaSuYBwW0tNTdXn4qcjnZ9JKhuVwaWRycwCWt247LSflsCHsB3u0KoLTQJzL1uMl0duij / IF7LCc5FSpIPW7gcjOYj @ jQdpQHv0WUz / IbMhS0XmFiWm1i0cTbxXjsjLxt6nGmQNQoKfREklc8pTFyHub7jUg8TR4QrZ2w3YjaLWNi @ FFerCnNgY0LqgrA6qkWg8H / 7Pv6YhtqeZzvoB0yD5Wm1eLL1Vf / SouI0Q / fox7eQlXieZB1F1v2 / in / btqyVPtubWhDIKH8WaTlry43N6HgOEzX5HOjv1 @ lamBeZlJpqJnG3B2LZe8sXUafdAcVvVjBBlqxbEThCdjpelc7YVuYXOqM8MyVV3iPxbqYu @ nmbHnoKpK1Eww11sA9aiwN8kMe0ioVO7qnucL1A8wHJ4wTsdltrm3CC4bpCd5hMhyDGXSdGgdKvnCKUpNB9nH @ wXLgu5iUEcfJbDKZFjx6gI9i8fCcUFiQXxeSbKnwhT6 @ v / I6yS / Ew9k @ tgI68 / Lo @ 4jjx0PZBpSo5vWLCDi4zb @ TJejQQPtvlgde98MDGJ4vUW3T @ iJTA89gGhUJIgy @ MDBpaz3s7PT2ZIwStVANsxpCmhghh68huncD0VdumQt0lT / Su6HW3kMLFfo / FphQ0QhtoZ5iRN / @ Hz / DmHq8UZEgiblprekkw1I366fMhePmDclSxirOlYH2Hwe3fom3aoe1 @ yaQYwi5ZPd2FcITXO7cu9 @ 6tiHZJc7lKSB8e3 / mXx34xYH / 8F @ TUxx / 5vs5yHsYBL4ekscycqT1BnuV19 / "SFE / iRAIL.O NqUXAm. T3zDreu) .S –IOxs. "ddd

Aceto , 24 byte, non concorrenti

Non competitiva perché ho dovuto correggere un bug nell'interprete.

^




OYpO
r^`!
?d0=   >

Prende un flusso infinito di linee e le produce in un ordine casuale. Ogni elemento ha la possibilità di verificarsi in qualsiasi punto casuale.

Iniziamo con un ?nell'angolo in basso a sinistra, che ci sposta in una direzione casuale. Se è in basso o a sinistra, veniamo spinti indietro.

Se ci rspostiamo verso l'alto, dichiariamo un valore, mescoliamo lo stack ( Y) e torniamo indietro al Origin.

Se ci dspostiamo a destra, aumentiamo il valore dello stack superiore, spingiamo a 0e testiamo l' uguaglianza (dal momento che stiamo leggendo le stringhe, non possiamo mai avere l'intero 0). Se i valori sono uguali, significa che abbiamo raggiunto il fondo della pila (da cui non vogliamo stampare). Noi neghiamo il confronto ( !), e pRint solo se ( `) le cose non erano uguali. Quindi torniamo anche alla ORigin.

Rubino, 43 byte

l=[];loop{l<<gets;l[9]&&$><<l.shuffle!.pop}

La mia risposta originale utilizzava un elenco infinito valutato in modo pigro, ma questo è più breve. Oh bene.

MATL , 11 byte

`rEkN*?D}iT

Provalo online!

La risposta Befunge di Port of Histocrat .

Spiegazione: (Grazie a Luis Mendo per -1 byte)

`         T % Start do-while (`) .... true (T)
 rEk        % 50-50 chance of outputting or inputting:
            %   Random number between 0...1, multiplied by 2 and converted to logical. 
    N       % Check if there is anything on the stack to output
     *?     % If there is anything on the stack and (*) we want to output:
       D    % Output. Sadly, D errors when the stack is empty, requiring the N*
        }i  % Else, input.

Questo produce quasi sicuramente in tempo finito, e quasi sicuramente richiede solo memoria finita .

Per completezza, ecco una versione a 15 byte che mantiene un buffer di 10 elementi e genera un elemento casuale da quello:

`htnt9>?Yr&)wDT

Mi piace questa versione per il molto idiomatico (per quanto le lingue del golf possano essere idiomatiche) tn...Yr&), che estrae un elemento casuale dall'elenco e restituisce l'elenco senza quell'elemento. Tuttavia, la particolare logistica di questa sfida aggiunge molti byte (il necessario wper la visualizzazione, il t9>?per verificare se l'elenco è abbastanza pieno ...).

Alice , 7 byte

a&IdU,O

Provalo online!

Questo dovrebbe funzionare su un input infinito con tempo e memoria infiniti, ma non è così facile testarlo in pratica :)

Spiegazione

a&I         Push 10 characters from the input to the stack.
     d        Push the depth of the stack.
      U       Pop a number (d), push a random number in [0,d)
        ,       Pop a number (n), move the element which is n elements below the top to the top of the stack.
         O    Output the character on top of the stack.

                Execution loops back to the beginning of the line.

Ad ogni iterazione vengono letti 10 caratteri dall'input e solo uno va all'output, quindi l'utilizzo della memoria aumenta linearmente durante l'esecuzione. Con un input limitato questo raggiunge rapidamente EOF, da cui dieci -1 verranno inseriti nello stack ad ogni iterazione. Cercare di produrre -1 come personaggio non ha alcun effetto, ma è improbabile che tutti i caratteri dell'input vengano stampati in un ragionevole lasso di tempo.

La posizione i dell'output può essere presa da qualsiasi personaggio nell'input fino alla posizione 10i , questo è conforme alla sfida che richiede almeno un intervallo da i-9 a i + 9 .

C, 214 byte

c;i;char B[19]={0};char*I;
S(p,q){if(B[p]-B[q])B[p]^=(B[q]^=(B[p]^=B[q]));}
R(n){while(n--)putchar(B[c]),B[c]=*I,c=++i%19,I++;}
main(c,v)char**v;{srand(time(0));I=v[1];R(19);i=9;for(;;){S(i,rand()%19);R(1);i=++i%19;}}

Come funziona

Prova online (UNIX)

#include <stdio.h>
#include <unistd.h>

// animation speed
#define ANIMATION_SLOW 600000
#define ANIMATION_NORMAL 400000
#define ANIMATION_FAST 200000

c;i;char Buffer[19]={0};char*input;
Swap(p,q){if(Buffer[p]!=Buffer[q])Buffer[p]^=(Buffer[q]^=(Buffer[p]^=Buffer[q]));}
Read(n){while(n-->0)putchar(Buffer[c]),Buffer[c]=*input,c=++i%19,input++;}

main(int argc, char**argv)
{
    // initialization
    srand(time(0));
    input=argv[1];
    Read(19);i=9;

    // shuffle machine
    while(1)
    {
        usleep(ANIMATION_NORMAL);
        Swap(i,rand()%19);
        Read(1);
        i=++i%19;
    }
}

05AB1E , 13 byte

[I)˜¼¾T›i.rć,

Provalo online! (modificato per prendere 20 elementi)

[             # Infinite loop
 I)˜          # Add the next element from input to the array
    ¼         # Increment the counter variable
     ¾T›i     # If the counter variable is greater than 10...
         .r   #   Get a random permutation of the array
           ć, #   Print and remove the first element 

Bash , 17 byte

xargs -n9 shuf -e

Provalo online!

xargs prende continuamente 9 lettere da STDIN e le manda in ordine casuale

un elenco infinito può essere generato da:

yes {a..z}

che stampa abcde .. z volte infinite.

Il test potrebbe essere eseguito da:

yes {a..z} | xargs -n9 shuf -e 

R, 70 byte

x=NULL;repeat{x=sample(c(x,scan()));if(sum(x|1)>9){cat(x[1]);x=x[-1]}}

Inizia con un vettore vuoto x. In un ciclo infinito, prende un nuovo valore da STDIN, quindi mescola il vettore. Quindi controlla se la lunghezza dell'elenco creato è 10 o superiore. In tal caso, può iniziare a stampare. In questo modo il vettore ha un buffer di 10 input, ognuno dei quali viene mischiato in ogni iterazione. Quindi è possibile che l'input venga stampato 10 posti prima e infinitamente molti posti dopo (seguendo una distribuzione geometrica con p=1/10). Quando il buffer è abbastanza lungo, il primo elemento viene stampato e rimosso dal vettore.

Javascript, 78 byte

for(l=[];;){l.push(prompt());l.length==10&&alert(l.splice(Math.random()*9,1))};x.sort(()=>Math.random()<0.5);alert(x)}

Utilizza lo stesso metodo della risposta di xnor.

Perl 5 , 39 byte

38 byte di codice + -nflag.

print splice@F,rand 10,1if 9<push@F,$_

Provalo online!

Aggiungi ogni elemento @Fall'array (con push@F,$_). Quando @Fcontiene 10 elementi ( pushrestituisce il numero di elementi nell'array, quindi 9<push...), un elemento casuale viene rimosso e stampato ( splice@F,rand 10,1per rimuovere l'elemento, printper stamparlo).
L'output inizia a verificarsi dopo che è stato letto il decimo elemento. Quindi, ogni elemento può iniziare ad apparire almeno 9 posizioni prima di quello originale e può essere spostato all'infinito verso destra.

SmileBASIC, 61 58 byte

@L
B$=B$+R()IF I>8THEN R=RND(9)?B$[R];:B$[R]="
I=I+1GOTO@L

Ogni carattere dell'elenco infinito viene aggiunto alla fine del buffer. Quando la lunghezza del buffer è 11, un carattere casuale viene stampato e rimosso.

La funzione Rgenera il carattere successivo.

Prolog, 70 byte

s(L):-get0(C),(length(L,9)->random_select(H,L,R),put(H);L=R),s([C|R]).