Bei einer vorgegebenen Eingabezeichenfolge wird auf folgende Weise Sgedruckt, Sgefolgt von einem nicht leeren Trennzeichen:

• Schritt 1: Es Sbesteht die Möglichkeit, dass das Programm 1/2gedruckt wird und 1/2beendet wird.

• Schritt 2: Es Sbesteht die Möglichkeit, dass das Programm 2/3gedruckt wird und 1/3beendet wird.

• Schritt 3: Es Sbesteht die Möglichkeit, dass das Programm 3/4gedruckt wird und 1/4beendet wird.

• …

• Schritt n: Es Sbesteht die Möglichkeit, dass das Programm n/(n+1)gedruckt wird und 1/(n+1)beendet wird.

Anmerkungen

• Die Eingabezeichenfolge besteht nur aus Zeichen, die im Zeichenfolgentyp Ihrer Sprache zulässig sind.

• Jedes nicht leere Trennzeichen kann verwendet werden, solange es immer dasselbe ist. Es wird erwartet, dass das Trennzeichen nach dem letzten Druck von gedruckt wird, Sbevor das Programm beendet wird.

• Das Programm kann 1/2vor dem Drucken beendet werden.

• Eine abschließende neue Zeile ist akzeptabel.

• Ihre Antwort muss einen echten Versuch machen, die beschriebenen Wahrscheinlichkeiten zu respektieren. Offensichtlich nwird dies immer weniger wahr sein , wenn es groß ist. Es reicht aus, zu erklären, wie Wahrscheinlichkeiten in Ihrer Antwort berechnet werden (und warum sie die Spezifikationen einhalten, wobei Pseudozufälligkeiten und Probleme mit großen Zahlen unberücksichtigt bleiben).

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

Pyth , 7 Bytes

WOh=hZQ

Probieren Sie es online!

Wie es funktioniert

Pseudocode:

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

C #, 94-85 Bytes

Meine erste Antwort!

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

Vorheriger Versuch (das hat mir gefallen 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();
    }
}

Hinweis: In C # gibt die Random.Next(N)Methode eine nicht negative Ganzzahl im Bereich [0, N-1] zurück, sodass wir nur überprüfen können, ob die zurückgegebene Zahl größer als 0 ist.

R, 47 46 43 Bytes

43 Bytes wegen Robin Ryder in den Kommentaren.

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Erläuterung

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

Gibt einen String aus s. Das Trennzeichen, das beim Beenden des Programms ausgegeben wird, ist NaNoder 0.

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

f('test')

Math.random()Gibt einen Wert zwischen 0 und 1 zurück. Wenn dieser Wert darunter liegt n/(n+1), swird gedruckt.

4 Bytes gespart dank @Neil

Java 8, 72 62 61 Bytes

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

-10 Bytes dank @cliffroot .
-1 Byte dank @JollyJoker .

Trennzeichen ist eine neue Zeile.

Erläuterung:

Probieren Sie es hier aus.

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 sparte 1 Byte (oben) und schlug etwas Besseres vor (unten)

Mathematica, 37 Bytes

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

Clojure, 61 56 Bytes

Oh, warum bin ich überhaupt nicht mit einem forgefahren? Aber um pedantisch doseqzu sein, muss man so forvorgehen , wie es faul bewertet wird.

#(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>_ {:?!^

Probieren Sie es online! (Sie können es auch auf dem Fischspielplatz ansehen , aber aufgrund einiger Fehler müssen Sie in der vierten Zeile ein }nach dem leinfügen und nach dem Code ein paar neue Zeilen einfügen, damit es richtig funktioniert.)

Zufälligkeit ist in> <> schwierig. Die einzige zufällige Anweisung ist x, die die Richtung des Fisches zufällig aus vier Auswahlmöglichkeiten (links, rechts, oben und unten) auswählt, sodass es nicht einfach ist , daraus etwas mit der Wahrscheinlichkeit 1 / n zu machen .

In diesem Code wird mithilfe der selbstmodifizierenden Funktionen von> <> ein Tower of Randomness unter dem Code erstellt. In der vierten Phase sieht der Code beispielsweise folgendermaßen aus:

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

Der Fisch beginnt am Fuße des Turms. Auf jeder Ebene des Turms xist der zwischen zwei Spiegeln eingeschlossen, sodass der Fisch nur nach links oder rechts entkommen kann. In jede dieser Richtungen wird der Fisch in die nächste Ebene des Turms befördert, aber wenn Sie nach links gehen, wird auch a 0auf den Stapel geschoben. Bis der Fisch die Spitze des Turms erreicht, enthält der Stapel eine Anzahl von 0s, und diese Anzahl folgt einer Binomialverteilung mit n Versuchen und p  = 1/2.

Wenn die Länge des Stapels 0 ist (was eine Wahrscheinlichkeit von 1/2 ^{n hat} ), wird das Programm angehalten. Wenn die Länge 1 ist (mit einer Wahrscheinlichkeit von n / 2 ⁿ ), druckt der Fisch die Eingabe und eine neue Zeile und baut eine weitere Ebene des Turms auf. Wenn die Länge etwas anderes ist, wirft der Fisch den Stapel ab und kehrt zum Boden des Turms zurück. Tatsächlich drucken n von ihnen aus den Möglichkeiten, die tatsächlich etwas bewirken, die Eingabezeichenfolge, und einer von ihnen hält das Programm an und gibt die erforderlichen Wahrscheinlichkeiten an.

Python 3 , 72 69 66 Bytes

