Seriler Hakkında

Öncelikle, buna diğer herhangi bir kod golf mücadelesi gibi davranabilir ve seri hakkında endişelenmeden cevap verebilirsiniz. Ancak, tüm zorluklarda bir lider tablosu var. Afiş ilk yazı dizisi hakkında daha fazla bilgi ile birlikte bulabilirsiniz .

Delik 8: Sonsuz bir listeyi karıştır

Girdi olarak sonsuz bir liste alan ve o listenin karıştırılmış halini döndüren bir işlev veya program yazmalısınız.

Sonsuz G / Ç Hakkında

Bu zorluk için girdi almanın ve çıktı üretmenin birkaç yolu var:

• Olumlu bir tamsayı listesi veya bir dize temsili veya bir basılabilir ASCII karakter listesi (0x20 ila 0x7E, dahil) alabilir. Çıkış formatı giriş formatıyla eşleşmelidir. Seçtiğiniz seçenek ne olursa olsun, verilere bundan sonra "liste" olarak bakacağım.
• Listeyi sonsuz bir standart giriş akışından okuyabilir ve çıktıyı sürekli bir sonsuz standart çıkış akışına yazabilirsiniz. Çözüm, çıktı akışının düzenli olarak yazılmasını ve temizlenmesini sağlamak için herhangi bir özel değere veya değer sırasına bağlı olmamalıdır (örneğin 5, giriş listesinde bir varsa çıktı yazamazsınız ). Tabii ki, bir listenin string gösterimini okursanız, liste ayırıcı ile karşılaşana kadar beklemeniz uygundur.
• Onları destekleyen dillerde tembel bir sonsuz liste veya dize alan ve döndüren bir işlev yazabilirsiniz.
• Onları destekleyen dillerde, başka bir jeneratörü giriş olarak alan sonsuz bir jeneratör kullanabilirsiniz.
• Alternatif olarak, hiçbir argüman almayan ve her çağrıldığında bir çıktı değeri döndüren bir fonksiyon yazabilirsiniz. Bu durumda, hiçbir argüman almayan ve bir sonraki giriş değerini her çağrıldığında döndüren bir fonksiyonun tanımlanmış olduğunu varsayabilirsiniz. Bu işlevin adını serbestçe seçebilirsiniz.

Programınızın sonsuza dek çalıştığını ve sonsuz hafızanın mevcut olduğunu varsayabilirsiniz. (Bunu sınırlı miktarda bellekle çözmek mümkündür, ancak bunun anlamı bellek sızdırmasına izin vermenizdir.)

Rastgele hakkında

Sonsuz girişin i konumunda okunan herhangi bir v değeri için , sonsuz çıkışın i-9 ila i + 9 pozisyonlarından herhangi birinde bitmesi için pozitif bir olasılık olmalıdır (eğer bu pozisyon negatif olmazsa) ). Bu olasılıklar farklı çıktı konumları için ve hatta farklı girdi konumları için aynı olmak zorunda değildir. Çözümünüz, değerleri daha uzaktaki başka bir konuma de karıştırabilirse sorun yoktur.

Bu nedenle, çözümünüzün listenin en üstündeki ilk değeri karıştırması veya tüm konumlar 9 adımından itibaren tüm adımları 9 adım attığı sürece iyi olmasına rağmen ilk geçişte çok geç bir değeri karıştırması gerekmez giriş mümkündür.

Örneğin, aşağıdaki dizgeyi girdi olarak aldıysanız , çıktının içine girmesi gereken ___tüm konumları belirtir X:

                  ___________________
 abcdefghijklmnopqrstuvwxyzXabcdefghijklmnopqrstuvwxyz...

Dilinizde yerleşik bir rasgele sayı üreteci yoksa veya kullanmak istemiyorsanız, giriş olarak ek bir tohum değeri alabilir ve tohumu kullanarak kendi uygun RNG'nizi uygulayabilirsiniz . Bu sayfa bunun için yardımcı olabilir.

Çözümünüzün kullandığı asıl dağıtımdan bağımsız olarak, kesin bir (ancak keyfi) bir süre sonra neredeyse bir sonraki değeri üretmesi gerekir .

Lütfen uygulamanızın bu gereklilikleri nasıl karşıladığına dair kısa bir açıklama ekleyin.

puanlama

Bu kod-golf , yani en kısa geçerli cevap - bayt olarak ölçülen - kazanır.

