Giới thiệu về bộ

Trước hết, bạn có thể coi điều này giống như bất kỳ thử thách chơi gôn mã nào khác, và trả lời nó mà không phải lo lắng về loạt bài này. Tuy nhiên, có một bảng xếp hạng trên tất cả các thách thức. Bạn có thể tìm thấy bảng xếp hạng cùng với một số thông tin khác về loạt bài trong bài đầu tiên .

Lỗ 8: Xáo trộn một danh sách vô hạn

Bạn nên viết một hàm hoặc chương trình lấy danh sách vô hạn làm đầu vào và trả về một phiên bản được xáo trộn của danh sách đó.

Về vô hạn I / O

Có một số cách bạn có thể lấy đầu vào và tạo đầu ra cho thử thách này:

• Bạn có thể lấy danh sách các số nguyên dương hoặc biểu diễn chuỗi hoặc chuỗi hoặc danh sách các ký tự ASCII có thể in (bao gồm 0x20 đến 0x7E). Định dạng đầu ra phải phù hợp với định dạng đầu vào. Từ giờ trở đi tôi sẽ chỉ xem dữ liệu là "danh sách", bất kể bạn chọn tùy chọn nào.
• Bạn có thể đọc danh sách từ luồng đầu vào tiêu chuẩn vô hạn và ghi đầu ra liên tục vào luồng đầu ra tiêu chuẩn vô hạn. Giải pháp không nên phụ thuộc vào bất kỳ giá trị cụ thể hoặc chuỗi giá trị nào để đảm bảo rằng luồng đầu ra được ghi và xóa thường xuyên (ví dụ: bạn không thể chỉ viết đầu ra bất cứ khi nào có5 trong danh sách đầu vào). Tất nhiên, nếu bạn đọc một đại diện chuỗi của danh sách, sẽ tốt cho đến khi gặp phải dấu phân cách danh sách.
• Trong các ngôn ngữ hỗ trợ chúng, bạn có thể viết một hàm lấy và trả về một danh sách hoặc chuỗi vô hạn lười biếng.
• Trong các ngôn ngữ hỗ trợ chúng, bạn có thể triển khai một trình tạo vô hạn lấy một trình tạo khác làm đầu vào.
• Ngoài ra, bạn có thể viết một hàm không có đối số và trả về một giá trị đầu ra mỗi lần nó được gọi. Trong trường hợp này, bạn có thể giả sử rằng một hàm đã được xác định không có đối số và trả về giá trị đầu vào tiếp theo mỗi lần nó được gọi. Bạn có thể tự do chọn tên của chức năng đó.

Bạn có thể cho rằng chương trình của bạn chạy mãi mãi và bộ nhớ vô hạn có sẵn. (Có thể giải quyết vấn đề này với một lượng bộ nhớ hữu hạn, nhưng điều này có nghĩa là bạn được phép rò rỉ bộ nhớ.)

Về sự ngẫu nhiên

Đối với bất kỳ giá trị v nào được đọc tại vị trí i của đầu vào vô hạn, phải có xác suất dương để nó kết thúc ở bất kỳ vị trí nào i-9 đến i + 9 của đầu ra vô hạn (trừ khi vị trí đó là âm ). Các xác suất này không phải giống nhau cho các vị trí đầu ra khác nhau hoặc thậm chí cho các vị trí đầu vào khác nhau. Thật tốt nếu giải pháp của bạn cũng có thể xáo trộn các giá trị sang vị trí khác ở xa hơn.

Do đó, không cần thiết rằng giải pháp của bạn có thể xáo trộn giá trị đầu tiên rất xa trong danh sách hoặc nó có thể xáo trộn một giá trị rất muộn lên đến vị trí đầu tiên, mặc dù nó vẫn ổn, miễn là tất cả các vị trí cách 9 bước đầu vào là có thể.

Ví dụ: nếu bạn lấy chuỗi sau làm đầu vào, thì ___chỉ ra tất cả các vị trí Xphải có thể kết thúc ở đầu ra:

                  ___________________
 abcdefghijklmnopqrstuvwxyzXabcdefghijklmnopqrstuvwxyz...

