给定输入字符串S，S按以下方式打印，后跟非空分隔符：

• 步骤1：S有1/2机会被打印，并且有1/2程序终止的机会。

• 步骤2：S有2/3机会被打印，并且有1/3程序终止的机会。

• 步骤3：S有3/4机会被打印，并且有1/4程序终止的机会。

• …

• 步骤n：S有n/(n+1)机会被打印，并且有1/(n+1)程序终止的机会。

笔记

• 输入字符串仅包含您语言的字符串类型可接受的字符。

• 可以使用任何非空分隔符，只要它始终相同即可。预期S在程序终止前的最后一次打印之后将打印分隔符。

• 该程序有1/2机会在打印任何内容之前终止。

• 尾随新行是可以接受的。

• 您的答案必须真正地尝试遵守所述的概率。显然，当n大时，这将越来越不正确。正确解释您的答案中的概率是如何计算的（以及为什么它们尊重规范，而忽略伪随机和大数问题）就足够了。

计分

这是代码高尔夫球，因此最短的答案以字节为单位。

Pyth，7个字节

WOh=hZQ

在线尝试！

这个怎么运作

伪代码：

while rand_int_below(1 + (Z += 1)):
    print(input)

C＃，94 85字节

我的第一个答案！

using System;s=>{var r=new Random();for(var i=2;r.Next(i++)>0;)Console.Write(s+" ");}

上一次尝试（我喜欢goto）：

using System;s=>{var i=2;var r=new Random();a:if(r.Next(i++)>0){Console.Write(s+" ");goto a;}}

取消高尔夫：

using System;
class P
{
    static void Main()
    {
        Action<string> f = s =>
        {
            var r = new Random();
            for (var i = 2; r.Next(i++) > 0;) Console.Write(s + " ");
        };

        f("test");

        Console.ReadKey();
    }
}

注意：在C＃中，该Random.Next(N)方法返回[0，N-1]范围内的非负整数，因此我们只需检查返回的数字是否大于0。

R，47 46 43字节

由于注释中的Robin Ryder占用43个字节。

s=scan(,"")
while(sample(T<-T+1)-1)print(s)

在线尝试！

说明

s=scan(,"")  # Takes input from stdin.
             T<-T+1    # T is 1 by default, so this
                       # evaluates to 2, and will increment
                       # at each step.
      sample(T<-T+1)   # Take a sample of size 2, i.e. generate
                       # a list of integers from 1 to 2 in random order
      sample(T<-T+1)-1 # Subtract one from every element of this list.
while(sample(T<-T+1)-1)# while() will treat the first value in this list
                       # as a logical value, i.e. FALSE for zero and TRUE
                       # for nonzero values. The other elements of the list
                       # are ignored, triggering a warning.
                       print(s) # print s

05AB1E，8个字节

