Định nghĩa

Định lý của Wolstenholme nói rằng:

trong đó avà blà các số nguyên dương và plà số nguyên tố, và dấu ngoặc đơn lớn là hệ số Binomial .

Bài tập

Để xác minh điều đó, bạn sẽ được cung cấp ba đầu vào: a, b, p, nơi avà blà nguyên dương và plà số nguyên tố.

Tính toán:

trong đó avà blà các số nguyên dương và plà số nguyên tố, và dấu ngoặc đơn là hệ số nhị thức .

Thông số kỹ thuật

Từ:

trong đó và dấu ngoặc đơn là hệ số Binomial .

Bạn có thể cho rằng 2b <= a

Tủ thử

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

Haskell, 73 71 byte

Do sự đệ quy, việc thực hiện này rất chậm. Thật không may, định nghĩa của tôi về hệ số nhị thức có cùng độ dài với 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

Một điều kỳ lạ thú vị là Haskell 98 đã cho phép các mẫu số học có thể rút ngắn cùng một mã thành 64 byte:

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

Thạch , 12 11 10 byte

ż×c/I÷S÷²}

Mong đợi a, bvà pnhư là đối số dòng lệnh.

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

ż×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³.

Python 2, 114 109 85 71 byte

Một cách thực hiện đơn giản. Gợi ý chơi golf chào mừng.

Chỉnh sửa: -29 byte nhờ Leaky Nun và -14 byte nhờ Dennis.

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

Một sự thay thế đơn giản hơn, có cùng độ dài, nhờ có Dennis, là

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 byte

Đưa đầu vào là:

[a, b]
p

Mã số:

*`c¹`c-²3m÷

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

R, 50 48 byte

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

Đơn giản nhất có thể ... Cảm ơn @Neil vì đã lưu 2 byte.

MATL , 13 byte

y*hZ}Xnd2G3^/

Hãy thử trực tuyến!

Trường hợp kiểm tra cuối cùng không tạo ra một số nguyên chính xác do độ chính xác bằng số. Kiểu dữ liệu mặc định của MATL ( double) chỉ có thể xử lý các số nguyên chính xác tối đa 2^53.

Giải trình

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 byte

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

Sử dụng

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

Ví dụ:

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

Đây chỉ là một thực hiện trực tiếp của công thức cho đến nay.

Lưu ý : đối với các số đầu vào của testcase thứ 3 phải được xác định là mở rộng (để xử lý số học lớn):

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

Brachylog , 52 byte

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

Hãy thử trực tuyến!

Chấp nhận đầu vào [[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

Python 3 với SciPy , 72 byte

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

Một hàm ẩn danh nhận đầu vào thông qua đối số và trả về kết quả.

Không có nhiều thứ đang diễn ra ở đây; đây là một thực hiện trực tiếp của tính toán mong muốn.

Hãy thử trên Ideone (kết quả được trả về theo ký hiệu số mũ cho trường hợp thử nghiệm cuối cùng)

Nim , 85 82 75 59 byte

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

Đây là một thủ tục ẩn danh; để sử dụng nó, nó phải được chuyển như một đối số cho một thủ tục khác, nó in nó. Một chương trình đầy đủ có thể được sử dụng để thử nghiệm được đưa ra dưới đây

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)

Proc mathcủa mô-đun Nim binomtính hệ số nhị thức của hai đối số của nó.

Python 2 , 67 byte

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

Hãy thử trực tuyến!

Biểu thị các hệ số nhị thức một cách hợp lý bằng phương pháp này .

JavaScript (ES6), 70 byte

(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

Lưu 1 byte bằng cách sử dụng ES7 ( /p**3thay vì /p/p/p).

APL (Dyalog) , 18 byte

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

Hãy thử trực tuyến!

Pari / GP , 43 byte

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

Hãy thử trực tuyến!