Dada uma sequência de entrada S, imprima Sseguida por um separador não vazio da seguinte maneira:

• Etapa 1: Stem a 1/2chance de ser impressa e a 1/2chance de o programa terminar.

• Etapa 2: Stem uma 2/3chance de ser impressa e uma 1/3chance de o programa terminar.

• Etapa 3: Stem a 3/4chance de ser impressa e a 1/4chance de o programa terminar.

• ...

• Etapa n: Stem a n/(n+1)chance de ser impressa e a 1/(n+1)chance de o programa terminar.

Notas

• A sequência de entrada será composta apenas por caracteres aceitáveis ​​no tipo de sequência do seu idioma.

• Qualquer separador não vazio pode ser usado, desde que seja sempre o mesmo. Espera-se que o separador seja impresso após a última impressão Santes de o programa terminar.

• O programa pode 1/2terminar antes de imprimir qualquer coisa.

• Uma nova linha à direita é aceitável.

• Sua resposta deve fazer uma tentativa genuína de respeitar as probabilidades descritas. Obviamente, quando nfor grande, isso será cada vez menos verdadeiro. Uma explicação adequada de como as probabilidades são computadas em sua resposta (e por que elas respeitam as especificações, desconsiderando problemas de pseudo-aleatoriedade e grandes números) é suficiente.

Pontuação

Isso é código-golfe , então a resposta mais curta em bytes vence.

Pitão , 7 bytes

WOh=hZQ

Experimente online!

Como funciona

Pseudo-código:

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

C #, 94 85 bytes

Minha primeira resposta!

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

Tentativa anterior (gostei disso goto):

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

Ungolfed:

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

Nota: em C # o Random.Next(N)método retorna um número inteiro não negativo no intervalo [0, N-1], para que possamos apenas verificar se o número retornado é maior que 0.

R, 47 46 43 bytes

43 bytes devido a Robin Ryder nos comentários.

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

Experimente online!

Explicação

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 bytes

[NÌL.R#,

Experimente online!

Explicação

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

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

Produzirá a string s. O separador que é impresso se o programa terminar é NaNou 0.

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

f('test')

Math.random()retorna um valor entre 0 e 1. Se esse valor estiver abaixo n/(n+1), sserá premido.

4 bytes salvos graças a @Neil

Java 8, 72 62 61 bytes

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

-10 bytes graças a @cliffroot .
-1 byte graças a @JollyJoker .

Delimitador é uma nova linha.

Explicação:

Experimente aqui.

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 bytes

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

JungHwan Min salvou 1 byte (acima) e sugeriu algo melhor (abaixo)

Mathematica, 37 bytes

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

Clojure, 61 56 bytes

Oh, por que eu não fui com um forem primeiro lugar? Mas, na verdade, ser pedante doseqdeve ser usado como foré avaliado preguiçosamente.

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

Original:

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

> <> , 124 112 bytes

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

Experimente online! (Você também pode assisti-lo no playground de peixes , mas devido a alguns erros, é necessário adicionar um }depois do lna quarta linha e adicionar várias linhas novas após o código para fazê-lo funcionar corretamente.)

A aleatoriedade é complicada em> <>. A única instrução aleatória é x, que escolhe a direção do peixe aleatoriamente entre quatro opções (esquerda, direita, para cima e para baixo), de modo que transformar isso em algo com probabilidade 1 / n não é simples.

Da maneira que esse código faz, é usando os recursos de autod modificação de> <> para criar uma Torre de Aleatoriedade abaixo do código; portanto, no quarto estágio, por exemplo, o código se parece com:

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

O peixe começa na parte inferior da torre. Em cada nível da torre, a xarmadilha fica presa entre dois espelhos, de modo que o peixe só pode escapar indo para a esquerda ou direita. Qualquer uma dessas direções envia o peixe para o próximo nível da torre, mas ir para a esquerda também empurra um 0para a pilha. Quando o peixe chega ao topo da torre, a pilha contém algum número de se 0esse número segue uma distribuição binomial com n tentativas ep  = 1/2.

Se o comprimento da pilha for 0 (com probabilidade 1/2 ⁿ ), o programa será interrompido. Se o comprimento for 1 (com probabilidade n / 2 ⁿ ), o peixe imprime a entrada e uma nova linha e constrói outro nível da torre. Se o comprimento for qualquer outra coisa, o peixe descarta a pilha e volta para o fundo da torre. De fato, dentre as possibilidades que realmente fazem algo, n delas imprimem a sequência de entrada e uma delas interrompe o programa, fornecendo as probabilidades necessárias.

