Definition

Wolstenholmes Satz besagt:

wo aund bsind positive ganze Zahlen und pist Primzahl, und die großen Klammern Ding ist Binomialkoeffizient .

Aufgabe

Um zu überprüfen, werden Sie drei Eingänge gegeben werden: a, b, p, wo aund bpositive ganze Zahlen und pist eine Primzahl.

Berechnen:

wo aund bsind positive ganze Zahlen und pist Primzahl, und die Klammer Ding ist Binomialkoeffizient .

Technische Daten

Schon seit:

wo und die Klammern Ding ist Binomialkoeffizient .

Das können Sie annehmen 2b <= a

Testfälle

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

Haskell, 73 71 Bytes

Aufgrund der Rekursion ist diese Implementierung sehr langsam. Leider hat meine Definition des Binomialkoeffizienten die gleiche Länge wie 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

Eine interessante Kuriosität ist, dass Haskell 98 arithmetische Muster zuließ, die denselben Code auf 64 Bytes verkürzt hätten:

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

Jelly , 12 11 10 Bytes

ż×c/I÷S÷²}

Erwartet a, bund pals Befehlszeilenargumente.

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

ż×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 Bytes

Eine einfache Implementierung. Golfvorschläge sind willkommen.

Edit: -29 Bytes dank Leaky Nun und -14 Bytes dank 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

Eine einfachere, gleichlange Alternative, dank Dennis, ist

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 Bytes

Übernimmt Eingaben als:

[a, b]
p

Code:

*`c¹`c-²3m÷

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

R 50 48 Bytes

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

So einfach wie möglich ... Vielen Dank an @Neil für das Speichern von 2 Bytes.

MATL , 13 Bytes

y*hZ}Xnd2G3^/

Probieren Sie es online!

Der letzte Testfall liefert aufgrund der numerischen Genauigkeit keine exakte Ganzzahl. Der Standarddatentyp ( double) von MATL kann nur exakte ganze Zahlen bis zu verarbeiten 2^53.

Erläuterung

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 Bytes

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

Verwendung

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

Beispielsweise:

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

Dies ist nur eine direkte Umsetzung der bisherigen Formel.

Hinweis : Für den 3. Testfall müssen die Eingabenummern als erweitert definiert werden (um große Arithmetik zu verarbeiten):

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

Brachylog , 52 Bytes

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

Probieren Sie es online!

Akzeptiert Eingaben [[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 mit SciPy , 72 Bytes

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

Eine anonyme Funktion, die Eingaben über Argumente entgegennimmt und das Ergebnis zurückgibt.

Hier ist nicht viel los; Dies ist eine direkte Implementierung der gewünschten Berechnung.

Probiere es auf Ideone aus (das Ergebnis wird in Exponentialschreibweise für den letzten Testfall zurückgegeben)

Nim , 85 82 75 59 Bytes

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

Dies ist ein anonymes Verfahren. Um es zu verwenden, muss es als Argument an eine andere Prozedur übergeben werden, die es druckt. Ein vollständiges Programm, das zum Testen verwendet werden kann, ist unten angegeben

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)

Nims mathModul binomproc berechnet den Binomialkoeffizienten seiner beiden Argumente.

Python 2 , 67 Bytes

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

Probieren Sie es online!

Drückt die Binomialkoeffizienten mit dieser Methode arithmetisch aus .

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

Speichern Sie 1 Byte mit ES7 ( /p**3anstelle von /p/p/p).

APL (Dyalog) , 18 Bytes

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

Probieren Sie es online!

Pari / GP , 43 Bytes

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

Probieren Sie es online!