정의

울 스턴 홀름의 정리에 따르면 :

곳 a과 b양의 정수와 p소수, 그리고 큰 괄호 꼬추는 이항 계수 .

직무

그것을 확인하려면, 당신은 3 개 개의 입력이 주어집니다 : a, b, p, 어디서 a과 b양의 정수이며 p소수.

계산 :

여기서 a와 b양의 정수 및 p소수이며,이 꼬이며 괄호 이항 계수 .

명세서

이후:

여기서 괄호 안의 것은 이항 계수 입니다.

당신은 가정 할 수 있습니다 2b <= a

테스트 케이스

a b p  output
6 2 5  240360
3 1 13 3697053
7 3 13 37403621741662802118325

하스켈, 73 71 바이트

재귀로 인해이 구현은 매우 느립니다. 불행히도 이항 계수의 정의는 길이와 같습니다 import Math.Combinatorics.Exact.Binomial.

n#k|k<1||k>=n=1|1>0=(n-1)#(k-1)+(n-1)#k --binomial coefficient
f a b p=div((a*p)#(b*p)-a#b)p^3       --given formula

흥미로운 이상한 점은 Haskell 98이 동일한 코드를 64 바이트로 단축 한 산술 패턴 을 허용 한다는 것입니다.

g a b p=div((a*p)#(b*p)-a#b)p^3
n+1#k|k<1||k>n=1|1>0=n#(k-1)+n#k

젤리 , 12 11 10 바이트

ż×c/I÷S÷²}

기대 a, b와 p명령 줄 인수로.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

ż×c/I÷S÷²}  Main link. Left argument: a, b. Right argument: p

 ×          Multiply; yield [pa, pb].
ż           Zipwith; yield [[a, pa], [b, pb]].
  c/        Reduce columns by combinations, yielding [aCb, (pa)C(pb)].
    I       Increments; yield [(pa)C(pb) - aCb].
     ÷      Divide; yield [((pa)C(pb) - aCb) ÷ p].
      S     Sum; yield ((pa)C(pb) - aCb) ÷ p.
        ²}  Square right; yield p².
       ÷    Divide; yield  ((pa)C(pb) - aCb) ÷ p³.

파이썬 2 114 109 85 71 바이트

간단한 구현. 골프 제안을 환영합니다.

편집 : Leaky Nun 덕분에 -29 바이트, Dennis 덕분에 -14 바이트.

lambda a,b,p,f=lambda n,m:m<1or f(n-1,m-1)*n/m:(f(a*p,b*p)-f(a,b))/p**3

Dennis 덕분에 더 간단하고 동일한 길이의 대안이 있습니다.

f=lambda n,m:m<1or f(n-1,m-1)*n/m
lambda a,b,p:(f(a*p,b*p)-f(a,b))/p**3

05AB1E , 11 바이트

다음과 같이 입력을받습니다.

[a, b]
p

암호:

*`c¹`c-²3m÷

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! .

R, 50 48 바이트

function(a,b,p)(choose(a*p,b*p)-choose(a,b))/p^3

가능한 한 간단합니다 ... 2 바이트를 절약 한 @Neil에게 감사드립니다.

MATL , 13 바이트

y*hZ}Xnd2G3^/

온라인으로 사용해보십시오!

마지막 테스트 사례는 숫자 정밀도로 인해 정확한 정수를 생성하지 않습니다. MATL의 기본 데이터 유형 (double )은 최대 정확한 정수만 처리 할 수 ​​있습니다 2^53.

설명

y   % Implicitly input [a; b] (col vector) and p (number). Push another copy of [a; b]
    %   Stack: [a; b], p, [a; b]
*   % Multiply the top two elements from the stack
    %   Stack: [a; b], [a*p; b*p]
h   % Concatenate horizontally
    %   Stack: [a, a*p; b, b*p]
Z}  % Split along first dimension
    %   Stack: [a, a*p], [b, b*p]
Xn  % Vectorize nchoosek
    %   Stack: [nchoosek(a,b), nchoosek(a*p,b*p)]
d   % Consecutive differences of array
    %   Stack: nchoosek(a,b)-nchoosek(a*p,b*p)