[NÌL.R#,

在线尝试！

说明

[         # start loop
 NÌL      # push range [1 ... current_iteration+2]
    .R    # pick a random number
      #   # if true (1), exit loop
       ,  # print input

Javascript，60 58 54字节

f=(s,n=1)=>Math.random()<n/++n?console.log(s)+f(s,n):0

将输出字符串s。如果程序终止，则打印的分隔符为NaN或0。

f=(s,n=1)=>Math.random()<n/++n?console.log(s)+f(s,n):0

f('test')

Math.random()返回介于0和1之间的值。如果该值小于n/(n+1)，s则将被打印。

@Neil节省了4个字节

Java 8，72 62 61字节

s->{for(int n=2;Math.random()<1f/n++;System.out.println(s));}

-10个字节，感谢@cliffroot。
-1个字节感谢@JollyJoker。

定界符是换行符。

说明：

在这里尝试。

s->{                          // Method with String parameter and no return-type
  for(                        //  Loop
    int n=2;                  //   Start `n` on 2
    Math.random()<1f/n++;     //   Continue loop as long as a random decimal (0.0-1.0)
                              //   is smaller than 1/`n` (and increase `n` by 1 afterwards)
    System.out.println(s)     //   Print the input-String
  );                          //  End of loop
}                             // End of method

Mathematica，43个字节

(n=1;While[RandomInteger@n>0,Print@#;n++])&

郑焕敏保存了1个字节（上方）并提出了更好的建议（下方）

Mathematica，37个字节

For[n=1,RandomInteger@n++>0,Print@#]&

Clojure，61 56字节

哦，为什么我不首先使用a for？但是实际上必须doseq像for懒惰的评价那样使用学究的方法。

#(doseq[n(range):while(>(rand-int(+ n 2))0)](println %))

原版的：

#(loop[n 2](if(>(rand-int n)0)(do(println %)(recur(inc n)))))

> <>，124112字节

i:0( ?v
 &5a ~/
&p0[^ >"\_\^x0!>"0&1+:&p1&:&p2&:&p3&:&p4&:&p0&1+:&p3&:&p4&:
=?v[/!}l]:?!;1
{:   ?^  >
:o>_ {:?!^

在线尝试！（您也可以在鱼操场上观看它，但是由于某些错误，您必须在第四行的}后面添加a ，并l在代码后添加一堆新行以使其正常运行。）

> <>中的随机性是棘手的。唯一的随机指令是x，它从四个选择（左，右，上和下）中随机选择鱼的方向，因此将其变成概率为1 / n的东西并不容易。

该代码的实现方式是使用> <>的自我修改功能在该代码下方构建一个随机塔，因此，例如在第四阶段，该代码如下所示：

i:0( ?v
 &5a ~/
&p0[^ >"\_\^x0!>"0&1+:&p1&:&p2&:&p3&:&p4&:&p0&1+:&p3&:&p4&:
=?v[/!}l]:?!;1
{:   ?^  >
:o>_ {:?!^
>!0x^
\  _\
>!0x^
\  _\
>!0x^
\  _\
>!0x^
\  _\

鱼从塔的底部开始。在塔的每一层，x鱼被困在两个镜子之间，所以鱼只能向左或向右走才能逃脱。这两个方向中的任何一个都将鱼送至塔的下一层，但向左走也将把鱼推0到栈中。到鱼到达塔顶时，烟囱中包含一定数量的0s，并且该数量遵循二项式分布，其中n次试验且p  = 1/2。

如果堆栈的长度为0（概率为1/2 ⁿ），程序将停止。如果长度为1（概率为n / 2 ⁿ），则鱼将打印输入内容和换行符，并建造塔的另一层。如果长度不一样，鱼将丢弃烟囱并返回塔的底部。实际上，在实际执行某项操作的可能性中，其中n种会打印输入字符串，而其中一种会中止程序，并给出所需的概率。

Python 3中，72个 69 66字节

• 感谢Jonathan Allan节省了3个字节：导入简写并从2开始计数。
• 由于L3viathan节省了3个字节：指向的randint（）包含在内，并且在有条件时也缩短了。

from random import*
s=input();i=1
while randint(0,i):print(s);i+=1

在线尝试！

QBIC，19 17字节

删除=1，切换条件，保存2个字节

{p=p+1~_rp||?;\_X

说明

{       Infinitely DO
p=p+1   Add 1 to p (p starts as 0, so on first loop is set to 1, then 2 etc...)
~       IF
  _rp|| a random number between 0 and p
        (implicitly: is anything but 0)
?;      THEN print A$ (which gets read from the cmd line)
\_X     ELSE QUIT
        END IF and LOOP are auto-added at EOF

Braingolf，23个字节

#|V12[R!&@v!r?<1+>1+]|;

在线尝试！

生成随机数x，其中0 <= x < n+1，如果x为0则终止，否则递增n并循环。分隔符为|

说明：

#|V12[R!&@v!r?<1+>1+]|;  Implicit input of commandline args to stack
#|                       Push |
  V                      Create stack2 and switch to it
   12                    Push 1, then 2
     [..............]    Do-While loop, will run indefinitely unless conditional skips
                         Closing bracket
      R                  Return to stack1
       !&@               Print entire stack without popping
          v              Switch to stack2
           !r            Generate random number 0 <= x < n where n is last item on stack
             ?           If last item is greater than 0..
              <          ..Move first item to end of stack
               1+        ..and increment, this is the loop counter number
                 >       ..Move back
                  1+     ..and increment, this is the upper range of the RNG
                    ]    ..end loop
                     |   Endif
                      ;  Suppress implicit output

爱丽丝，18字节

/?!\v
\iO/>]qhUn$@

在线尝试！

说明

/     Reflect to SE. Switch to Ordinal.
i     Read all input as a string and push it to the stack.
!     Store the string on the tape.
/     Reflect to E. Switch to Cardinal.
>     Ensure that the IP moves east. This begins the main loop.

  ]   Move the tape head to the right. We'll be using the tape head's 
      position as a counter variable. Note that this tape head is independent
      of the one used in Ordinal mode to point at the input string.
  q   Push the tape head's position to the stack.
  h   Increment it (so that it's 2 initially).
  U   Get a uniformly random number in [0,n).
  n   Logical NOT. Gives 1 with probability 1/n and 0 otherwise.
  $@  Terminate the program if we got a  1.
  \   Reflect to NE. Switch to Ordinal.
  ?   Retrieve the input from the tape.
  O   Print it with a trailing linefeed.
  \   Reflect to E. Switch to Cardinal.

v     Send the IP south where it runs into the > to start the next
      loop iteration.

PHP，31字节

for(;rand()%~++$c;)echo$argn._;

在线尝试！

Perl，26个字节

24个字节的代码+ 2个-nl。

print while rand++$i+1|0

在线尝试！

木炭，14字节

Ａ²γＷ‽γ«θ_Ａ⁺γ¹γ

在线尝试！链接是详细版本的代码。使用_作为分隔符。注意：输出缓存已禁用，因此请不要锤打丹尼斯的服务器！

MATL，9个字节

`G@QYrq]x

在线尝试！

说明

`        % Do...while
  G      %   Push input
  @      %   Push iteration index k, starting at 1
  QYrq   %   Random integer uniformly distributed in {0, 1, ..., k}. This is the
         %   loop condition. If non-zero (which occurs with probability k/(1+k))
         %   proceed with next iteration; else exit loop
]        % End
x        % Delete, as there are one too many strings. Implicitly display the stack

Perl 6的， 50 41 38 36  26个字节

{put $_//last for (($,$_),*⊎$_...*).map(*.pick)}

试试吧

{eager ->{(++$).rand>.5??.put!!last}...*}

试试吧

{eager ->{(++$).rand>.5??.put!!0}...0}

试试吧

{eager ->{(++$).rand>.5&&.put}...!*}

试试吧

.put while (++$/).rand>.5

（带有-n命令行参数）

试试吧

Python 3，55个字节

v=s=input();i=2
while hash(v)%i:print(s);i+=1;v=hash(v)

说明

为了节省必须导入的随机性，我利用了以下事实：每次启动python进程时（至少在MacOS中），都会随机植入内置的哈希值。最后一个哈希的每个哈希应生成一系列伪随机整数。

如果哈希是足够的伪随机，则的模i与概率为零1/i。

笔记

我对冗余哈希感到有些困扰，但是在Python中没有做一次做或有条件分配的工作，我有些困惑。

C＃

这与顶部C＃答案的长度相同，但是：

using System;s=>{var x=(1<<31)/new Random().Next();for(;++x>0;)Console.Write(s+" ");}

只是想指出一些数学可以产生正确的概率。

int.MaxValue/new Random().Next()-1

相当于

(int)(1 / new Random().NextDouble()) - 1;

函数f（x）= 1 / x-1为：

f（1）= 0

f（1/2）= 1

f（1/3）= 2

f（1/4）= 3

因此，有1/2的机会被四舍五入为0，1 / 6的机会被四舍五入为1，而1 /（n + 1）（n + 2）的机会被四舍五入为n。

也许其他一些语言可以利用这一点。

编辑：修正了我的错误

我想到了一些使其缩小的方法。

编辑：我只是种种错误。将Random退出循环，因为如果对其进行多次评估，它将无法正常工作。

编辑编辑：我摆脱了变量我。我将停止尝试缩小它。不，撒谎。摆脱了另一个字节。

木炭，17字节

ＳαＡ²βＷ‽β«⁺α¶Ａ⁺β¹β

在线尝试！包含详细代码。尊重规格，因为它使用的是从0到的随机范围n。

C，41个字节

n;f(char*s){for(n=1;rand()%++n;puts(s));}

假设rand是种子。在线尝试！

脑力激荡，22字节

编辑：相同的字节数，但我意识到我可以潜入新的磁带L模仿功能。

,[>,]>L+[+$rzQ>[.>]:>]

用途0作为分隔符。像这样工作：

,[>,]                   Read a byte and move to next cell until end of input.
     >                  After the loop we're in an empty cell;
                          Leave it empty and move to the next.
      L                 Set tape limit here:
                          The tape will then wrap around if we move further.
       +                Increase current cell by one.
                          This cell will be our counter.
        [            ]  Loop until the counter is zero.
                          That won't happen, so it's an infinite loop.
         +              Increase again, so the first time the counter is 2.
          $r            Get a random number, 0 <= r > current cell
            zQ          Quit the program if that random number was 0
              >         Wrap around to the start of the tape.
               [.>]     Print the input stored on the tape
                          The loop will stop at the blank cell.
                   :    Print the blank cell as a number ("0")
                    >   Go to the next (last) cell

Python，54个字节

lambda s:int(1/random()-1)*(s+'|')
from random import*

在线尝试！

生成副本的数量作为floor(1/p)-1与p从该单元间隔均匀地选择。副本的数目是n在1/p-1介于n和n+1，时发生1/(n+2) < p < 1/(n+1)。这种情况的发生概率为1/(n+1)-1/(n+2)或1/((n+1)*(n+2)。这是输出n副本的期望概率：1/2概率为0，1/6概率为1，1/12概率为2，...

C ++，97 96 57字节

这是我第一次尝试codegolf :)

#include<iostream>
int main(){std::string S;std::cin>>S;int i=1;while(rand()%++i)puts(S.data());}

我通过使用保存了一个字节 for

#include<iostream>
int main(){std::string S;std::cin>>S;for(int i=1;rand()%++i;)puts(S.data());}

保存了39个字节，因为似乎没有人计算包含

void p(string S){for(int i=1;rand()%++i;)puts(S.data());}

不打高尔夫球

#include <iostream>
int main()
{
  // Create and read string from inputstream
  std::string S;
  std::cin >> S;       

  // rand % i: create random int in range [0, i-1]
  // Zero is seen as false and all positive int as true
  int i = 1;
  while (rand() % ++i) 
    puts(S.data());    
}

F＃，161个字节

绝对不是最好的高尔夫语言，但我决定尝试一下（此外，我对F＃一无所知，因此欢迎提供任何有关改善我的答案的技巧）。

let f s=
 let r,z=System.Random(),(<>)0
 let p _=printfn"%s"s
 seq {for i in 2|>Seq.unfold(fun i->Some(i,i+1))do yield r.Next(i)}|>Seq.takeWhile z|>Seq.iter p

执行：

[<EntryPoint>]
let main argv =
    "test" |> f
    0

写入新行作为分隔符。

红宝石，29 + 1 = 30字节

使用-n标志。

i=1;puts$_ while i>rand(i+=1)

在线尝试！

JS（ES6），47个字节

x=>{for(i=1;Math.random()<i/(i+1);i++)alert(x)}

与其他ES6答案不同，它使用for循环和警报炸弹代替递归。程序停止时打印的分隔符未定义。

PowerShell，31个字节

for($i=2;random($i++)){"$args"}

Get-Random $i输出nwhere 0 <= n < $i，分隔符是隐式换行符。

Python，75个字节

另一个Python答案要短一些，但我想尝试另一种方法：

from random import*
f=lambda d=1,s=input():randint(0,d)and s+'!'+f(d+1)or''