वोल्स्टेनहोल के प्रमेय को सत्यापित करें

Question

परिभाषा

वोल्स्टेनहोल के प्रमेय में कहा गया है कि:

कहाँ aऔर bसकारात्मक पूर्णांक हैं और pअभाज्य है, और बड़े कोष्ठक की बात द्विपद गुणांक है ।

कार्य

कि सत्यापित करने के लिए, आप तीन आदानों दिया जाएगा: 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

Comments

मुझे लगता है कि आउटपुट .0के अंत में होना चाहिए , वास्तव में यह दिखाने के लिए कि विभाजन नहीं है।

— एल'एंडिया स्ट्रोमैन

@ El'endiaStarman चलो।

— लीक नून

विल [240360](सिंगलटन सरणी) एक स्वीकार्य आउटपुट प्रारूप होगा?

— डेनिस

मुझे नहीं लगता कि कोई ऐसा है, जिससे मैं पूछ रहा हूं।

— डेनिस

@ डेनिस तो एक बनाओ।

— लीक नन

Answer 1

हास्केल, 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

एक दिलचस्प विचित्रता यह है कि हास्केल 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

Comments

Haskell 98 संस्करण अभी भी एक वैध प्रस्तुत नहीं होना चाहिए?

— माइकल क्लेन

Answer 2

जेली , 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³.

Answer 3

पायथन 2, 114 109 85 71 बाइट्स

एक साधारण कार्यान्वयन। गोल्फ सुझाव का स्वागत करते हैं।

संपादित करें: -29 बाइट्स के लिए धन्यवाद लीक नन और -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

डेनिस के लिए धन्यवाद के साथ एक सरल, समान लंबाई वाला विकल्प है

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

Comments

यहाँ एक golfed भाज्य लैम्ब्डा है

— NonlinearFruit

Answer 4

05AB1E , 11 बाइट्स

इनपुट के रूप में लेता है:

[a, b]
p

कोड:

*`c¹`c-²3m÷

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

Comments

क्या आपने गोल्फ डेनिस को आउट किया?

— लीक नन

अगर मैं डेनिस के जूते में होता तो मुझे लगता कि मैं इन सभी "आउटगोल्फ डेनिस" टिप्पणियों से थोड़ा थक जाता ...

— लुइस

@LuisMendo मैं नियमित रूप से उन्हें नंगा कर सकता हूं या नहीं कर सकता।

— डेनिस

और

— हिचकिचाहट

Answer 5

आर, 50 48 बाइट्स

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

जैसा कि सीधा हो सकता है ... 2 बाइट बचाने के लिए @Neil को धन्यवाद।

Comments

उन स्थानों में से कितने आवश्यक हैं?

— नील

42 बाइट्स का नाम बदलने chooseऔर pryr::fफ़ंक्शन को परिभाषित करने के लिए उपयोग करके B=choose;pryr::f((B(a*p,b*p)-B(a,b))/p^3):।

— रटबर्न

Answer 6

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

Answer 7

जे, 17 बाइट्स

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

प्रयोग

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

उदाहरण के लिए:

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

यह अभी तक फार्मूले का प्रत्यक्ष कार्यान्वयन है।

नोट : 3rd टेस्टकेस इनपुट संख्या के लिए विस्तारित होना चाहिए (बड़ी अंकगणित को संभालने के लिए):

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

Answer 8

ब्रेकीलॉग , 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

Answer 9

साइपाय के साथ पायथन 3 , 72 बाइट्स

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

एक अनाम फ़ंक्शन जो तर्क के माध्यम से इनपुट लेता है और परिणाम देता है।

यहाँ बहुत कुछ नहीं चल रहा है; यह वांछित गणना का प्रत्यक्ष कार्यान्वयन है।

Ideone पर इसे आज़माएं (अंतिम परीक्षण मामले के लिए परिणाम घातीय संकेतन में वापस आ गया है)

Answer 10

निम , 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)

निम के mathमॉड्यूल की खरीद binomइसके दो तर्कों के द्विपद गुणांक की गणना करती है।

Answer 11

पायथन 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

इसे ऑनलाइन आज़माएं!

इस पद्धति का उपयोग करते हुए द्विपद गुणांक को व्यक्त करता है ।

Answer 12

जावास्क्रिप्ट (ईएस 6), 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 (के /p**3बजाय /p/p/p) का उपयोग करके 1 बाइट बचाएं ।

Answer 13

एपीएल (डायलॉग) , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 14

परी / जीपी , 43 बाइट्स

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

इसे ऑनलाइन आज़माएं!