Schreiben Sie ein Programm, das bei einer kleinen positiven geraden Ganzzahl aus der Standardeingabe die Wahrscheinlichkeit berechnet, dass das Umwerfen so vieler Münzen zu halb so vielen Köpfen führt.

Zum Beispiel sind bei 2 Münzen die möglichen Ergebnisse:

HH HT TH TT

wobei H und T Kopf und Zahl sind. Es gibt 2 Ergebnisse ( HTund TH), die halb so viele Köpfe haben wie die Anzahl der Münzen. Es gibt insgesamt 4 Ergebnisse, daher beträgt die Wahrscheinlichkeit 2/4 = 0,5.

Das ist einfacher als es aussieht.

Testfälle:

2 -> 0.5
4 -> 0.375
6 -> 0.3125
8 -> 0.2734375

J, 22 19 (Killer-Ansatz)

Ich bin darauf gekommen, als ich meine Haskell-Antwort gespielt habe.

%/@:>:@i.&.(".@stdin)_

(gleiche E / A wie meine andere J-Antwort )

Pari / GP - 32 30 34 Zeichen

print(binomial(n=input(),n\2)/2^n)

Python 53 Zeichen

i=r=1.;exec"r*=(2*i-1)/i/2;i+=1;"*(input()/2);print r

Excel, 25

Nicht ganz nach Spezifikation :)

Benennen Sie eine Zelle nund geben Sie Folgendes in eine andere Zelle ein:

=COMBIN(n,n/2)/POWER(2,n)

Haskell, 39 43 46

main=do x<-readLn;print$foldr1(/)[1..x]

Demonstration:

$ runhaskell coins.hs <<<2
0.5
$ runhaskell coins.hs <<<4
0.375
$ runhaskell coins.hs <<<6
0.3125
$ runhaskell coins.hs <<<8
0.2734375

J, 25 (natürlicher Ansatz)

((!~-:)%2&^)&.(".@stdin)_

Beispielverwendung:

$ echo -n 2 | jconsole coins.ijs 
0.5
$ echo -n 4 | jconsole coins.ijs
0.375
$ echo -n 6 | jconsole coins.ijs
0.3125
$ echo -n 8 | jconsole coins.ijs 
0.273438

Es ist alles selbsterklärend, aber für eine grobe Aufteilung der Verantwortlichkeiten:

• !~ -:könnte als Binomial angesehen werden (x, x / 2)
• % 2&^ist "geteilt durch 2 ^ x "
• &. (". @ stdin) _ für I / O.

GNU Octave - 36 Zeichen

disp(binopdf((n=input(""))/2,n,.5));

Ruby, 39 Zeichen

p 1/(1..gets.to_i).inject{|a,b|1.0*b/a}

Golfscript - 30 Zeichen

Einschränkung - funktioniert nur für Eingänge unter 63

'0.'\~..),1>\2//{{*}*}%~\/5@?*

Testfälle

$ echo 2 | ruby golfscript.rb binom.gs 
0.50
$ echo 4 | ruby golfscript.rb binom.gs 
0.3750
$ echo 6 | ruby golfscript.rb binom.gs 
0.312500
$ echo 8 | ruby golfscript.rb binom.gs 
0.27343750

Analyse

'0.'GS macht kein Gleitkomma, also fälschen wir es, indem wir danach eine Ganzzahl schreiben.
\~Ziehen Sie die Eingabe an den Anfang des Stapels und konvertieren Sie sie in eine Ganzzahl. Erstellen
..Sie 2 Kopien der Eingabe.
),1>Erstellen Sie eine Liste aus 1..n Teilen Sie
\2//die Liste in 1..n / 2 und n / 2 + 1..n
{{*}*}%Multipliziere die Elemente der beiden Unterlisten mit (n / 2)! und n! / (n / 2)!
~Extrahieren Sie diese beiden Zahlen auf den Stapel.
\Tauschen Sie die beiden Zahlen um
/Divide
5@?*Multiplizieren Sie mit 5 ** n. Dies ist die Ursache für die oben angegebene Einschränkung

TI-BASIC, 10

Dies benötigt mehr als zehn Bytes Rechnerspeicher, da ein Programmheader vorhanden ist, aber nur zehn Bytes Code vorhanden sind.

binompdf(Ans,.5,.5Ans

//Equivalently:

2^~AnsAns nCr (.5Ans

Dies erfolgt in der Form [number]:[program name]; Das Hinzufügen eines Eingabebefehls verwendet drei weitere Bytes. ~ist das unäre Minuszeichen.

Ruby - 50 57 54 Zeichen

p (1..(n=gets.to_i)/2).reduce(1.0){|r,i|r*(n+1-i)/i/4}

J, 20

f=:(]!~[:<.2%~])%2^]

Beispiele:

f 2
0.5
f 4
0.375
f 6
0.3125
f 8
0.273438

APL 21 15 Zeichen

((N÷2)!N)÷2*N←⎕

Denn wo es nicht richtig rendert

((N{ColonBar}2)!N){ColonBar}2*N{LeftArrow}{Quad}

Wo alles in {} APL-spezifische Symbole wie hier sind .

Windows PowerShell, 45

($p=1)..($n="$input"/2)|%{$p*=(1+$n/$_)/4}
$p

Meh.

MATLAB, 29

n=input('');binopdf(n/2,n,.5)

PostScript, 77

([)(%stdin)(r)file token{2 idiv}if def
1
1 1[{[exch div 1 add 4 div mul}for
=

Mathematica, 19

f=2^-# #!/(#/2)!^2&

Javascript, 86 Bytes

a=prompt(f=function(n){return n?n*f(n-1):1});alert(f(a)/(f(a/2)*f(a/2)*Math.pow(2,a)))

Python 3, 99

Ich nehme an, dies ist ein naiver Ansatz, und die Lösung von fR0DDY ist viel cooler, aber zumindest kann ich sie lösen.

Probieren Sie es hier aus

from itertools import*
n=int(input())
print(sum(n/2==i.count("H")for i in product(*["HT"]*n))/2**n)

Python 2, 103

from itertools import*
n=int(raw_input())
print sum(n/2==i.count("H")for i in product(*["HT"]*n))/2.**n

Ziel c:

152 148 Bytes nur für die Funktion.

Klassenmethoden, Header und Benutzeroberfläche sind nicht im Code enthalten.

Eingabe: Ein intWert, der die Anzahl der Münzen bestimmt.

Ausgabe: Ein floatWert, der die Wahrscheinlichkeit bestimmt.

-(float)calcPWithCoins:(int)x {int i=0;int j=0;for (int c=x;c<1;c+-){i=i*c;} for(int d=x/2;d<1;d+-){j=j*d;} return (((float)i/(float)j)/powf(2,x));}

Ungolfed:

-(float)calcPWithCoints:(int)x
{
    int i = 0;
    int j = 0;
    for (int c = x; c < 1; c+-) {
         i = i * c;
    }
    // Calculate the value of x! (Factorial of x)

    for (int d = x / 2; d < 1; d+-)
         j = j * d;
    }
    // Calculate (x/2)! (Factorial of x divided by 2)

    return (((float)i / (float)j) / powf(2, x));
    /* Divides i! by (i/2)!, then divides that result (known as the nCr) by 2^x.
    This is all floating-point and precise. If I didn't have casts in there,
    It would be Integer division and, therefore, wouldn't have any decimal
    precision. */
}

Dies basiert auf der Microsoft Excel-Antwort . In C und Objective-C besteht die Herausforderung darin, die Algorithmen hart zu codieren.