Python 3 , 72 69 66 bytes

• Economizou 3 bytes graças a Jonathan Allan : importe taquigrafia e comece a contar a partir de 2.
• Economizou 3 bytes graças ao L3viathan : O randint apontado () foi inclusivo e também encurtado durante a condição.

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

Experimente online!

QBIC , 19 17 bytes

Descartados =1, condicionais comutados, salvos 2 bytes

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

Explicação

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

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

Experimente online!

Gera um número aleatório em xque 0 <= x < n+1, termina se xfor 0, caso contrário, incrementos ne loops. Separador é|

Explicação:

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

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

Experimente online!

Explicação

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

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

Experimente online!

Perl, 26 bytes

Código de 24 bytes + 2 para -nl.

print while rand++$i+1|0

Experimente online!

Carvão , 14 bytes

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

Experimente online! Link é a versão detalhada do código. Usa _como separador. Nota: o cache de saída está desativado; portanto, não martele o servidor de Dennis!

MATL , 9 bytes

`G@QYrq]x

Experimente online!

Explicação

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

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

Tente

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

Tente

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

Tente

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

Tente

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

(com -nargumento da linha de comando)

Tente

Python 3 , 55 bytes

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

Explicação

Para evitar a importação aleatória, explorei o fato de que o hash interno é aleatoriamente propagado toda vez que um processo python é iniciado (pelo menos no MacOS). Cada hash do último hash deve gerar uma série de números inteiros pseudo-aleatórios.

Se o hash é pseudo-aleatório o suficiente, o módulo com ié zero com probabilidade 1/i.

Notas

Estou um pouco incomodado com o hash redundante, mas sem uma atribuição de tempo de permanência ou condição no Python, estou um pouco preso.

C #

Este é o mesmo tamanho da resposta C # principal, mas:

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

Só queria salientar que alguma matemática pode produzir a probabilidade correta.

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

É equivalente a

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

E a função f (x) = 1 / x-1 é:

f (1) = 0

f (1/2) = 1

f (1/3) = 2

f (1/4) = 3

Portanto, 1/2 chance de ser arredondado para 0, 1/6 de chance de ser arredondado para 1 e 1 / (n + 1) (n + 2) uma chance de ser arredondado para n.

Talvez alguma outra linguagem possa tirar proveito disso.

EDIT: Corrigido meu erro

Pensei em algo para torná-lo menor.

Editar edição: eu estou apenas todos os tipos de errado. Puxou o Random para fora do loop, porque se ele for avaliado várias vezes, não funcionará.

Editar edição editar: me livrei da variável i. Vou parar de tentar diminuir agora. Não, menti. Livre-se de outro byte.

Carvão , 17 bytes

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

Experimente online! Código detalhado incluído. Respeita as especificações porque usa um intervalo aleatório de 0até n.

C, 41 bytes

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

Assume que randé semeado. Experimente online!

braingasm , 22 bytes

editar: Contagem de mesmos bytes, mas percebi que podia me infiltrar no novo Lrecurso de imitação de fita .

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

Usa 0como separador. Funciona assim:

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

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

Experimente online!

Gerado o número de cópias como floor(1/p)-1com puniformemente escolhido a partir do intervalo de unidade. O número de cópias é nquando 1/p-1cai entre ne n+1, o que acontece quando 1/(n+2) < p < 1/(n+1). Isso acontece com probabilidade 1/(n+1)-1/(n+2)ou 1/((n+1)*(n+2). Esta é a probabilidade desejada de produzir ncópias: 1/2prob de 0, 1/6prob de 1, 1/12prob de 2, ...

C ++, 97 96 57 bytes

Aqui minha primeira tentativa no codegolf :)

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

Salvei um byte usando for

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

Economizou 39 bytes, já que ninguém parece contar as inclusões

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

destroçado

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

Definitivamente não é o melhor idioma para o golfe, mas decidi tentar (além disso, não sei nada sobre F #, portanto, qualquer dica sobre como melhorar minha resposta será bem-vinda).

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

Executar com:

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

Grava uma nova linha como separador.

Ruby , 29 + 1 = 30 bytes

Usa a -nbandeira.

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

Experimente online!

JS (ES6), 47 bytes

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

Diferentemente da outra resposta do ES6, ele usa bombas for loop e alert em vez de recursão. O separador que é impresso quando o programa para é indefinido.

PowerShell, 31 bytes

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

Get-Random $igera um nonde 0 <= n < $i, separador é uma nova linha implícita.

Python, 75 bytes

A outra resposta do Python é mais curta, mas eu queria tentar de uma maneira diferente:

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