Scrivi un programma che, dato un piccolo numero intero pari positivo dall'input standard, calcola la probabilità che lanciando quel numero di monete comporti la metà del numero di teste.

Ad esempio, date 2 monete i possibili risultati sono:

HH HT TH TT

dove H e T sono testa e croce. Ci sono 2 risultati ( HTe TH) che sono la metà del numero di teste rispetto al numero di monete. Ci sono un totale di 4 risultati, quindi la probabilità è 2/4 = 0,5.

Questo è più semplice di quanto sembri.

Casi test:

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

J, 22 19 (approccio killer)

Ci sono arrivato mentre giocavo a golf la mia risposta Haskell.

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

(stesso I / O dell'altra mia risposta J )

Pari / GP - 32 30 34 caratteri

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

Personaggi di Python 53

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

Excel, 25

Non abbastanza secondo le specifiche, però :)

Denominare una cella ne quindi digitare quanto segue in un'altra cella:

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

Haskell, 39 43 46

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

Dimostrazione:

$ 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 (approccio naturale)

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

Esempio di utilizzo:

$ 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

È tutto autoesplicativo, ma per una grossolana divisione delle responsabilità:

• !~ -:potrebbe essere pensato come binomiale (x, x / 2)
• % 2&^è "diviso per 2 ^ x "
• &. (". @ stdin) _ per I / O

GNU Octave - 36 personaggi

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

Rubino, 39 caratteri

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

Golfscript - 30 caratteri

Limitazione: funziona solo per input inferiori a 63

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

casi test

$ 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

Analisi

'0.'GS non fa il virgola mobile, quindi lo falsificheremo scrivendo un numero intero dopo questo
\~Trascina l'input in cima allo stack e convertilo in un numero intero
..Crea 2 copie dell'input
),1>Crea un elenco da 1..n
\2//Dividi il elenca in 1..n / 2 e n / 2 + 1..n
{{*}*}%Moltiplica gli elementi delle due liste secondarie dando (n / 2)! e n! / (n / 2)!
~Estrai quei due numeri nella pila
\Scambia i due numeri attorno a
/Dividi
5@?*Moltiplica per 5 ** n. Questa è la causa della limitazione di cui sopra

TI-BASIC, 10

Questo richiederà più di dieci byte di memoria calcolatrice perché esiste un'intestazione del programma, ma ci sono solo dieci byte di codice.

binompdf(Ans,.5,.5Ans

//Equivalently:

2^~AnsAns nCr (.5Ans

Questo richiede input nel modulo [number]:[program name]; l'aggiunta di un comando di input utilizza altri tre byte. ~è il token meno unario.

Rubino - 50 57 54 caratteri

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

J, 20

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

esempi:

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

21 APL 15 caratteri

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

Per dove non viene visualizzato correttamente

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

Dove tutto in {} sono simboli specifici APL come qui .

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 byte

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

Questo è un approccio ingenuo, suppongo, e la soluzione di fR0DDY è molto più interessante, ma almeno sono in grado di risolverlo.

Provalo qui

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

Objective-C:

152 148 byte solo per la funzione.

I metodi di classe, le intestazioni e l'interfaccia utente non sono inclusi nel codice.

Input: un intvalore che determina il numero di monete.

Output: un floatvalore che determina la probabilità.

-(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. */
}

Questo si basa sulla risposta di Microsoft Excel . In C e Objective-C, la sfida è nel codificare gli algoritmi.