Đưa ra một chuỗi đầu vào S, in Stheo sau là dấu phân cách không trống theo cách sau:

• Bước 1: Scó 1/2cơ hội được in và 1/2cơ hội để chương trình chấm dứt.

• Bước 2: Scó 2/3cơ hội được in và 1/3cơ hội để chương trình chấm dứt.

• Bước 3: Scó 3/4cơ hội được in và 1/4cơ hội để chương trình chấm dứt.

• Giáo dục

• Bước n: Scó n/(n+1)cơ hội được in, và 1/(n+1)cơ hội để chương trình chấm dứt.

Ghi chú

• Chuỗi đầu vào sẽ chỉ bao gồm các ký tự được chấp nhận trong loại chuỗi ngôn ngữ của bạn.

• Bất kỳ dấu tách không trống nào cũng có thể được sử dụng, miễn là nó luôn giống nhau. Dự kiến ​​thiết bị phân tách được in sau lần in cuối cùng Strước khi chương trình kết thúc.

• Chương trình có 1/2cơ hội chấm dứt trước khi in bất cứ điều gì.

• Một dòng mới được chấp nhận.

• Câu trả lời của bạn phải thực hiện một nỗ lực đích thực trong việc tôn trọng các xác suất được mô tả. Rõ ràng, khi nlớn thì điều này sẽ ngày càng ít đúng. Một lời giải thích phù hợp về cách xác suất được tính toán trong câu trả lời của bạn (và tại sao họ tôn trọng thông số kỹ thuật, coi nhẹ giả ngẫu nhiên và các vấn đề về số lượng lớn) là đủ.

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Bình thường , 7 byte

WOh=hZQ

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

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

Mã giả:

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

C #, 94 85 byte

Câu trả lời đầu tiên của tôi!

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

Lần thử trước (tôi thích điều đó goto):

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

Ung dung:

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

Lưu ý: trong C #, Random.Next(N)phương thức trả về một số nguyên không âm trong phạm vi [0, N-1], vì vậy chúng ta chỉ cần kiểm tra xem số trả về có lớn hơn 0 không.

R, 47 46 43 byte

43 byte do Robin Ryder trong các bình luận.

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

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

Giải trình

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 byte

[NÌL.R#,

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

Giải trình

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

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

Sẽ đầu ra chuỗi s. Bộ tách biệt được in nếu chương trình kết thúc là NaNhoặc 0.

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

f('test')

Math.random()trả về một giá trị trong khoảng từ 0 đến 1. Nếu giá trị đó nằm dưới n/(n+1), thì nó ssẽ được đưa ra.

4 byte được lưu nhờ @Neil

Java 8, 72 62 61 byte

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

-10 byte nhờ @cliffroot .
-1 byte nhờ @JollyJoker .

Dấu phân cách là một dòng mới.

Giải trình:

Hãy thử nó ở đây.

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

Toán học, 43 byte

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

JungHwan Min đã lưu 1 byte (ở trên) và đề xuất một cái gì đó tốt hơn (bên dưới)

Toán học, 37 byte

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

Clojure, 61 56 byte

Oh tại sao tôi không đi với một forở nơi đầu tiên? Nhưng thực sự để được pedantic doseqphải được sử dụng như forđược đánh giá một cách lười biếng.

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

Nguyên:

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

> <> , 124 112 byte

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

Hãy thử trực tuyến! (Bạn cũng có thể xem nó ở sân chơi cá , nhưng do một số lỗi bạn phải thêm một }sau khi lở dòng thứ tư và thêm một loạt các dòng mới sau khi mã để làm cho nó hoạt động đúng.)

Sự ngẫu nhiên là khó khăn trong> <>. Hướng dẫn ngẫu nhiên duy nhất là x, chọn hướng ngẫu nhiên của cá từ bốn lựa chọn (trái, phải, lên và xuống), do đó, việc biến nó thành thứ gì đó có xác suất 1 / n không đơn giản.

Cách mã này thực hiện bằng cách sử dụng các khả năng tự sửa đổi của> <> để xây dựng Tháp ngẫu nhiên bên dưới mã, vì vậy, ở giai đoạn thứ tư, ví dụ, mã trông như sau:

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

Con cá bắt đầu ở dưới cùng của tháp. Ở mỗi cấp độ của tháp, cái xbị mắc kẹt giữa hai tấm gương, vì vậy cá chỉ có thể trốn thoát bằng cách đi sang trái hoặc phải. Một trong hai hướng này sẽ đưa cá lên tầng tiếp theo của tháp, nhưng đi sang trái cũng đẩy một con 0lên ngăn xếp. Vào thời điểm cá lên đỉnh tháp, ngăn xếp chứa một số 0s và con số này tuân theo phân phối nhị thức với n thử nghiệm và p  = 1/2.

Nếu độ dài của ngăn xếp là 0 (có xác suất 1/2 ⁿ ), chương trình sẽ dừng lại. Nếu chiều dài là 1 (với xác suất n / 2 ⁿ ), cá sẽ in đầu vào và một dòng mới và xây dựng một cấp độ khác của tháp. Nếu chiều dài là bất cứ điều gì khác, cá sẽ loại bỏ chồng và quay trở lại dưới cùng của tháp. Trong thực tế, trong số các khả năng thực sự làm một cái gì đó, n trong số chúng in chuỗi đầu vào và một trong số chúng tạm dừng chương trình, đưa ra các xác suất cần thiết.

Python 3 , 72 69 66 byte

