Über die Serie

Zunächst einmal können Sie dies wie jede andere Code-Golf-Herausforderung behandeln und beantworten, ohne sich Gedanken über die Serie zu machen. Es gibt jedoch eine Rangliste für alle Herausforderungen. Sie finden die Rangliste zusammen mit einigen weiteren Informationen über die Serie im ersten Beitrag .

Loch 8: Mische eine unendliche Liste

Sie sollten eine Funktion oder ein Programm schreiben, das eine unendliche Liste als Eingabe verwendet und eine gemischte Version dieser Liste zurückgibt.

Über unendliche I / O

Es gibt verschiedene Möglichkeiten, wie Sie Eingaben vornehmen und Ausgaben für diese Herausforderung erstellen können:

• Sie können entweder eine Liste positiver Ganzzahlen oder eine Zeichenfolgendarstellung davon oder eine Zeichenfolge oder eine Liste druckbarer ASCII-Zeichen (einschließlich 0x20 bis 0x7E) verwenden. Das Ausgabeformat muss mit dem Eingabeformat übereinstimmen. Ich bezeichne die Daten nur noch als "die Liste", unabhängig davon, welche Option Sie wählen.
• Sie können die Liste aus einem unendlichen Standardeingabestream lesen und die Ausgabe kontinuierlich in einen unendlichen Standardausgabestream schreiben. Die Lösung sollte nicht von einem bestimmten Wert oder einer bestimmten Wertereihenfolge abhängen, um sicherzustellen, dass der Ausgabestream regelmäßig geschrieben und gelöscht wird (z. B. können Sie nicht einfach eine Ausgabe schreiben, wenn sich eine 5in der Eingabeliste befindet). Wenn Sie eine Zeichenfolgendarstellung einer Liste lesen, können Sie natürlich warten, bis Sie auf das Listentrennzeichen stoßen.
• In Sprachen, die diese unterstützen, können Sie eine Funktion schreiben, die eine verzögerte unendliche Liste oder Zeichenfolge annimmt und zurückgibt.
• In Sprachen, die sie unterstützen, können Sie einen unendlichen Generator implementieren, der einen anderen Generator als Eingabe verwendet.
• Alternativ können Sie eine Funktion schreiben, die keine Argumente akzeptiert und bei jedem Aufruf einen Ausgabewert zurückgibt. In diesem Fall können Sie davon ausgehen, dass eine Funktion definiert wurde, die keine Argumente akzeptiert und bei jedem Aufruf den nächsten Eingabewert zurückgibt. Sie können den Namen dieser Funktion frei wählen.

Sie können davon ausgehen, dass Ihr Programm für immer ausgeführt wird und dass unendlicher Speicher verfügbar ist. (Es ist möglich, dies mit einer begrenzten Menge an Speicher zu lösen. Dies bedeutet jedoch, dass Sie Speicher verlieren dürfen.)

Über die Zufälligkeit

Für jeden Wert v, der an einer Position i der unendlichen Eingabe gelesen wird , muss eine positive Wahrscheinlichkeit bestehen, dass er an einer der Positionen i-9 bis i + 9 der unendlichen Ausgabe endet (es sei denn, diese Position wäre negativ) ). Diese Wahrscheinlichkeiten müssen nicht für verschiedene Ausgabepositionen oder sogar für verschiedene Eingabepositionen gleich sein. Es ist in Ordnung, wenn Ihre Lösung die Werte auch an eine andere, weiter entfernte Position verschieben kann.

Daher ist es nicht erforderlich, dass Ihre Lösung den ersten Wert sehr weit unten in der Liste oder einen sehr späten Wert bis zur ersten Position mischen kann, obwohl dies in Ordnung ist, solange alle Positionen 9 Schritte von der Liste entfernt sind Eingaben sind möglich.

