เกี่ยวกับซีรี่ส์

ก่อนอื่นคุณอาจปฏิบัติเช่นนี้กับการแข่งขันกอล์ฟอื่น ๆ และตอบคำถามโดยไม่ต้องกังวลกับซีรีย์เลย อย่างไรก็ตามมีลีดเดอร์บอร์ดสำหรับทุกความท้าทาย คุณสามารถค้นหาลีดเดอร์พร้อมกับข้อมูลบางอย่างเพิ่มเติมเกี่ยวกับซีรีส์ในโพสต์แรก

หลุม 8: สุ่มรายการที่ไม่มีที่สิ้นสุด

คุณควรเขียนฟังก์ชันหรือโปรแกรมที่รับรายการอนันต์เป็นอินพุตและส่งคืนเวอร์ชันแบบสับของรายการนั้น

เกี่ยวกับ I / O ไม่มีที่สิ้นสุด

มีหลายวิธีที่คุณสามารถรับอินพุตและสร้างเอาต์พุตสำหรับความท้าทายนี้:

• คุณสามารถเลือกรายการจำนวนเต็มบวกหรือการแทนสตริงดังกล่าวหรือสตริงหรือรายการอักขระ ASCII ที่พิมพ์ได้ (0x20 ถึง 0x7E, รวมไว้ด้วย) รูปแบบผลลัพธ์ต้องตรงกับรูปแบบอินพุต ฉันจะดูข้อมูลว่า "รายการ" ต่อจากนี้ไปไม่ว่าคุณจะเลือกตัวเลือกใด
• คุณสามารถอ่านรายการจากอินพุตมาตรฐานแบบไม่สิ้นสุดและเขียนเอาต์พุตอย่างต่อเนื่องไปยังเอาต์พุตมาตรฐานแบบไม่สิ้นสุด การแก้ปัญหาไม่ควรขึ้นอยู่กับค่าเฉพาะหรือลำดับของค่าใด ๆ เพื่อให้แน่ใจว่าเอาต์พุตสตรีมจะถูกเขียนและล้างข้อมูลอย่างสม่ำเสมอ (เช่นคุณไม่สามารถเขียนเอาต์พุตเมื่อใดก็ตามที่มี5ในรายการอินพุต) แน่นอนถ้าคุณอ่านการแทนค่าสตริงของรายการคุณจะต้องรอจนกว่าจะเจอตัวคั่นรายการ
• ในภาษาที่รองรับพวกเขาคุณสามารถเขียนฟังก์ชั่นที่รับและส่งคืนรายการหรือสตริงที่ไม่มีที่สิ้นสุดที่ขี้เกียจ
• ในภาษาที่สนับสนุนพวกเขาคุณอาจใช้เครื่องมือสร้างที่ไม่มีที่สิ้นสุดซึ่งใช้ตัวสร้างอื่นเป็นอินพุต
• หรือคุณสามารถเขียนฟังก์ชั่นที่ไม่มีข้อโต้แย้งและคืนค่าเอาต์พุตหนึ่งค่าในแต่ละครั้งที่เรียกใช้ ในกรณีนี้คุณสามารถสันนิษฐานได้ว่าฟังก์ชั่นได้รับการกำหนดซึ่งจะไม่มีข้อโต้แย้งและส่งกลับค่าการป้อนข้อมูลต่อไปในแต่ละครั้งที่มันถูกเรียก คุณสามารถเลือกชื่อของฟังก์ชันนั้นได้อย่างอิสระ

คุณอาจสมมติว่าโปรแกรมของคุณทำงานตลอดไปและมีหน่วยความจำที่ไม่มีที่สิ้นสุด (เป็นไปได้ที่จะแก้ปัญหานี้ด้วยจำนวนหน่วยความจำที่ จำกัด แต่สิ่งนี้หมายความว่าคุณได้รับอนุญาตให้หน่วยความจำรั่วไหล)

เกี่ยวกับการสุ่ม

สำหรับค่าใด ๆvที่อ่านที่ตำแหน่งiของอินพุตไม่สิ้นสุดจะต้องมีความเป็นไปได้ในเชิงบวกที่จะสิ้นสุดในตำแหน่งใด ๆi-9ถึงi +9ของเอาต์พุตแบบไม่ จำกัด (เว้นแต่ตำแหน่งนั้นจะเป็นค่าลบ ) ความน่าจะเป็นเหล่านี้ไม่จำเป็นต้องเหมือนกันสำหรับตำแหน่งเอาต์พุตที่ต่างกันหรือแม้แต่สำหรับตำแหน่งอินพุตที่ต่างกัน ไม่เป็นไรหากโซลูชันของคุณสามารถสับเปลี่ยนค่าไปยังตำแหน่งอื่นที่อยู่ไกลออกไปได้

