Étant donné une chaîne d'entrée S, print Ssuivi d'un séparateur non vide de la manière suivante:

• Étape 1: Sa une 1/2chance d'être imprimé et une 1/2chance pour que le programme se termine.

• Étape 2: Sa une 2/3chance d'être imprimé et une 1/3chance pour que le programme se termine.

• Étape 3: Sa une 3/4chance d'être imprimé et une 1/4chance pour que le programme se termine.

• …

• Étape n: Sa une n/(n+1)chance d'être imprimé et une 1/(n+1)chance pour que le programme se termine.

Remarques

• La chaîne d'entrée ne comprendra que des caractères acceptables dans le type de chaîne de votre langue.

• Tout séparateur non vide peut être utilisé, à condition qu'il soit toujours identique. Le séparateur devrait être imprimé après la dernière impression Savant la fin du programme.

• Le programme a une 1/2chance de se terminer avant d’imprimer quoi que ce soit.

• Une nouvelle ligne est acceptable.

• Votre réponse doit véritablement tenter de respecter les probabilités décrites. Évidemment, quand nest grand ce sera de moins en moins vrai. Une explication appropriée de la manière dont les probabilités sont calculées dans votre réponse (et de la raison pour laquelle elles respectent les spécifications, abstraction faite des problèmes de pseudo-aléatoire et des grands nombres) est suffisante.

Notation

C'est du code-golf , donc la réponse la plus courte en octets est gagnante.

Pyth , 7 octets

WOh=hZQ

Essayez-le en ligne!

Comment ça marche

Pseudocode:

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

C #, 94 85 octets

Ma première réponse!

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

Tentative précédente (j'ai aimé ça 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();
    }
}

Remarque: en C #, la Random.Next(N)méthode retourne un entier non négatif dans la plage [0, N-1], nous pouvons donc simplement vérifier que le nombre renvoyé est supérieur à 0.

R, 47 46 43 octets

43 octets dus à Robin Ryder dans les commentaires.

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

Essayez-le en ligne!

Explication

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 octets

[NÌL.R#,

Essayez-le en ligne!

Explication

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

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

Sera la chaîne de sortie s. Le séparateur qui est imprimé si le programme se termine est NaNou 0.

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

f('test')

Math.random()renvoie une valeur comprise entre 0 et 1. Si cette valeur est inférieure à n/(n+1), elle ssera utilisée.

4 octets sauvegardés grâce à @Neil

Java 8, 72 62 61 octets

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

-10 octets grâce à @cliffroot .
-1 octet grâce à @JollyJoker .

Le délimiteur est une nouvelle ligne.

Explication:

Essayez ici.

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 octets

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

JungHwan Min a économisé 1 octet (ci-dessus) et suggéré quelque chose de mieux (ci-dessous)

Mathematica, 37 octets

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

Clojure, 61 56 octets

Oh pourquoi je ne suis pas allé avec un foren premier lieu? Mais en réalité, être pédant doseqdoit être utilisé tel qu’il forest évalué paresseusement.

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

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

Essayez-le en ligne! (Vous pouvez également le regarder sur le terrain de jeu du poisson , mais à cause de certains bugs, vous devez ajouter un }après lla quatrième ligne et ajouter un tas de nouvelles lignes après le code pour que cela fonctionne correctement.)

Le hasard est délicat dans> <>. La seule instruction aléatoire est de xchoisir la direction du poisson parmi quatre choix (gauche, droite, haut et bas), de sorte que le transformer en quelque chose avec une probabilité de 1 / n n'est pas simple.

Ce code utilise les fonctionnalités de modification automatique de> <> pour créer une Tower of Randomness sous le code. Ainsi, à la quatrième étape, par exemple, le code ressemble à ceci:

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

Le poisson commence au bas de la tour. À chaque niveau de la tour, le xest coincé entre deux miroirs, ainsi le poisson ne peut s'échapper qu'en allant à gauche ou à droite. Chacune de ces directions envoie le poisson au niveau supérieur de la tour, mais aller à gauche pousse également un 0vers la pile. Au moment où le poisson arrive au sommet de la tour, la pile contient un certain nombre de 0s et ce nombre suit une distribution binomiale avec n essais et p  = 1/2.

Si la longueur de la pile est égale à 0 (avec une probabilité de 1/2 ⁿ ), le programme s’arrête. Si la longueur est 1 (avec une probabilité n / 2 ⁿ ), le poisson imprime l'entrée et une nouvelle ligne et construit un autre niveau de la tour. Si la longueur est différente, le poisson jette la pile et retourne au bas de la tour. En fait, sur les possibilités qui font réellement quelque chose, n d’entre eux impriment la chaîne de saisie et l’un d’eux arrête le programme, en donnant les probabilités requises.

Python 3 , 72 69 66 octets