Wenn Sie beispielsweise den folgenden String als Eingabe verwendet haben, ___gibt der alle Positionen an, die Xin der Ausgabe enthalten sein müssen:

                  ___________________
 abcdefghijklmnopqrstuvwxyzXabcdefghijklmnopqrstuvwxyz...

Fehlt in Ihrer Sprache ein integrierter Zufallszahlengenerator oder möchten Sie diesen nicht verwenden, können Sie einen zusätzlichen Startwert als Eingabe verwenden und mithilfe des Startwerts ein eigenes geeignetes RNG implementieren . Diese Seite kann hilfreich sein.

Unabhängig von der tatsächlichen Verteilung, die Ihre Lösung verwendet, muss sie mit ziemlicher Sicherheit nach einer endlichen (aber willkürlichen) Zeit den nächsten Wert erzeugen.

Bitte erläutern Sie kurz, wie Ihre Implementierung diese Anforderungen erfüllt.

Wertung

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Bestenliste

Der erste Beitrag der Serie generiert eine Rangliste.

Um sicherzustellen, dass Ihre Antworten angezeigt werden, beginnen Sie jede Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

# Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie Ihren Score zu verbessern, Sie können alte Rechnungen in der Überschrift halten, indem man sich durch das Anschlagen. Zum Beispiel:

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

(Die Sprache wird derzeit nicht angezeigt, das Snippet erfordert sie jedoch und analysiert sie. In Zukunft werde ich möglicherweise eine Bestenliste nach Sprachen hinzufügen.)

Python 3 , 78 Bytes

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

Probieren Sie es online!

Nimmt die Eingabe von STDIN (eine pro Zeile) und druckt auf STDOUT.

Hält einen Puffer lvon bis zu 10 Elementen. Der Puffer wird bei jedem Schritt gemischt. Bei einer Länge von 10 wird das letzte Element gedruckt und entfernt.

Wenn ein Element gedruckt wird, sobald es eingefügt wurde, hat es 9 andere im Puffer wartende Elemente übersprungen, sodass 9 Stellen übrig bleiben. Ein Element kann beliebig lange im Puffer warten, sodass sich seine Position beliebig nach rechts verschieben kann.

Es scheint keine gute Möglichkeit zu geben, ein zufälliges Element aus einer Liste zu erzeugen und zu entfernen. Mischen scheint übertrieben. Die zu verwendende Länge beträgt 2 Byte l.pop(randint(0,9))(was bedeutet, dass die Liste 10 Elemente enthält).

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

Es ist nicht besser. x=choice(l);l.remove(x)Eine Sprache mit poprandomwie zu tun

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

könnte sehr sauber machen

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

Befunge ( quirkster Aroma ), 4 Bytes

?,?~

,Liest ein Zeichen aus dem Stream und schiebt es auf den Stapel. ~Entfernt das oberste Zeichen aus dem Stapel (falls vorhanden) und druckt es aus. ?Randomisiert, welcher Befehl als nächstes ausgeführt wird. Der Algorithmus hier lautet also "In einer Endlosschleife mit gleicher Wahrscheinlichkeit entweder ein Zeichen drücken oder ein Zeichen platzen lassen." Ich denke, dies genügt den Anforderungen: Ein Zeichen kann beliebig viele Zeichen darüber im Stapel sehen, so dass es sich beliebig weit nach rechts bewegen kann, und es kann gedruckt werden, wenn der Stapel beliebig groß ist, so dass es sich beliebig weit nach rechts bewegen kann die linke.

C (gcc) 94 Bytes

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();}

Probieren Sie es online!

Ok, ein TIO-Link macht nicht viel Sinn. Zum leichteren Testen habe ich das folgende C-Programm erstellt, das zufällige ASCII-Zeichen ausgibt oder eine Zeichenfolge unendlich wiederholt.

#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++]);
        }
    }
}

Dieses Programm wird als bezeichnet iro.

Programmkorrektheit