ดังนั้นจึงไม่จำเป็นที่โซลูชันของคุณจะสามารถสับเปลี่ยนค่าแรกที่อยู่ไกลสุดในรายการได้หรืออาจสับเปลี่ยนค่าที่ช้ามากจนถึงตำแหน่งแรกแม้ว่าจะใช้ได้ดีก็ตามถ้าทำได้ตราบใดที่ตำแหน่งทั้งหมด 9 ขั้นจาก อินพุตเป็นไปได้

เช่นถ้าคุณใช้สตริงต่อไปนี้เป็นอินพุตการ___บ่งชี้ตำแหน่งทั้งหมดที่Xจะต้องสามารถสิ้นสุดในผลลัพธ์:

                  ___________________
 abcdefghijklmnopqrstuvwxyzXabcdefghijklmnopqrstuvwxyz...

หากภาษาของคุณไม่มีตัวสร้างตัวเลขสุ่มในตัวหรือคุณไม่ต้องการใช้มันคุณอาจใช้ค่าเมล็ดเพิ่มเติมเป็นอินพุตและใช้RNG ที่เหมาะสมของคุณเองโดยใช้เมล็ด หน้านี้อาจมีประโยชน์สำหรับสิ่งนั้น

โดยไม่คำนึงถึงการกระจายจริงใช้วิธีการแก้ปัญหาของคุณจะต้องเกือบแน่นอนผลิตค่าถัดไปหลังจากที่มีการ จำกัด ( แต่พล) เวลา

โปรดระบุคำอธิบายสั้น ๆ เกี่ยวกับวิธีการนำไปใช้ของคุณเป็นไปตามข้อกำหนดเหล่านี้

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดที่ถูกต้อง - วัดเป็นไบต์ - ชนะ

ลีดเดอร์บอร์ด

โพสต์แรกของซีรีส์สร้างกระดานผู้นำ

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มต้นทุกคำตอบด้วยบรรทัดแรกโดยใช้เทมเพลต Markdown ต่อไปนี้:

# Language Name, N bytes

ที่Nมีขนาดของส่งของคุณ หากคุณปรับปรุงคะแนนของคุณคุณสามารถเก็บคะแนนเก่าไว้ในพาดหัวโดยการตีพวกเขาผ่าน ตัวอย่างเช่น

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

(ภาษาไม่ปรากฏในปัจจุบัน แต่ตัวอย่างข้อมูลต้องการและแยกวิเคราะห์และฉันอาจเพิ่มกระดานผู้นำแบบแยกภาษาในอนาคต)

Python 3 , 78 ไบต์

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

ลองออนไลน์!

ใช้อินพุตจาก STDIN (หนึ่งต่อบรรทัด) พิมพ์ไปที่ STDOUT

เก็บบัฟเฟอร์lได้มากถึง 10 องค์ประกอบ บัฟเฟอร์ถูกสับในแต่ละขั้นตอน เมื่อความยาวของมันคือ 10 องค์ประกอบสุดท้ายจะถูกพิมพ์และลบออก

หากองค์ประกอบเกิดขึ้นที่จะพิมพ์ทันทีที่ใส่เข้าไปองค์ประกอบนั้นจะข้ามไปก่อน 9 องค์ประกอบอื่น ๆ ที่รออยู่ในบัฟเฟอร์ดังนั้นจะปรากฏจุดที่เหลือ 9 จุด องค์ประกอบที่สามารถรอในบัฟเฟอร์ยาวโดยพลการดังนั้นตำแหน่งของมันสามารถย้ายจำนวนใด ๆ ที่เหมาะสม

ดูเหมือนจะไม่มีวิธีที่ดีในการผลิตและลบองค์ประกอบแบบสุ่มออกจากรายการ การสับดูเหมือนว่ามากไป ใช้นานกว่า 2 ไบต์l.pop(randint(0,9))(ซึ่งใช้รายการนั้นมีองค์ประกอบ 10 รายการ)

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

มันไม่ดีกว่าที่จะทำx=choice(l);l.remove(x). ภาษากับpoprandomชอบ

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

สามารถทำได้อย่างสะอาดหมดจด

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

