Calculate probability of getting half as many heads as coin tosses.

Question

Write a program that, given a small positive even integer from standard input, calculates the probability that flipping that many coins will result in half as many heads.

For example, given 2 coins the possible outcomes are:

HH HT TH TT

where H and T are heads and tails. There are 2 outcomes (HT and TH) that are half as many heads as the number of coins. There are a total of 4 outcomes, so the probability is 2/4 = 0.5.

This is simpler than it looks.

Test cases:

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

Answer 1

J, 22 19 (killer approach)

I got down to this while golfing my Haskell answer.

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

(same I/O as my other J answer)

Answer 2

Pari/GP - 32 30 34 chars

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

Answer 3

Python 53 Characters

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

Answer 4

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

Answer 5

Excel, 25

Not quite according to spec, though :)

Name a cell n and then type the following into another cell:

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

Answer 6

Golfscript - 30 chars

Limitation - only works for inputs less than 63

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

test cases

$ 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

Analysis

'0.' GS doesn't do floating point, so we'll fake it by writing an integer after this
\~ Pull the input to the top of the stack and convert to an integer
.. Make 2 copies of the input
),1>Create a list from 1..n
\2//Split the list into 1..n/2 and n/2+1..n
{{*}*}%Multiply the elements of the two sublists giving (n/2)! and n!/(n/2)!
~Extract those two numbers onto the stack
\Swap the two numbers around
/Divide
5@?*Multiply by 5**n. This is the cause of the limitation given above

Answer 7

J, 25 (natural approach)

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

Sample use:

$ 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

It's all self-explanatory, but for a rough split of responsibilities:

• !~ -: could be thought of as binomial(x,x/2)
• % 2&^ is "divided by 2^x"
• &. (". @ stdin) _ for I/O

Answer 8

GNU Octave - 36 Characters

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

Answer 9

Ruby, 39 characters

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

Answer 10

TI-BASIC, 10

This will take more than ten bytes of calculator memory because there is a program header, but there are only ten bytes of code.

binompdf(Ans,.5,.5Ans

//Equivalently:

2^~AnsAns nCr (.5Ans

This takes input in the form [number]:[program name]; adding an Input command uses three more bytes. ~ is the unary minus token.

Answer 11

Ruby - 50 57 54 chars

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

Answer 12

J, 20

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

examples:

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

Answer 13

APL 21 15 chars

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

For where it doesn't render right

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

Where everything in {} are APL specific symbols like here.

Answer 14

Windows PowerShell, 45

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

Meh.

Answer 15

MATLAB, 29

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

Answer 16

PostScript, 77

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

Answer 17

Mathematica, 19

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

Answer 18

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)))

Answer 19

Python 3, 99

This is a naive approach, I suppose, and fR0DDY's solution is much cooler, but at least I am able to solve it.

Try it here

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

Answer 20

Objective-C:

152 148 bytes for just the function.

Class methods, headers, and UI are not included within the code.

Input: an int value determinining the number of coins.

Output: a float value determining the probability.

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

This is based off of the Microsoft Excel answer. In C and Objective-C, the challenge is in hard-coding the algorithms.