Nếu ngôn ngữ của bạn thiếu trình tạo số ngẫu nhiên tích hợp hoặc bạn không muốn sử dụng nó, bạn có thể lấy một giá trị hạt giống bổ sung làm đầu vào và triển khai RNG phù hợp của riêng bạn bằng cách sử dụng hạt giống. Trang này có thể hữu ích cho việc đó.

Bất kể phân phối thực tế mà giải pháp của bạn sử dụng là gì, nó gần như chắc chắn sẽ tạo ra giá trị tiếp theo sau một thời gian hữu hạn (nhưng tùy ý).

Vui lòng bao gồm một lời giải thích ngắn về cách thực hiện của bạn đáp ứng các yêu cầu này.

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

Bảng xếp hạng

Bài đầu tiên của loạt bài tạo ra một bảng thành tích.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu mọi câu trả lời bằng tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

(Ngôn ngữ hiện không được hiển thị, nhưng đoạn mã yêu cầu và phân tích nó và tôi có thể thêm bảng xếp hạng ngôn ngữ trong tương lai.)

Python 3 , 78 byte

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

Hãy thử trực tuyến!

Lấy đầu vào từ STDIN (một trên mỗi dòng), in ra STDOUT.

Giữ một bộ đệm l lên đến 10 yếu tố. Bộ đệm được xáo trộn với mỗi bước. Khi chiều dài của nó là 10, phần tử cuối cùng được in và xóa.

Nếu một phần tử tình cờ được in ngay sau khi nó được chèn, nó đã bỏ qua trước 9 phần tử khác đang chờ trong bộ đệm, vì vậy nó xuất hiện 9 điểm còn lại. Một phần tử có thể chờ trong bộ đệm dài tùy ý, vì vậy vị trí của nó có thể di chuyển bất kỳ số lượng nào đúng.

Dường như không có một cách hay để sản xuất và loại bỏ một yếu tố ngẫu nhiên khỏi danh sách. Xáo trộn có vẻ như quá mức cần thiết. Đó là 2 byte dài hơn để sử dụng l.pop(randint(0,9))(trong đó sử dụng danh sách có 10 phần tử).

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

Không có gì tốt hơn để làm x=choice(l);l.remove(x). Một ngôn ngữ poprandomnhư

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

rất có thể làm sạch

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

Befunge ( hương vị quirkster ), 4 byte

?,?~

,đọc một ký tự từ luồng và đẩy nó lên ngăn xếp. ~bật ký tự trên cùng từ ngăn xếp (nếu có) và in nó. ?chọn ngẫu nhiên lệnh nào được thực thi tiếp theo. Vì vậy, thuật toán ở đây là "Trong một vòng lặp vô hạn, với xác suất bằng nhau hoặc đẩy một ký tự hoặc bật một ký tự." Tôi nghĩ rằng điều này thỏa mãn các yêu cầu: một ký tự có thể thấy nhiều ký tự được thêm vào bên trên nó trong ngăn xếp, vì vậy nó có thể di chuyển xa tùy ý sang bên phải và nó có thể được in khi ngăn xếp lớn tùy ý, do đó nó có thể di chuyển xa tùy ý Bên trái.

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

Hãy thử trực tuyến!

Ok, một liên kết TIO không có nhiều ý nghĩa. Để dễ kiểm tra, tôi đã tạo chương trình C sau đây sẽ xuất các ký tự ascii ngẫu nhiên hoặc lặp lại một chuỗi vô tận.

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

Chương trình này sẽ được gọi là iro .

Chương trình chính xác

Những gì tôi làm ở đây là đọc 9các giá trị vào một bộ đệm. Sau này, các chỉ số ngẫu nhiên được chọn từ mảng này và được xuất ra, sau đó được thay thế bằng ký tự tiếp theo trong luồng.

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

Hãy thử trực tuyến!

Về cơ bản, nó tiếp tục lấy đầu vào (trên trình thông dịch trực tuyến thông qua các đối số, nhưng trên trình thông dịch chính thức ngoại tuyến, nó sẽ cho phép bạn nhập vào bảng điều khiển (vô hạn)) trong các khối 15 tại một thời điểm (30 khối đầu tiên).