Befunge ( รสแปลก ๆ ), 4 ไบต์

?,?~

,อ่านตัวละครจากกระแสและผลักมันลงบนสแต็ก ~ดึงอักขระบนสุดออกจากสแต็ก (ถ้ามี) และพิมพ์ออกมา ?สุ่มคำสั่งที่จะดำเนินการต่อไป ดังนั้นอัลกอริทึมที่นี่คือ "ในวงที่ไม่มีที่สิ้นสุดด้วยความน่าจะเป็นที่เท่ากันไม่ว่าจะเป็นการผลักตัวละครหรือป๊อปตัวละคร" ฉันคิดว่านี่เป็นไปตามข้อกำหนด: ตัวละครสามารถเห็นตัวละครจำนวนมากที่เพิ่มเข้ามาในสแต็คเพื่อให้มันสามารถย้ายไปทางขวาไปทางขวาโดยพลการและสามารถพิมพ์ได้เมื่อสแต็คมีขนาดใหญ่ตามอำเภอใจ ทางซ้าย.

C (gcc) , 94 ไบต์

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

ลองออนไลน์!

ตกลงลิงค์ TIO ไม่สมเหตุสมผล เพื่อความสะดวกในการทดสอบฉันสร้างโปรแกรม C ต่อไปนี้ที่จะแสดงผลตัวอักษร ASCII แบบสุ่มหรือทำซ้ำสตริงแบบไม่สิ้นสุด

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

iroโปรแกรมนี้จะถูกเรียกว่า

ความถูกต้องของโปรแกรม

สิ่งที่ฉันทำที่นี่คืออ่าน9ค่าลงในบัฟเฟอร์ หลังจากนี้ดัชนีสุ่มจะถูกเลือกจากอาร์เรย์นี้และถูกเอาท์พุทแล้วแทนที่ด้วยอักขระถัดไปในสตรีม

ไซโล , 149 ไบต์

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

ลองออนไลน์!

(บนล่ามออนไลน์ผ่านการขัดแย้ง แต่ในล่ามออฟไลน์อย่างเป็นทางการจะช่วยให้คุณพิมพ์ลงในคอนโซล (ไม่ จำกัด )) ในบล็อก 15 ครั้ง (30 บล็อกแรก)

มันโหลดอินพุตลงในคิวชั่วคราวและเลือก lucky 15 (สุ่ม แต่ไม่กระจายเท่ากันในแง่ของความน่าจะเป็นหรือการกระจาย)

ส่วนที่เหลือยังคงอยู่ในขณะที่อินพุตใหม่เติมคิวการป้อนข้อมูลครั้งแรกสามารถสับไปจนจบ (โดยพื้นฐานแล้วฉันคิดว่าตัวละครตามการแจกแจงแบบปกติ) เป็นที่น่าสนใจที่จะทราบว่าโปรแกรมนี้เป็นเพียงสองเท่า verbose เป็นงูหลามและบางที "golfier" กว่า Java

เพื่อดูผลลัพธ์ให้ดีขึ้นฉันมีเวอร์ชันที่ไม่เข้ากันซึ่งรับอินพุตเป็นสตริง (อย่างไรก็ตามสามารถใช้อักขระได้เพียง 8,000 ตัวเท่านั้น)

ลองออนไลน์!

