关于系列

首先，您可以像对待其他任何代码高尔夫挑战赛一样对待它，并回答它而不必担心系列赛。但是，在所有挑战中都有排行榜。您可以在第一篇文章中找到排行榜以及有关该系列的更多信息。

漏洞8：随机播放一个无限列表

您应该编写一个函数或程序，该函数或程序将一个无限列表作为输入并返回该列表的改组版本。

关于无限I / O

您可以通过多种方法来输入和产生此挑战的输出：

• 您可以采用正整数列表或其字符串表示形式，也可以采用字符串或可打印ASCII字符列表（0x20至0x7E，包括0x20至0x7E）。输出格式必须与输入格式匹配。从现在开始，无论您选择哪个选项，我都将数据称为“列表”。
• 您可以从无限标准输入流中读取列表，并将输出连续写入无限标准输出流中。解决方案不应依赖任何特定值或值序列来确保输出流被定期写入和刷新（例如5，输入列表中只有a时，您不能仅写入输出）。当然，如果您读取列表的字符串表示形式，则可以等到遇到列表分隔符后再试。
• 在支持它们的语言中，您可以编写一个函数，该函数接受并返回一个惰性无限列表或字​​符串。
• 在支持它们的语言中，您可以实现一个无限生成器，该生成器将另一个生成器作为输入。
• 另外，您可以编写一个不带参数的函数，并在每次调用时返回一个输出值。在这种情况下，可以假定已定义一个不带任何参数的函数，并且每次调用时都返回下一个输入值。您可以自由选择该函数的名称。

您可能会假设您的程序可以永远运行并且可以使用无限内存。（可以通过有限的内存来解决此问题，但这意味着您可以泄漏内存。）

关于随机性

对于在无穷大输入的位置i上读取的任何值v，它必须有一个正概率使其最终在无穷大输出的位置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值读入缓冲区。此后，从该数组中选择随机索引并输出，然后由流中的下一个字符替换。

SILOS，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个）。

它将输入加载到临时队列中，并选择一个幸运的15（随机，但就概率或分布而言，分布不均）。

其余的保留在新输入填充队列中时，第一个输入可以一直拖到最后，（基本上我认为字符遵循正态分布）。有趣的是，该程序的详细程度仅是python的两倍，也许是Java的“更高”。

为了更好地查看结果，我有一个不兼容的版本，该版本将输入作为字符串（但是只能输入8,000个左右的字符）。

在线尝试！

只是为了好玩，这是通过字符串版本提供的这篇文章。

 [.L.Ooy“ 9beS.IS]，” 14 ts b1
 ly

  = ll
   x = 1b 15 1
5b a * b =磅rd＃+磅ea e O e 
 X
 Ifquu   
1 0x b
   =

    Ë
0
   我lblxa -d * 2
    x x = rn 
   x Xea p0
   pnInt ora
   mf = iePit
  11
   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“
 查看全部内容（e eToghr tetgpnmntuon eruEuut rhofi off，bhenecil inretea.atr ialoks tirilw upeitfleptly ty honso（e oote cenfine iwllbc 15 only）nitloo aim（te）nikfte3 firs bck）
hs 0It 
 Lodshipo alauttt.mpra quuet我再次接受了一个随机的15点（或者等号，不正确地删除或撤消了不良反应，请参见ibttmin.Tet ri）
 无人问津 
pte ftip，ae uldsfuesis ob hlelth weual tc hdyoend，fbabaly thi an elnkhecarcthe（sc ho noreiItrolwaaldibtio lmiru.t'iereaf）tsng tetntiottssht prasnon hogIms只有twieatisi s vroscpoladhan。
 tte s /“ gt 
禁止在多处使用tsvea，在rwvritcaw aa g（hoee n onl kein n00 orscat，0 cter）上使用tsutrics。

[Tyauoas itine！hrhrys ：。ru] p // o / lsslo＃jVd（tinnexi3E @ KDpit / LrhtwXwVEUuscxPmJjFFCaNimMzlHiQEcMmdVIT7vqs8mNgxU3mD / J1AwXQ / ivbao1j @ nb4I6 / m93655bThmb4cy5TUX3xvI018cZzrXItuO5B @ NX5JD / HzyE @ģ@ 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字节，无竞争

不竞争，因为我必须修复解释器中的错误。

^




OYpO
r^`!
?d0=   >

接受无限的线流并以随机顺序产生它们。每个元素都有可能在任意随机点发生。

我们从?左下角的a开始，它向随机方向移动。如果那是向下或向左，我们将被向右推。

如果我们向上移动，我们将获得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

在线尝试！

港histocrat的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，每次迭代将从中将10 -1推入堆栈。尝试将-1输出为字符没有任何效果，但是输入的所有字符不太可能在合理的时间内打印出来。

输出中的位置i可以由输入中的任何字符占据，直到位置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连续接收来自STDIN的9个字母并将其发送到shuffle

无限列表可以通过以下方式生成：

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]).