Nó tải đầu vào vào một hàng đợi tạm thời và chọn 15 may mắn (ngẫu nhiên, nhưng không được phân phối đồng đều về mặt xác suất hoặc phân phối).

Phần còn lại vẫn ở trong khi các đầu vào mới lấp đầy hàng đợi, đầu vào đầu tiên có thể được xáo trộn cho đến hết, (về cơ bản tôi nghĩ rằng các ký tự tuân theo phân phối bình thường). Thật thú vị khi lưu ý rằng chương trình này chỉ dài gấp đôi so với trăn và có lẽ "golfier" hơn Java.

Để thấy rõ hơn kết quả, tôi có một phiên bản không tuân thủ, lấy đầu vào là một chuỗi (tuy nhiên, nó chỉ có thể có 8.000 ký tự hoặc hơn).

Hãy thử trực tuyến!

Để cho vui, đây là bài đăng này được cung cấp thông qua phiên bản chuỗi.

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

  = sẽ
   x = 1b 15 1
5b a * b = lbrd # + lb eaI O e 
 x
 ifquu   
1 0x b
   = =

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


 qe -lblX u0 m GOOue  
[rlT 

 tnn5! I.STii] [S.LO tức là

htpsgthyx]: iub.om/jhujh .. tcraa.IOo /TytonieSu:wl/.L lnn !: tt / iS
[Trong 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 iw
hs 0It te 
 lodshipo alauttt.mpra quuet i reanicks a lck eooy d Randomyn p 15 (uo Equl, unbtty drbutingaynistinems 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 '
 tte s / "gt 
obterelIe tsvea non-omhTs

[Tyauoas nó onine! Hrhrys :.ru] p // o / lsslo # jVd (tinnexi3E @ KDpit / LrhtwXwVEUuscxPmJjFFCaNimMzlHiQEcMmdVIT7vqs8mNgxU3mD / J1Aq / 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 / "lâm trường / iRAIL.O NqUXAm. T3zDreu) .STHERIOxs. "ddd

Aceto , 24 byte, không cạnh tranh

Không cạnh tranh vì tôi phải sửa một lỗi trong trình thông dịch.

^




OYpO
r^`!
?d0=   >

Có một dòng vô hạn và tạo ra chúng theo thứ tự ngẫu nhiên. Mọi yếu tố đều có cơ hội xảy ra tại bất kỳ điểm ngẫu nhiên nào.

Chúng tôi bắt đầu với một ?ở góc dưới bên trái, di chuyển chúng tôi theo một hướng ngẫu nhiên. Nếu đó là xuống hoặc trái, chúng tôi bị đẩy trở lại phải.

Nếu chúng ta di chuyển lên trên, chúng ta sẽ thấy rmột giá trị, xáo trộn ngăn xếp (Y ) và quay trở lại Origin.

Nếu chúng ta di chuyển sang phải, chúng ta sẽ dtăng giá trị ngăn xếp trên cùng, đẩy a 0và kiểm tra sự bằng nhau (vì chúng ta đang đọc các chuỗi, chúng ta không bao giờ có số nguyên 0). Nếu các giá trị bằng nhau, điều đó có nghĩa là chúng tôi đã chạm đến đáy của ngăn xếp (từ đó chúng tôi không muốn in). Chúng tôi phủ nhận so sánh ( !) và pchỉ rint nếu ( `) mọi thứ không bằng nhau. Sau đó, chúng tôi cũng nhảy trở lại Origin.

Ruby, 43 byte

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

Câu trả lời ban đầu của tôi đã sử dụng một danh sách vô hạn được đánh giá lười biếng, nhưng nó ngắn hơn. Ồ tốt

MATL , 11 byte

`rEkN*?D}iT

Hãy thử trực tuyến!

Cảng Befunge của câu trả lời .

Giải thích: (Cảm ơn Luis Mendo cho -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.

Kết quả này gần như chắc chắn trong thời gian hữu hạn và gần như chắc chắn chỉ cần bộ nhớ hữu hạn .

Để hoàn thiện, đây là phiên bản 15 byte giữ bộ đệm 10 phần tử và xuất ra một phần tử ngẫu nhiên từ đó:

`htnt9>?Yr&)wDT