เพียงเพื่อความสนุกนี่คือการโพสต์นี้ถูกป้อนผ่านเวอร์ชันสตริง

 [.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
   =

    อี
0
   ฉัน lblxa -d * 2
    quu x = rn 
   x Xea p0
   pnInt ora
   mf = iePit
  บริติชแอร์เวย์ 1
   GTO 1 fb x + Oa


 qe -lblX u0 m GOOue  
[RLT 

 tnn5! I.STii] [S.LO คือ

htpsgthyx]: iub.om/jhujh .. tcraa.IOo /TytonieSu:wl/.L lnn!: tt / iS
[ใน hsto.un / nuslprxRUCoDsio /]: e#NzZn6j4c/2xNQFnF7y0aLzkrosd9Dov2yxJNx774HBrgPUdi9CySI09sCLw5TJwB7jlB1XVeQFE7m1VMsIQvDOjBmdtME3umNzYXs9unFbqRamVDfUDw@RT3NHoL7/i04bz16DCoP4eulOU7jPD8OmYjATpynkuMDuBPYmtnIJzseyyhaNkMyQgXG2R782vqMDIiUm6Kq4Q3mJkxlUsR1rrldPw./l28Z SL.XS - IONuscOT "
senallyxMz.stiitkp ingN "
 eestaint on heeInliinrprt (oe toghr tetgpnmntuon eruEuut rh ofi), bhenecil inretea.atr ialoks tirilw upeitfleptly ty honso (e oote cenfine iwllbb 15 atly nitloo b)
hs 0 มันเป็นเรื่องจริง 
 lodshipo alauttt.mpra quuet i reanicks a lck eooy d randomyn p 15 (uo equl, unbtty drbutedaynistinems oftrly ordisrprob ป่วย abition h ibttmin.Tet ri)
 ไม่ทราบว่าคุณจะอยู่ที่ไหน 
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 hogIms
 tte s / "gt 
obterelIe tsvea ไม่ใช่ omhTrehs a plntvesion hcahihk ine teuts sriprics ที่ rwvritcaw aa g (ho'n onl kein n00 orscat, 0 cter)

[Tyauoas มัน 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 / ใน / 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 ไบต์, ไม่ใช่การแข่งขัน

ไม่ใช่การแข่งขันเพราะฉันต้องแก้ไขข้อบกพร่องในล่าม

^




OYpO
r^`!
?d0=   >

รับกระแสที่ไม่มีที่สิ้นสุดของเส้นและให้ผลในลำดับสุ่ม ทุกองค์ประกอบมีโอกาสเกิดขึ้นที่จุดสุ่มใด ๆ

เราเริ่มต้นด้วยการ?ที่มุมล่างซ้ายซึ่งย้ายเราไปในทิศทางที่สุ่ม ถ้ามันลงหรือซ้ายเราจะถูกผลักกลับทันที

หากเราเลื่อนขึ้นไปเราจะrใส่ค่าสับเปลี่ยนกอง ( Y) และกระโดดกลับไปที่ต้นOกำเนิด

หากเราย้ายไปทางขวาเราจะdอัปเดตค่าสแต็กด้านบนกด a 0และทดสอบความเท่าเทียมกัน (เนื่องจากเรากำลังอ่านสตริงเราจึงไม่มีจำนวนเต็ม 0) หากค่าเท่ากันนั่นหมายความว่าเราได้มาถึงด้านล่างของสแต็ก (ซึ่งเราไม่ต้องการพิมพ์) เราคัดค้านการเปรียบเทียบ ( !) และใช้pเฉพาะในกรณีที่ ( `) สิ่งต่าง ๆ ไม่เท่ากัน จากนั้นเราก็กระโดดกลับไปที่ต้นOกำเนิด

Ruby, 43 ไบต์

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

คำตอบเดิมของฉันใช้รายการอนันต์ที่ประเมินโดยคนขี้เกียจ แต่นี่สั้นกว่า โอ้ดี

MATL 11 ไบต์

`rEkN*?D}iT

ลองออนไลน์!

พอร์ตของ คำตอบ Befungeฮิสโตแคต

คำอธิบาย: (ขอบคุณ Luis Mendo สำหรับ -1 ไบต์)

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

ผลลัพธ์นี้เกือบจะแน่นอนในเวลาที่ จำกัด และ เกือบจะแน่นอนต้องใช้หน่วยความจำที่ จำกัด เท่านั้น

เพื่อความสมบูรณ์นี่คือเวอร์ชัน 15 ไบต์ซึ่งเก็บบัฟเฟอร์ 10 องค์ประกอบและส่งออกองค์ประกอบสุ่มจาก:

`htnt9>?Yr&)wDT

ฉันชอบรุ่นนี้สำหรับสำนวนที่มาก (เท่าที่ภาษากอล์ฟสามารถเป็นสำนวน) tn...Yr&)ซึ่งปรากฏองค์ประกอบสุ่มจากรายการและส่งกลับรายการโดยไม่มีองค์ประกอบนั้น อย่างไรก็ตามโลจิสติกเฉพาะของความท้าทายนี้เพิ่มจำนวนมากไบต์ (จำเป็นwสำหรับการแสดงผล, t9>?เพื่อตรวจสอบว่ารายการเต็ม ... )

อลิซขนาด 7 ไบต์

a&IdU,O

ลองออนไลน์!

สิ่งนี้ควรทำงานกับอินพุตที่ไม่มีที่สิ้นสุดด้วยเวลาและหน่วยความจำที่ไม่มีที่สิ้นสุด แต่มันไม่ง่ายเลยที่จะทดสอบในทางปฏิบัติ :)

คำอธิบาย

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.