• 3 Bytes gespart dank Jonathan Allan : Kurzschrift importieren und ab 2 zählen.
• 3 Bytes gespart dank L3viathan : Pointed Randint () war inklusive und verkürzt auch während Bedingung.

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

Probieren Sie es online!

QBIC , 19 17 Bytes

Gelöschte =1, umgeschaltete Bedingungen, 2 Bytes gespart

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

Erläuterung

{       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+]|;

Probieren Sie es online!

Zufallszahl erzeugt , xwo 0 <= x < n+1, beendet , wenn x0 ist , andernfalls inkrementiert nund Schleifen. Trennzeichen ist|

Erläuterung:

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

Probieren Sie es online!

Erläuterung

/     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._;

Probieren Sie es online!

Perl, 26 Bytes

24 Byte Code + 2 für -nl.

print while rand++$i+1|0

Probieren Sie es online!

Holzkohle , 14 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Verwendet _als Trennzeichen. Hinweis: Das Zwischenspeichern von Ausgaben ist deaktiviert, also hämmern Sie bitte nicht Dennis 'Server!

MATL , 9 Bytes

`G@QYrq]x

Probieren Sie es online!

Erläuterung

`        % 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)}

Versuch es

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

Versuch es

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

Versuch es

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

Versuch es

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

(mit -nKommandozeilenargument)

Versuch es

Python 3 , 55 Bytes

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

Erläuterung

Um nicht zufällig importieren zu müssen, habe ich die Tatsache ausgenutzt, dass der integrierte Hash jedes Mal zufällig gesetzt wird, wenn ein Python-Prozess gestartet wird (zumindest unter MacOS). Jeder Hash des letzten Hash sollte eine Reihe von Pseudozufallszahlen erzeugen.

Wenn der Hash pseudozufällig genug ist, ist das Modulo imit Wahrscheinlichkeit Null 1/i.

Anmerkungen

Der überflüssige Hash stört mich ein wenig, aber ohne eine Unterbrechung oder die Zuweisung von Bedingungen in Python stecke ich ein wenig fest.

C #

Dies ist dieselbe Länge wie die obere C # -Antwort, aber:

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

Ich wollte nur darauf hinweisen, dass einige Mathematik die richtige Wahrscheinlichkeit produzieren kann.

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

Ist äquivalent zu

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

Und die Funktion f (x) = 1 / x-1 ist:

f (1) = 0

f (1/2) = 1

f (1/3) = 2

f (1/4) = 3

Also 1/2 eine Chance, auf 0 abgerundet zu werden, 1/6 eine Chance, auf 1 abgerundet zu werden, und 1 / (n + 1) (n + 2) eine Chance, auf n abgerundet zu werden.

Vielleicht könnte eine andere Sprache davon profitieren.

EDIT: Mein Fehler wurde behoben

Ich dachte an etwas, um es kleiner zu machen.

EDIT EDIT: Ich liege einfach falsch. Random aus der Schleife gezogen, da es nicht funktioniert, wenn es mehrmals ausgewertet wird.

EDIT EDIT EDIT: Ich habe die Variable i losgeworden. Ich werde jetzt aufhören zu versuchen, es zu verkleinern. Nein, gelogen. Wurde ein anderes Byte los.

Kohle , 17 Bytes

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

Probieren Sie es online! Ausführlicher Code enthalten. Respektiert Spezifikationen, da ein zufälliger Bereich von 0bis verwendet wird n.

C 41 Bytes

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

Angenommen, randist gesät. Probieren Sie es online!

Braingasmus , 22 Bytes

edit: Gleiche LByteanzahl , aber mir wurde klar, dass ich mich in die neue Tape Imit-Funktion einschleichen konnte .

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

Verwendet 0als Trennzeichen. Funktioniert so:

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

Probieren Sie es online!

Erzeugte die Anzahl der Exemplare wie floor(1/p)-1bei peinheitlich gewähltem Einheitsintervall. Die Anzahl der Kopien ist, nwenn 1/p-1zwischen nund liegt n+1, was passiert, wenn 1/(n+2) < p < 1/(n+1). Dies geschieht mit der Wahrscheinlichkeit 1/(n+1)-1/(n+2)oder 1/((n+1)*(n+2). Dies ist die gewünschte Wahrscheinlichkeit für die Ausgabe von nKopien: 1/2prob von 0, 1/6prob von 1, 1/12prob von 2, ...

C ++, 97 96 57 Bytes

Hier mein erster Versuch mit Codegolf :)

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

Ich habe ein Byte mit gespeichert for

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

39 Bytes gespart, da niemand die Includes zu zählen scheint

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

ungolfed

#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

Auf jeden Fall nicht die beste Sprache zum Golfspielen, aber ich habe mich dazu entschlossen, es zu versuchen (außerdem weiß ich nichts über F #, daher sind alle Tipps zur Verbesserung meiner Antwort willkommen).

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

Ausführen mit:

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

Schreibt eine neue Zeile als Trennzeichen.

Ruby , 29 + 1 = 30 Bytes

Verwendet die -nFlagge.

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

Probieren Sie es online!

JS (ES6), 47 Bytes

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

Im Gegensatz zu der anderen ES6-Antwort werden hier for-Schleifen- und Alarmbomben anstelle von Rekursionen verwendet. Das Trennzeichen, das beim Beenden des Programms gedruckt wird, ist nicht definiert.

PowerShell, 31 Byte

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

Get-Random $iAusgänge ein , nwo der 0 <= n < $iSeparator ist implizit Neue - Zeile.

Python, 75 Bytes

Die andere Python-Antwort ist kürzer, aber ich wollte es anders versuchen:

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