Liderler Sıralaması

Serinin ilk yazı lider tablosu oluşturur.

Cevaplarınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak her bir başlığa başlıkla başlayın:

# Language Name, N bytes

Gönderinizin Nbüyüklüğü nerede ? Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

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

(Dil şu anda gösterilmiyor, ancak snippet bunu gerektiriyor ve ayrıştırıyor ve gelecekte bir dilin lider tahtası ekleyebilirim.)

Python 3 , 78 bayt

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

Çevrimiçi deneyin!

STDIN'den (satır başına bir) girdi alır, STDOUT'a yazdırır.

l10 öğeye kadar bir tampon tutar . Tampon, her adımda karıştırılır. Uzunluğu 10 olduğunda, son eleman basılır ve çıkarılır.

Bir eleman yerleştirildiği anda basılırsa, tamponda bekleyen diğer 9 öğenin önüne atladı, böylece 9 nokta kaldı. Bir öğe arabellekte keyfi bir şekilde uzun süre bekleyebilir, böylece konumu herhangi bir miktarda doğru hareket edebilir.

Bir listeden rastgele bir öğe üretmenin ve kaldırmanın iyi bir yolu görünmüyor. Karıştırmak fazlaca görünüyor. Kullanımı 2 bayt daha uzundur l.pop(randint(0,9))(listenin 10 öğesi vardır).

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

Bunu yapmak için hiçbir iyidir x=choice(l);l.remove(x)ile .A dili poprandomgibi

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

çok temiz yapabilirdi

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

Befunge ( quirkster lezzet ), 4 bayt

?,?~

,Akıştan bir karakter okur ve yığına iter. ~(eğer varsa) yığındaki üst karakteri çıkarır ve yazdırır. ?Daha sonra hangi komutun yürütüldüğünü belirler. Bu yüzden buradaki algoritma "Sonsuz bir döngüde, eşit olasılıkla bir karakteri itin veya bir karakter pop'u" şeklindedir. Bunun gereklilikleri karşıladığını düşünüyorum: bir karakter yığının üstüne eklenmiş birçok karakteri keyfi olarak görebilir, böylece keyfi olarak sağa doğru hareket edebilir ve yığın isteğe bağlı olarak büyük olduğunda yazdırılabilir, böylece isteğe bağlı olarak uzaklaşabilir sol.

C (gcc) , 94 bayt

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

Çevrimiçi deneyin!

Tamam, bir TIO bağlantısı pek mantıklı değil. Test kolaylığı için, rasgele ascii karakterleri çıktısını ya da bir dizgiyi sonsuz tekrarlayan aşağıdaki C programını oluşturdum.

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

Bu program olarak anılacaktır iro.

Program doğruluğu

Burada yaptığım, 9değerleri bir tampon belleğe okumaktır . Bundan sonra, rastgele endeksler bu diziden seçilir ve çıkarılır, ardından akıştaki bir sonraki karakterle değiştirilir.

SILOS , 149 bayt

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

Çevrimiçi deneyin!

Esasen girdi almaya devam ediyor (çevrimiçi tercüman üzerinde argümanlar aracılığıyla, ancak çevrimdışı resmi tercüman üzerinde konsola (sonsuz)) bir defada 15 bloktan (ilk blok 30) yazmanıza izin verecek.

Girdiyi geçici bir kuyruğa yükler ve şanslı bir 15 (rastgele ama olasılık veya dağılım açısından eşit dağılmaz) alır.

Yeni girişler kuyruğu doldururken geri kalan kısımda kalır, ilk giriş sonuna kadar karıştırılabilir (temelde karakterlerin normal bir dağılım izlediğini düşünüyorum). Bu programın, Java'dan yalnızca iki kat daha python ve belki de "golfier" kadar güzel olduğunu not etmek ilginçtir.

Sonuçları daha iyi görebilmek için girdiyi dizge olarak alan uyumlu olmayan bir sürüme sahibim (ancak yalnızca 8000 karakter alabilir).

Çevrimiçi deneyin!

Sadece eğlence için, işte dize sürümü ile beslenen bu yazı.

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

  = ll
   x = 1b 15 1
5b a * b = lb rd # + lb ea O E 
 x
 ifquu   
1 0x b
   =

    e