• Đã lưu 3 byte nhờ Jonathan Allan : Nhập tốc ký và bắt đầu đếm từ 2.
• Đã lưu 3 byte nhờ L3viathan : Pointed randint () đã được bao gồm và cũng được rút ngắn trong khi điều kiện.

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

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

QBIC , 19 17 byte

Bỏ =1, chuyển điều kiện, lưu 2 byte

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

Giải trình

{       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 byte

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

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

Tạo số ngẫu nhiên xtrong đó 0 <= x < n+1, chấm dứt nếu bằng x0, nếu không thì tăng nvà vòng lặp. Dấu phân cách là|

Giải trình:

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

Alice , 18 byte

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

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

Giải trình

/     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 byte

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

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

Perl, 26 byte

Mã 24 byte + 2 cho -nl.

print while rand++$i+1|0

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

Than , 14 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sử dụng _như là dấu phân cách. Lưu ý: bộ đệm ẩn đầu ra bị vô hiệu hóa, vì vậy vui lòng không đập máy chủ của Dennis!

MATL , 9 byte

`G@QYrq]x

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

Giải trình

`        % 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 byte

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

Thử nó

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

Thử nó

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

Thử nó

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

Thử nó

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

(với -nđối số dòng lệnh)

Thử nó

Python 3 , 55 byte

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

Giải trình

Để tiết kiệm phải nhập ngẫu nhiên, tôi đã khai thác thực tế là hàm băm tích hợp được gieo ngẫu nhiên mỗi khi một quy trình python được kích hoạt (ít nhất là trong MacOS). Mỗi hàm băm cuối cùng sẽ tạo ra một loạt các số nguyên giả ngẫu nhiên.

Nếu hàm băm đủ giả ngẫu nhiên, modulo bằng i0 với xác suất 1/i.

Ghi chú

Tôi hơi bận tâm về hàm băm dư thừa, nhưng không có sự phân công trong thời gian chờ hoặc trong điều kiện trong Python, tôi hơi bị mắc kẹt.

C #

Đây là cùng độ dài với câu trả lời C # hàng đầu, nhưng:

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

Chỉ muốn chỉ ra rằng một số toán học có thể tạo ra xác suất chính xác.

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

Tương đương với

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

Và hàm f (x) = 1 / x-1 là:

f (1) = 0

f (1/2) = 1

f (1/3) = 2

f (1/4) = 3

Vì vậy, 1/2 cơ hội được làm tròn xuống 0, 1/6 cơ hội được làm tròn xuống 1 và 1 / (n + 1) (n + 2) cơ hội được làm tròn xuống n.

Có lẽ một số ngôn ngữ khác có thể tận dụng điều này.

EDIT: Đã sửa lỗi của tôi

Tôi nghĩ về một cái gì đó để làm cho nó nhỏ hơn.

EDIT EDIT: Tôi chỉ là tất cả các loại sai. Kéo Ngẫu nhiên ra khỏi vòng lặp vì nếu nó được đánh giá nhiều lần, nó sẽ không hoạt động.

EDIT EDIT EDIT: Tôi đã thoát khỏi biến i. Tôi sẽ ngừng cố gắng thu nhỏ nó ngay bây giờ. Không, nói dối. Đã thoát khỏi một byte khác.

Than , 17 byte

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

Hãy thử trực tuyến! Mã Verbose bao gồm. Tôn trọng thông số kỹ thuật bởi vì nó sử dụng một phạm vi ngẫu nhiên từ 0đến n.

C, 41 byte

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

Giả định randlà hạt giống. Hãy thử trực tuyến!

braingasm , 22 byte

chỉnh sửa: Cùng một số byte, nhưng tôi nhận ra rằng tôi có thể lẻn vào Ltính năng bắt chước băng mới .

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

Sử dụng 0như dấu phân cách. Hoạt động như thế này:

,[>,]                   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 byte

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

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

Tạo ra số lượng bản sao như floor(1/p)-1với plựa chọn thống nhất từ khoảng đơn vị. Số lượng bản sao là nkhi 1/p-1rơi vào giữa nvà n+1, xảy ra khi 1/(n+2) < p < 1/(n+1). Điều này xảy ra với xác suất 1/(n+1)-1/(n+2)hoặc 1/((n+1)*(n+2). Đây là xác suất mong muốn xuất ra các nbản sao: đầu 1/2dò 0, đầu 1/6dò 1, đầu 1/12dò 2, ...

C ++, 97 96 57 byte

Đây là lần thử đầu tiên của tôi về codegolf :)

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

Tôi đã lưu một byte bằng cách sử dụng for

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

Đã lưu 39 byte vì dường như không ai đếm được bao gồm

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

vô dụng

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

Chắc chắn đó không phải là ngôn ngữ tốt nhất để chơi gôn, nhưng tôi đã quyết định thử nó (bên cạnh đó, tôi không biết gì về F #, vì vậy mọi lời khuyên về cách cải thiện câu trả lời của tôi sẽ được hoan nghênh).

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

Thực hiện với:

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

Viết một dòng mới như dấu phân cách.

Ruby , 29 + 1 = 30 byte

Sử dụng -ncờ.

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

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

JS (ES6), 47 byte

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

Không giống như câu trả lời ES6 khác, câu hỏi này sử dụng bom vòng lặp và cảnh báo thay vì đệ quy. Bộ tách biệt được in khi chương trình dừng không xác định.

PowerShell, 31 byte

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

Get-Random $ixuất ra một nnơi 0 <= n < $i, dấu phân cách là ẩn dòng mới.

Python, 75 byte

Câu trả lời Python khác ngắn hơn, nhưng tôi muốn thử nó theo một cách khác:

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