Viết một chương trình, với một số nguyên chẵn dương nhỏ từ đầu vào tiêu chuẩn, tính toán xác suất lật nhiều đồng xu sẽ dẫn đến một nửa số đầu.

Ví dụ: đưa ra 2 đồng tiền, kết quả có thể xảy ra là:

HH HT TH TT

trong đó H và T là đầu và đuôi. Có 2 kết quả ( HTvà TH) là một nửa số đầu bằng số lượng tiền. Có tổng cộng 4 kết quả, vì vậy xác suất là 2/4 = 0,5.

Điều này là đơn giản hơn nó trông.

Các trường hợp thử nghiệm:

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

J, 22 19 (phương pháp giết người)

Tôi đã nhận được điều này trong khi chơi golf câu trả lời Haskell của tôi.

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

(cùng I / O như câu trả lời J khác của tôi )

Pari / GP - 32 30 34 ký tự

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

Nhân vật Python 53

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

Excel, 25

Không hoàn toàn theo thông số kỹ thuật, mặc dù :)

Đặt tên cho một ô nvà sau đó nhập nội dung sau vào một ô khác:

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

Haskell, 39 43 46

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

Trình diễn:

$ 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 (cách tiếp cận tự nhiên)

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

Sử dụng mẫu:

$ 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

Tất cả đều tự giải thích, nhưng để phân chia trách nhiệm:

• !~ -:có thể được coi là nhị thức (x, x / 2)
• % 2&^là "chia cho 2 ^ x "
• &. (". @ stdin) _ cho I / O

GNU Octave - 36 ký tự

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

Ruby, 39 ký tự

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

Golfscript - 30 ký tự

Giới hạn - chỉ hoạt động đối với đầu vào dưới 63

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

trường hợp kiểm tra

$ 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

Phân tích

'0.'GS không làm dấu phẩy động, vì vậy chúng tôi sẽ giả mạo nó bằng cách viết một số nguyên sau này
\~Kéo đầu vào lên trên cùng của ngăn xếp và chuyển đổi thành một số nguyên
..Tạo 2 bản sao của đầu vào
),1>Tạo một danh sách từ 1..n
\2//Tách liệt kê thành 1..n / 2 và n / 2 + 1..n
{{*}*}%Nhân các phần tử của hai danh sách con cho (n / 2)! và n! / (n / 2)!
~Trích xuất hai số đó vào ngăn xếp
\Hoán đổi hai số xung quanh
/Chia cho
5@?*Nhân với 5 ** n. Đây là nguyên nhân của giới hạn nêu trên

TI-CƠ BẢN, 10

Điều này sẽ mất hơn mười byte bộ nhớ máy tính vì có một tiêu đề chương trình, nhưng chỉ có mười byte mã.

binompdf(Ans,.5,.5Ans

//Equivalently:

2^~AnsAns nCr (.5Ans

Điều này có đầu vào trong mẫu [number]:[program name]; thêm một lệnh Input sử dụng thêm ba byte. ~là mã thông báo trừ đơn nhất.

Ruby - 50 57 54 ký tự

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

J, 20

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

ví dụ:

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

APL 21 15 ký tự

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

Vì nơi nào nó không hiển thị đúng

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

Trong đó mọi thứ trong {} là các ký hiệu cụ thể của APL như ở đây .

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
=

Toán học, 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)))

Trăn 3, 99

Đây là một cách tiếp cận ngây thơ, tôi cho rằng, và giải pháp của fR0DDY mát mẻ hơn nhiều, nhưng ít nhất tôi có thể giải quyết nó.

Hãy thử nó ở đây

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

Con trăn 2, 103

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

Mục tiêu-C:

152 148 byte cho chỉ chức năng.

Các phương thức lớp, tiêu đề và giao diện người dùng không được bao gồm trong mã.

Đầu vào: một int giá trị xác định số lượng xu.

Đầu ra: một floatgiá trị xác định xác suất.

-(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));}

Ung dung:

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

Điều này dựa trên câu trả lời của Microsoft Excel . Trong C và Objective-C, thách thức là mã hóa cứng các thuật toán.