0
   ben lblxa -d * 2
    quu x = rn 
   x Xea p0
   öğleden sonra
   mf = iePit
  ba 1
   GTO 1 fb x + Oa


 qe -lblX u0 m GOOue  
[RLT 

 tnn5! I.STii] [S.LO yani

htpsgthyx]: iub.om/jhujh .. tcraa.IOo /TytonieSu:wl/.L lnn!: tt / iS
[Hsto.un içinde / nuslprxRUCoDsio /]: e#NzZn6j4c/2xNQFnF7y0aLzkrosd9Dov2yxJNx774HBrgPUdi9CySI09sCLw5TJwB7jlB1XVeQFE7m1VMsIQvDOjBmdtME3umNzYXs9unFbqRamVDfUDw@RT3NHoL7/i04bz16DCoP4eulOU7jPD8OmYjATpynkuMDuBPYmtnIJzseyyhaNkMyQgXG2R782vqMDIiUm6Kq4Q3mJkxlUsR1rrldPw./l28Z SL.XS - IONuscOT "
senallyxMz.stiitkp ingN "
 eestaint heeInliinrprt (oe e toghr tetgpnmntuon eruEuut rh ofi off, bhenecil inretea.atr ialoks tirilw upeitfleptly ty honso (e o cenfine iwllbc 15 atly)
saat 0 
 lodshipo alauttt.mpra quuet i lck eooy d randomyn p 15 yeniden değerlendirir (uq equl, unbtty drbutedaynistinems oftrly ordisrprob hasta abition h ibttmin.Tet ri)
 bir gün önce 
pte ftip, ae uldsfuesis ob hl hil t tc hdyoend, f tbaaly thi bir elnkhecarcthe (sc ho noreiItrolwaaldibtio lmiru.t 'iereaf) tsng tetntiottssht prasnon hogIms sadece er er ros py tet tet tet olf olf olf olf olf olf olf olf olf olf olf olf olf olf olf ap ap ap ap ap ap ap ap ap ap ap.
 tte s / "gt 
obterele tsvea non-omhTrehts bir hcahihk ine rwvritcaw aa g (s onee kein n00 orscat, 0 cter) sriprics öğretir.

[Tyauoas onine! Hrhrys :.ru] s // 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 @ h / I6yS / Ew9k @ tgI68 / lO @ 4jjx0PZBpSo5vWLCDi4zb @ TJejQQPtvlgde98MDGJ4vUW3T @ iJTA89gGhUJIgy @ MDBpaz3s7PT2ZIwStVANsxpCmhghh68huncD0VdumQt0lT / Su6HW3kMLFfo / FphQ0QhtoZ5iRN / @ Hz / DmHq8UZEgiblprekkw1I366fMhePmDclSxirOlYH2Hwe3fom3aoe1 @ yaQYwi5ZPd2FcITXO7cu9 @ 6tiHZJc7lKSB8e3 / mXx34xYH / 8-F @ TUxx / 5vs5yHsYBL4ekscycqT1BnuV19 / "SFE / iRAIL.O NqUXAm. T3zDreu) .S –IOxs. "ddd

Aceto , 24 bayt, rakipsiz

Rekabetçi değil çünkü tercümanda bir hatayı düzeltmek zorunda kaldım.

^




OYpO
r^`!
?d0=   >

Sonsuz sayıda satır akışı alır ve bunları rasgele sırada verir. Her elementin herhangi bir rastgele noktada oluşma şansı var.

?Sol alt köşeden başlayarak bizi rasgele bir yöne doğru hareket ettiriyoruz. Bu aşağı veya sola giderse, hemen geriye itiliriz.

Eğer yukarı doğru hareket redersek, bir değere hazırlık yaparız, yığını ( Y) karıştırırız ve tekrar Oteçhizata atlarız.

Sağa dtaşınırsak, en üstteki yığın değerini yükseltiriz, a 0ve eşitliği test ederiz (dizeleri okuduğumuzdan, 0 tamsayısına asla sahip olamayız). Değerler eşitse, bu yığının altına ulaştığımız anlamına gelir (bundan baskı yapmak istemiyoruz). Biz boşa karşılaştırma ( !) ve psadece (eğer Rint `şeyin eşit değildi). Sonra da Oteçhizata geri dönüyoruz.

Ruby, 43 bayt

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

Orijinal cevabım tembel olarak değerlendirilmiş sonsuz bir liste kullandı, ancak bu daha kısa. Oh iyi.

Matl , 11 bayt

`rEkN*?D}iT

Çevrimiçi deneyin!

Port histocrat en Befunge cevap .

Açıklama: (-1 bayt için Luis Mendo'ya teşekkürler)

`         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.

Bu, sonlu bir zaman içerisinde neredeyse kesinlikle çıktılar ve neredeyse kesinlikle yalnızca sonlu belleği gerektirir .

Tamamlanması için, burada 10 öğeli bir arabellek tutan ve bundan rasgele bir öğe çıkaran 15 baytlık bir sürüm var:

`htnt9>?Yr&)wDT

tn...Yr&)Listeden rastgele bir öğe çıkarıp listeyi o öğe olmadan geri döndüren, bu deyimi aptalca (golf dilleri deyimsel olduğu sürece) seviyorum . Ancak, bu zorluğun belirli bir lojistiği çok fazla bayt ekler ( wekran için gerekli t9>?, listenin yeterince dolu olup olmadığını kontrol etmek için ...).

Alice , 7 bayt

a&IdU,O

Çevrimiçi deneyin!

Bu sonsuz zaman ve hafıza ile sonsuz bir girdi üzerinde çalışmalı, ancak pratikte test etmek o kadar kolay değil :)

açıklama

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.

Her yinelemede, 10 karakter girdiden okunur ve yalnızca biri çıktıya gider, böylece bellek kullanımı yürütme sırasında doğrusal olarak artar. Sonlu bir girişle bu, hızlı bir şekilde EOF'ye ulaşır; on'dan her bir tekrarlamada on-1'e itilir. Bir karakter olarak -1 çıktısını almaya çalışmak bir etkiye sahip değildir, ancak girişin tüm karakterlerinin makul bir sürede basılması muhtemel değildir.

Pozisyon ı çıkış pozisyonu kadar giriş herhangi bir karakter ile alınabilir 10i , en az bir dizi gerektiren sorun ile bu uyumlu olduğu gelen I-9 için i + 9 .

C, 214 bayt

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

Nasıl çalışır

Çevrimiçi Deneyin (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 bayt

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

Çevrimiçi deneyin! (20 element alacak şekilde değiştirilmiş)

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

xargs -n9 shuf -e

Çevrimiçi deneyin!

xargs sürekli STDIN'den 9 harf alıyor ve karıştırmaya gönderir

sonsuz bir liste şu şekilde oluşturulabilir:

yes {a..z}

hangi abcde .. z sonsuz kez basar.

Test şu şekilde yapılabilir:

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

R, 70 bayt

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

Boş bir vektörle başlar x. Sonsuz bir döngüde, STDIN'den yeni bir değer alır, ardından vektörü karıştırır. Sonra oluşturulan listenin uzunluğu 10 veya daha yüksek olup olmadığını kontrol eder. Öyleyse, yazdırmaya başlayabilir. Bu şekilde vektör, her bir yinelemede karıştırılan 10 girişli bir tampon içerir. Bu nedenle, girişin daha önce 10 yere ve daha sonra sonsuz sayıda yere (ile geometrik bir dağılımın ardından p=1/10) yazdırılması mümkündür . Tampon yeterince uzun olduğunda, ilk eleman basılır ve vektörden çıkarılır.

Javascript, 78 bayt

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

Xnor'ın cevabıyla aynı yöntemi kullanır.

Perl 5 , 39 bayt

38 baytlık kod + -n bayrak.

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

Çevrimiçi deneyin!

Her elemanı @Fdiziye (ile push@F,$_) ekleyin . Tüm @F10 elemanları (ihtiva pushdizideki elementlerin sayısı ile döner, böylece 9<push...), rasgele elemanı çıkarılır ve (basılır splice@F,rand 10,1, öğe kaldırmak için printyazdırmak için).
Çıkış, 10. eleman okunduktan sonra gerçekleşmeye başlar. Bu nedenle, her bir eleman orijinalinden önce en az 9 pozisyonda görünmeye başlayabilir ve sonsuz sağa kaydırılabilir.

SmileBASIC, 61 58 bayt

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

Sonsuz listenin her karakteri, tamponun sonuna eklenir. Tampon uzunluğu 11 olduğunda, rastgele bir karakter basılır ve kaldırılır.

İşlev bir Rsonraki karakteri oluşturur.

Prolog, 70 bayt

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