• 3 octets sauvés grâce à Jonathan Allan : Importer un raccourci et compter à partir de 2.
• Sauvegardé de 3 octets grâce à L3viathan : Randint pointu () était inclus et a également été raccourci.

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

Essayez-le en ligne!

QBIC , 19 17 octets

Chute =1, changement de condition, sauvegarde de 2 octets

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

Explication

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

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

Essayez-le en ligne!

Génère un nombre aléatoire xoù 0 <= x < n+1, se termine si xvaut 0, sinon incrémente net boucle. Le séparateur est|

Explication:

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

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

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Perl, 26 octets

Code de 24 octets + 2 pour -nl.

print while rand++$i+1|0

Essayez-le en ligne!

Charbon de bois , 14 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Utilise _comme séparateur. Remarque: la mise en cache de la sortie est désactivée, veuillez donc ne pas écraser le serveur de Dennis!

MATL , 9 octets

`G@QYrq]x

Essayez-le en ligne!

Explication

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

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

L'essayer

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

L'essayer

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

L'essayer

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

L'essayer

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

(avec -nargument en ligne de commande)

L'essayer

Python 3 , 55 octets

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

Explication

Pour éviter d'avoir à importer de manière aléatoire, j'ai exploité le fait que le hachage intégré est créé de manière aléatoire à chaque fois qu'un processus python est lancé (du moins sous MacOS). Chaque hachage du dernier doit générer une série d’entiers pseudo-aléatoires.

Si le hachage est suffisamment pseudo-aléatoire, le modulo avec ivaut zéro avec probabilité 1/i.

Remarques

Je suis un peu gêné par le hachage redondant, mais sans affectation temporaire ou in-condition en Python, je suis un peu coincé.

C #

C'est la même longueur que la réponse C # en haut, mais:

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

Je voulais juste souligner que certains calculs peuvent produire la probabilité correcte.

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

Est équivalent à

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

Et la fonction f (x) = 1 / x-1 est:

f (1) = 0

f (1/2) = 1

f (1/3) = 2

f (1/4) = 3

Donc, une chance sur deux d'être arrondie à 0, une chance sur six d'être arrondie à un, et 1 / (n + 1) (n + 2) une chance d'être arrondie à n.

Peut-être qu'une autre langue pourrait en tirer parti.

EDIT: Correction de mon erreur

J'ai pensé à quelque chose pour le rendre plus petit.

EDIT EDIT: Je me trompe de toutes sortes. Sortir le Random de la boucle, car s'il est évalué plusieurs fois, cela ne fonctionnera pas.

EDIT EDIT EDIT: Je me suis débarrassé de la variable i. Je vais arrêter d'essayer de le réduire maintenant. Non, a menti. Je me suis débarrassé d'un autre octet.

Charbon de bois , 17 octets

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

Essayez-le en ligne! Code verbeux inclus. Respecte les spécifications car il utilise une plage aléatoire allant de 0à n.

C, 41 octets

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

Assume randest ensemencée. Essayez-le en ligne!

braingasm , 22 octets

edit: Même nombre d'octets, mais j'ai réalisé que je pouvais me glisser dans la nouvelle Lfonctionnalité imit tape .

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

Utilise 0comme séparateur. Fonctionne comme ceci:

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

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

Essayez-le en ligne!

Généré le nombre de copies comme floor(1/p)-1avec puniformément choisi de l'intervalle d'unité. Le nombre de copies est compris entre nquand et ce qui arrive quand . Cela se produit avec une probabilité ou . C'est la probabilité souhaitée de sortie des copies: prob de 0, prob de 1, prob de 2, ...1/p-1nn+11/(n+2) < p < 1/(n+1)1/(n+1)-1/(n+2)1/((n+1)*(n+2)n1/21/61/12

C ++, 97 96 57 octets

Voici mon premier essai sur codegolf :)

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

J'ai sauvegardé un octet en utilisant for

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

Sauvé 39 octets puisque personne ne semble compter les inclus

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

non-golfé

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

Ce n’est certainement pas la meilleure langue pour jouer au golf, mais j’ai décidé de l’essayer (en plus, je ne connais rien à F #, donc tout conseil pour améliorer ma réponse sera le bienvenu).

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

Exécuter avec:

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

Écrit une nouvelle ligne en tant que séparateur.

Ruby , 29 + 1 = 30 octets

Utilise le -ndrapeau.

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

Essayez-le en ligne!

JS (ES6), 47 octets

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

Contrairement aux autres réponses ES6, cela utilise une boucle for et des bombes d'alerte au lieu d'une récursion. Le séparateur qui est imprimé lorsque le programme s’arrête n’est pas défini.

PowerShell, 31 octets

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

Get-Random $igénère un séparateur noù 0 <= n < $iest une nouvelle ligne implicite.

Python, 75 octets

L'autre réponse Python est plus courte, mais je voulais essayer d'une autre manière:

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