Was ich hier mache, ist 9Werte in einen Puffer zu lesen . Danach werden Zufallsindizes aus diesem Array ausgewählt und ausgegeben und dann durch das nächste Zeichen im Stream ersetzt.

SILOS , 149 Bytes

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

Probieren Sie es online!

Im Wesentlichen nimmt es weiterhin Eingaben entgegen (auf dem Online-Interpreter durch Argumente, aber auf dem offiziellen Offline-Interpreter können Sie (unendlich) in Blöcken von jeweils 15 eingeben (30 der erste Block).

Es lädt die Eingabe in eine temporäre Warteschlange und wählt eine glückliche 15 aus (zufällig, aber in Bezug auf Wahrscheinlichkeit oder Verteilung nicht gleichmäßig verteilt).

Der Rest verbleibt in der Warteschlange, während neue Eingaben die Warteschlange füllen. Die erste Eingabe kann bis zum Ende gemischt werden (im Grunde genommen folgen die Zeichen einer Normalverteilung). Interessanterweise ist dieses Programm nur doppelt so ausführlich wie Python und möglicherweise "golfer" als Java.

Um die Ergebnisse besser sehen zu können, habe ich eine nicht konforme Version, die Eingaben als Zeichenfolge akzeptiert (es können jedoch nur etwa 8.000 Zeichen eingegeben werden).

Probieren Sie es online!

Nur zum Spaß, hier ist dieser Beitrag durch die String-Version gespeist.

 [.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) bckfte3
hs 0It te 
 lodshipo alauttt.mpra quuet i reanicks a lck eooy d randomyn p 15 (uo equl, unbtty drbutedaynistinems oftrly ordisrprob ill abition)
 eine neue 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)
 tte s / "gt 
obterelIe tsvea non-omhTrehs a plntvesion hcahihk ine teuts sriprics bei rwvritcaw aa g (hoee n onl kein n00 orscat, 0 cter).

[Tyauoas it onine! 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 Bytes, nicht konkurrierend

Nicht konkurrierend, weil ich einen Fehler im Interpreter beheben musste.

^




OYpO
r^`!
?d0=   >

Nimmt einen unendlichen Strom von Linien und gibt sie in zufälliger Reihenfolge aus. Jedes Element hat die Chance, an einem beliebigen Punkt aufzutreten.

Wir beginnen mit einer ?in der linken unteren Ecke, die uns in eine zufällige Richtung bewegt. Wenn das unten oder links ist, werden wir gleich zurückgeschoben.

Wenn wir uns nach oben bewegen, rlesen wir einen Wert, mischen den Stapel ( Y) und springen zurück zum ORigin.

Wenn wir nach rechts dverschoben werden , erhöhen wir den obersten Stapelwert, drücken a 0und testen auf Gleichheit (da wir Zeichenfolgen lesen, können wir niemals die ganze Zahl 0 haben). Wenn die Werte gleich sind, haben wir das Ende des Stapels erreicht (von dem aus wir nicht drucken möchten). Wir negieren den Vergleich ( !) und pschreiben nur, wenn ( `) die Dinge nicht gleich waren. Dann springen wir auch zurück zur ORigin.

Ruby, 43 Bytes

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

Meine ursprüngliche Antwort verwendete eine faul bewertete unendliche Liste, aber diese ist kürzer. Naja.

MATL , 11 Bytes

`rEkN*?D}iT

Probieren Sie es online!

Port of Histocrat's Befunge Antwort .

Erklärung: (Danke an Luis Mendo für -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.

Dies gibt mit ziemlicher Sicherheit in endlicher Zeit aus und erfordert mit ziemlicher Sicherheit nur endlichen Speicher .

Der Vollständigkeit halber ist hier eine 15-Byte-Version, die einen 10-Elemente-Puffer enthält und daraus ein zufälliges Element ausgibt:

`htnt9>?Yr&)wDT