Tôi thích phiên bản này vì rất thành ngữ (theo như ngôn ngữ chơi gôn có thể là thành ngữ) tn...Yr&), xuất hiện một yếu tố ngẫu nhiên từ danh sách và trả về danh sách mà không có yếu tố đó. Tuy nhiên, hậu cần cụ thể của thử thách này thêm rất nhiều byte (yêu cầu wcho màn hình hiển thị, t9>?để kiểm tra xem danh sách có đủ đầy không ...).

Alice , 7 byte

a&IdU,O

Hãy thử trực tuyến!

Điều này sẽ hoạt động trên một đầu vào vô hạn với thời gian và bộ nhớ vô hạn, nhưng thực tế không dễ để kiểm tra :)

Giải trình

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.

Ở mỗi lần lặp, 10 ký tự được đọc từ đầu vào và chỉ một ký tự đi đến đầu ra, do đó việc sử dụng bộ nhớ tăng tuyến tính trong khi thực hiện. Với đầu vào hữu hạn, điều này nhanh chóng đạt đến EOF, từ đó mười -1 sẽ được đẩy lên ngăn xếp ở mỗi lần lặp. Cố gắng xuất -1 dưới dạng ký tự không có tác dụng, nhưng không chắc là tất cả các ký tự của đầu vào sẽ được in trong một khoảng thời gian hợp lý.

Vị trí i của đầu ra có thể được lấy bởi bất kỳ ký tự nào trong đầu vào lên đến vị trí 10i , điều này phù hợp với thử thách yêu cầu ít nhất một phạm vi từ i-9 đến 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;}}

Làm thế nào nó hoạt động

Dùng thử trực tuyến (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ć,

Hãy thử trực tuyến! (sửa đổi để lấy 20 yếu tố)

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

Hãy thử trực tuyến!

xargs liên tục lấy 9 chữ cái từ STDIN và gửi chúng để xáo trộn

một danh sách vô hạn có thể được tạo bởi:

yes {a..z}

mà in abcde .. z lần vô hạn.

Kiểm tra có thể được thực hiện bởi:

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

Bắt đầu với một vector trống x. Trong một vòng lặp vô hạn, nó nhận một giá trị mới từ STDIN, sau đó xáo trộn vectơ. Sau đó, nó kiểm tra xem độ dài của danh sách dựng lên là 10 hoặc cao hơn. Nếu có, nó có thể bắt đầu in. Bằng cách này, vectơ có một bộ đệm gồm 10 đầu vào, mỗi đầu vào được xáo trộn trong mỗi lần lặp. Vì vậy, có thể đầu vào được in sớm hơn 10 vị trí và vô cùng nhiều vị trí sau (theo phân phối hình học với p=1/10). Khi bộ đệm đủ dài, phần tử đầu tiên được in và xóa khỏi vectơ.

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

Sử dụng phương pháp tương tự như câu trả lời của xnor.

Perl 5 , 39 byte

38 byte mã + -ncờ.

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

Hãy thử trực tuyến!

Thêm từng phần tử vào @Fmảng (với push@F,$_). Khi @Fchứa 10 phần tử ( pushtrả về số lượng phần tử trong mảng, do đó 9<push...), một phần tử ngẫu nhiên được xóa và in ( splice@F,rand 10,1để loại bỏ phần tử, printđể in nó).
Đầu ra bắt đầu xảy ra sau đó phần tử thứ 10 đã được đọc. Do đó, mỗi phần tử có thể bắt đầu xuất hiện ít nhất 9 vị trí trước vị trí ban đầu của nó và có thể được dịch chuyển sang bên phải vô hạn.

SmileBASIC, 61 58 byte

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

Mỗi ký tự của danh sách vô hạn được thêm vào cuối bộ đệm. Khi chiều dài bộ đệm là 11, một ký tự ngẫu nhiên được in và xóa.

Hàm Rtạo ký tự tiếp theo.

Prolog, 70 byte

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