ในแต่ละการวนซ้ำ 10 ตัวถูกอ่านจากอินพุตและมีเพียงหนึ่งไปที่เอาต์พุตดังนั้นการใช้หน่วยความจำเพิ่มขึ้นเป็นเส้นตรงระหว่างการดำเนินการ ด้วยอินพุต จำกัด นี่จะมาถึง EOF อย่างรวดเร็วจากนั้นจะผลักสิบไปที่สแต็กในแต่ละการวนซ้ำ การพยายามเอาท์พุท -1 ในฐานะตัวละครไม่มีผลกระทบ แต่เป็นไปได้ยากที่ตัวละครทั้งหมดของอินพุตจะถูกพิมพ์ในเวลาที่เหมาะสม

ตำแหน่งผมของการส่งออกสามารถนำมาโดยตัวอักษรใด ๆ ในการป้อนข้อมูลขึ้นไปยังตำแหน่ง10i , สอดคล้องกับความท้าทายนี้ที่ต้องการอย่างน้อยช่วงจากI-9จะi + 9

C, 214 ไบต์

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

มันทำงานอย่างไร

ลองออนไลน์ (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 ไบต์

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

ลองออนไลน์! (แก้ไขเพื่อใช้ 20 องค์ประกอบ)

[             # 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 ไบต์

xargs -n9 shuf -e

ลองออนไลน์!

xargs ใช้ตัวอักษร 9 ตัวจาก STDIN อย่างต่อเนื่องและส่งไปสับเปลี่ยน

รายการที่ไม่มีที่สิ้นสุดสามารถสร้างได้โดย:

yes {a..z}

ซึ่งพิมพ์ abcde .. z ครั้งอนันต์

การทดสอบสามารถทำได้โดย:

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

R, 70 ไบต์

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

xเริ่มต้นด้วยเวกเตอร์ที่ว่างเปล่า ในลูปแบบไม่สิ้นสุดจะใช้ค่าใหม่จาก STDIN จากนั้นจึงสลับเวกเตอร์ จากนั้นจะตรวจสอบว่าความยาวของรายการที่สร้างขึ้นมีค่า 10 หรือสูงกว่า หากเป็นเช่นนั้นจะสามารถเริ่มพิมพ์ได้ วิธีนี้เวกเตอร์มีบัฟเฟอร์ 10 อินพุตแต่ละอันจะถูกสับในทุกการวนซ้ำ ดังนั้นจึงเป็นไปได้สำหรับการป้อนข้อมูลที่จะพิมพ์ 10 ตำแหน่งก่อนหน้านี้และมากมายหลายสถานที่ในภายหลัง (ต่อไปนี้การกระจายเรขาคณิตด้วยp=1/10) เมื่อบัฟเฟอร์มีความยาวเพียงพอองค์ประกอบแรกจะถูกพิมพ์และลบออกจากเวกเตอร์

Javascript, 78 ไบต์

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

ใช้วิธีการเดียวกันกับคำตอบของ xnor

Perl 5 , 39 ไบต์

รหัส 38 ไบต์ + -nธง

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

ลองออนไลน์!

เพิ่มแต่ละองค์ประกอบให้กับ@Fอาร์เรย์ (พร้อมpush@F,$_) เมื่อ@Fมี 10 องค์ประกอบ ( pushส่งคืนจำนวนองค์ประกอบในอาร์เรย์ดังนั้น9<push...) องค์ประกอบสุ่มจะถูกลบและพิมพ์ ( splice@F,rand 10,1เพื่อลบองค์ประกอบprintเพื่อพิมพ์)
เอาต์พุตเริ่มต้นขึ้นหลังจากอ่านอิลิเมนต์ที่ 10 แล้ว ดังนั้นแต่ละองค์ประกอบสามารถเริ่มปรากฏอย่างน้อย 9 ตำแหน่งก่อนหน้าองค์ประกอบดั้งเดิมและสามารถเลื่อนไปทางขวาได้อย่างไม่สิ้นสุด

SmileBASIC, 61 58 ไบต์

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

อักขระแต่ละตัวของรายการไม่มีที่สิ้นสุดถูกเพิ่มไปยังจุดสิ้นสุดของบัฟเฟอร์ เมื่อความยาวของบัฟเฟอร์เท่ากับ 11 จะมีการพิมพ์และลบอักขระแบบสุ่ม

ฟังก์ชั่นRสร้างตัวละครต่อไป

Prolog, 70 ไบต์

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