Ich mag diese Version für das sehr idiomatische (soweit Golfsprachen idiomatisch sein können) tn...Yr&), das ein zufälliges Element aus der Liste entfernt und die Liste ohne dieses Element zurückgibt. Die besondere Logistik dieser Herausforderung fügt jedoch eine Menge Bytes hinzu (die wfür die Anzeige erforderlich sind, um t9>?zu überprüfen, ob die Liste voll genug ist ...).

Alice , 7 Bytes

a&IdU,O

Probieren Sie es online!

Dies sollte bei einer unendlichen Eingabe mit unendlicher Zeit und unendlichem Speicher funktionieren, aber in der Praxis ist es nicht so einfach zu testen :)

Erläuterung

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.

Bei jeder Iteration werden 10 Zeichen von der Eingabe gelesen und nur eines geht zur Ausgabe, sodass die Speichernutzung während der Ausführung linear zunimmt. Mit einer endlichen Eingabe erreicht dies schnell EOF, von dem zehn -1 bei jeder Iteration auf den Stapel verschoben werden. Der Versuch, -1 als Zeichen auszugeben, hat keine Auswirkung, aber es ist unwahrscheinlich, dass alle Zeichen der Eingabe in angemessener Zeit gedruckt werden.

Die Position i der Ausgabe kann von jedem Zeichen in der Eingabe bis zur Position 10i eingenommen werden. Dies entspricht der Herausforderung, die mindestens einen Bereich von i-9 bis i + 9 erfordert .

C 214 Bytes

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;}}

Wie es funktioniert

Online testen (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 Bytes

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

Probieren Sie es online! (geändert um 20 Elemente aufzunehmen)

[             # 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 Bytes

xargs -n9 shuf -e

Probieren Sie es online!

xargs nimmt fortlaufend 9 Buchstaben von STDIN entgegen und sendet sie an shuffle

Eine unendliche Liste kann erzeugt werden durch:

yes {a..z}

was abcde druckt .. z unendlich oft.

Der Test könnte durchgeführt werden von:

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

R, 70 Bytes

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

Beginnt mit einem leeren Vektor x. In einer Endlosschleife nimmt es einen neuen Wert von STDIN und mischt dann den Vektor. Dann wird geprüft, ob die Länge der aufgebauten Liste 10 oder mehr beträgt. Ist dies der Fall, kann der Druckvorgang gestartet werden. Auf diese Weise hat der Vektor einen Puffer von 10 Eingaben, von denen jede in jeder Iteration gemischt wird. So ist es möglich, dass Eingaben 10 Stellen früher und unendlich viele Stellen später gedruckt werden (nach einer geometrischen Verteilung mit p=1/10). Wenn der Puffer lang genug ist, wird das erste Element gedruckt und aus dem Vektor entfernt.

Javascript, 78 Bytes

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

Verwendet die gleiche Methode wie die Antwort von xnor.

Perl 5 , 39 Bytes

38 Byte Code + -nFlag.

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

Probieren Sie es online!

Fügen Sie jedes Element zum @FArray hinzu (mit push@F,$_). Wenn @F10 Elemente enthalten sind ( pushgibt also die Anzahl der Elemente im Array zurück 9<push...), wird ein zufälliges Element entfernt und gedruckt ( splice@F,rand 10,1um das Element zu entfernen, printum es zu drucken).
Die Ausgabe beginnt, nachdem das 10. Element gelesen wurde. Daher kann jedes Element mindestens 9 Positionen vor seiner ursprünglichen Position erscheinen und kann unendlich nach rechts verschoben werden.

SmileBASIC, 61 58 Bytes

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

Jedes Zeichen der unendlichen Liste wird am Ende des Puffers hinzugefügt. Wenn die Pufferlänge 11 ist, wird ein zufälliges Zeichen gedruckt und entfernt.

Funktion Rerzeugt das nächste Zeichen.

Prolog, 70 Bytes

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