2G  % Push second input again
    %   Stack: nchoosek(a,b)-nchoosek(a*p,b*p), p
3^  % Raise to third power
    %   Stack: nchoosek(a,b)-nchoosek(a*p,b*p), p^3
/   % Divide top two elements from the stack
    %   Stack: (nchoosek(a,b)-nchoosek(a*p,b*p))/p^3
    % Implicitly display

J, 17 바이트

(!/@:*-!/@[)%]^3:

용법

(b,a) ( (!/@:*-!/@[)%]^3: ) p

예를 들면 다음과 같습니다.

   2 6 ( (!/@:*-!/@[)%]^3: ) 5
240360

이것은 지금까지 공식을 직접 구현 한 것입니다.

참고 : 세 번째 테스트 케이스의 경우 입력 숫자를 확장 으로 정의해야합니다 (큰 산술 처리).

   3x 7x ( (!/@:*-!/@[)%]^3: ) 13x
37403621741662802118325

Brachylog , 52 바이트

tT;T P&t^₃D&h↰₁S&h;Pz×₎ᵐ↰₁;S-;D/
hḟF&⟨{-ḟ}×{tḟ}⟩;F↻/

온라인으로 사용해보십시오!

입력을 받아들 [[a, b], p]입니다.

% Predicate 1 - Given [n, r], return binomial(n, r)
hḟF              % Compute n!, set as F
&⟨               % Fork:
  {-ḟ}           % (n - r)!
  ×              % times
  {tḟ}           % r!
⟩                
;F↻              % Prepend n! to that
/                % Divide n! by the product and return

% Predicate 0 (Main)
tT;T P           % Set P to the array [p, p] 
&t^₃D            % Set D as p^3
&h↰₁S            % Call predicate 1 on [a, b], 
                 %  set S as the result binomial(a, b)
&h;Pz×₎ᵐ         % Form array [ap, bp]
↰₁               % Call predicate 1 on that to get binomial(ap, bp)
;S-              % Get binomial(ap, bp) - binomial(a, b)
;D/              % Divide that by the denominator term p^3
                 % Implicit output

SciPy가 포함 된 Python 3 , 72 바이트

from scipy.special import*
lambda a,b,p:(binom(a*p,b*p)-binom(a,b))/p**3

인수를 통해 입력을 받아 결과를 반환하는 익명 함수입니다.

여기에는 많은 일이 없습니다. 이것은 원하는 계산을 직접 구현 한 것입니다.

Ideone에서 시도하십시오 (마지막 테스트 사례에 대한 결과는 지수 표기법으로 반환됩니다)

Nim , 85 82 75 59 바이트

import math,future
(a,b,p)=>(binom(a*p,b*p)-binom(a,b))/p^3

이것은 익명의 절차입니다. 이를 사용하려면 다른 프로 시저에 인수로 전달하여이를 인쇄해야합니다. 테스트에 사용할 수있는 전체 프로그램은 다음과 같습니다.

import math,future
proc test(x: (int, int, int) -> float) =
 echo x(3, 1, 13) # substitute in your input or read from STDIN
test((a,b,p)=>(binom(a*p,b*p)-binom(a,b))/p^3)

Nim의 math모듈 binomproc은 두 인수의 이항 계수를 계산합니다.

파이썬 2 , 67 바이트

def f(a,b,p):B=2<<a*p;R=(B+1)**a;print(R**p/B**(p*b)-R/B**b)%B/p**3

온라인으로 사용해보십시오!

이 방법을 사용하여 이항 계수를 산술적으로 표현합니다 .

자바 스크립트 (ES6), 70 바이트

(a,b,p,c=(a,b)=>a==b|!b||c(--a,b)+c(a,--b))=>(c(a*p,b*p)-c(a,b))/p/p/p

ES7을 사용하여 1 바이트를 절약하십시오 ( /p**3대신에 /p/p/p).

APL (Dyalog) , 18 바이트

{(-/!/¨⍺1×⊂⍵)÷⍺*3}

온라인으로 사용해보십시오!

Pari / GP , 43 바이트

(a,b,p)->((c=binomial)(a*p,b*p)-c(a,b))/p^3

온라인으로 사용해보십시오!