अपने कोड का पुन: उपयोग करें!

Question

इस चुनौती में हम एक साथ दो महत्वपूर्ण समस्याओं को हल करने का प्रयास करते हैं। वो हैं:

1. पूर्णांक a और b को देखते हुए , बताएं कि ^b -1 एक अभाज्य संख्या है।
2. पूर्णांक a और b को देखते हुए , nCr (a, b) लौटाते हैं ।

विशेष रूप से, आपको दो प्रोग्राम लिखना चाहिए, एक जो पहला कार्य करता है और दूसरा जो करता है। जैसा कि हम एक ही बार में दोनों समस्याओं को हल करना चाहते हैं, यह दोनों कार्यक्रमों में एक ही कोड का उपयोग करने के लिए प्रोत्साहित किया जाता है।

स्कोरिंग

एक उत्तर का स्कोर दो कार्यक्रमों के बीच लेवेन्सहाइट दूरी है। लोअर स्कोर बेहतर है। एक टाई के मामले में, दो कार्यक्रमों के सबसे छोटे संयुक्त कोड के साथ उत्तर जीतता है। आप अपने समाधान के स्कोर की गणना करने के लिए इस स्क्रिप्ट का उपयोग कर सकते हैं।

नियम

1. आपको एक ही भाषा में दो कार्यक्रम लिखने होंगे जो ऊपर वर्णित कार्यों को हल करते हैं। आप अपनी इच्छानुसार किसी भी I / O विधियों का उपयोग कर सकते हैं। कार्य 1 के लिए, आप एक सत्य / झूठे मूल्य को वापस कर सकते हैं या सही और गलत का अर्थ करने के लिए दो मान चुन सकते हैं और तदनुसार उन्हें वापस कर सकते हैं। उदाहरण के लिए। आप इसे चुन सकते हैं"prime" इसका मतलब सही है और "not prime"गलत का मतलब है।
2. आपके द्वारा उपयोग किए जाने वाले एल्गोरिदम सभी संभावित इनपुट के लिए काम करना चाहिए, लेकिन यह ठीक है यदि कोड प्रयुक्त संख्या प्रकार की सीमाओं के कारण बड़ी संख्या में विफल रहता है। आप मान सकते हैं कि इनपुट वैध है।

3. कार्यक्रम का कोई सबसेट समस्या को हल नहीं करना चाहिए, अर्थात। यदि कोई वर्ण हटा दिया गया है तो कोड को काम नहीं करना चाहिए। उदाहरण के लिए, निम्न कोड मान्य नहीं है, क्योंकि प्रोग्राम को तोड़े बिना अप्रयुक्त-ब्लॉक को निकालना संभव है:

   if (1) { /* change to 0 to get the second program*/
       ...
   } else {
       ...
   }
   

4. मानक खामियों की अनुमति नहीं है।

परीक्षण के मामलों

एक ^ख -1 प्रधानमंत्री है?

a b
1 1 false
2 3 true
5 2 false
2 5 true
4 3 false
2 7 true

nCr

a b nCr(a,b)
1 1 1
5 2 10
4 3 4
10 7 120
12 5 792

Comments

लेवेंसहाइट दूरी की गणना करने के लिए यह आसान हो सकता है

— लुइस मेंडो

विचार अच्छा है, लेकिन मुझे लगता है कि आप अभी भी लेवेंसहाइट दूरी 1 के साथ समाधान प्राप्त करेंगे जो अप्रयुक्त भागों में संशोधन को एक तरह से या किसी अन्य तरीके से रोकने के लिए प्रबंधन करते हैं और फिर प्रभावी ढंग से उस संरचना में परिणामित करते हैं जिसे आप निषिद्ध करना चाहते हैं।

— मार्टिन एंडर

@LuisMendo मुद्दा यह है कि उन समाधानों में से कई वास्तव में धीमी हैं। आप इसके बजाय इस मैथिक्स स्क्रिप्ट का उपयोग कर सकते हैं।

— मार्टिन एंडर

मुझे लगता है कि दो कार्यक्रमों की कुल लंबाई से विभाजित एक बेहतर मीट्रिक लेवेंसाइटिन दूरी होगी।

— ग्रेग मार्टिन

@GregMartin कोड गेंदबाजी में परिणाम नहीं होगा? कृत्रिम रूप से कार्यक्रमों को बड़ा बनाना संभव है और फिर भी यह दावा करते हैं कि उनके पास कोई अनावश्यक कोड नहीं है।

— फर्ग्यूसक

Answer 1

MATLAB, दूरी 10

primality:

function x=f(a,b);x=isprime(a^b-1);

nCr:

function x=f(a,b);x=nchoosek(a,b);

Comments

वह अंतर्निहित मैं खोज रहा था!

— कृति लिथोस

Answer 2

PHP, दूरी 29

a^b-1 प्रिंट 0 के लिए सच है और किसी भी पूर्णांक मान> 0 के लिए गलत है

[,$a,$b]=$argv;for($c=-$i=1;$i<=$d=$a**$b-1;$d%++$i?:$c++);echo$c;

nCr(a,b)

[,$a,$b]=$argv;for($c=$i=1;$i<=$a;$c*=$i**(1-($i<=$a-$b)-($i<=$b)),$i++);echo$c;

PHP, दूरी 36

a^b-1 झूठे के लिए सच्चा कुछ नहीं के लिए 1 प्रिंट

[,$a,$b]=$argv;for($c=-1,$i=1;$i<=$d=-1+$a**$b;)$d%++$i?:$c++;echo$c<1;

nCr(a,b)

[,$a,$b]=$argv;for($c=$d=$i=1;$i<=$a;$c*=$i++)$d*=$i**(($i<=$a-$b)+($i<=$b));echo$c/$d;

Answer 3

रूबी, दूरी 1, संयुक्त लंबाई 194

प्रधान जाँच:

->a,b{s='[(a**b-1).prime?,(1..b).inject(1){|m,i|(a+1-i)/i*m}][0]';require'math'<<s.size*2;eval s}

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

nCr:

->a,b{s='[(a**b-1).prime?,(1..b).inject(1){|m,i|(a+1-i)/i*m}][1]';require'math'<<s.size*2;eval s}

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

जैसा कि टिप्पणियों में अनुमान लगाया गया है, कुछ झटका हमेशा समस्या की भावना के खिलाफ जाना पड़ता है। हालांकि इसके आसपास काम करने का एक तरीका था, यह मजेदार था! यहां बताया गया है कि यह कैसे काम करता है: हमारे पास समस्याओं के दो अलग-अलग समाधान हैं। हम दोनों चलाते हैं, उन्हें एक सरणी में रखते हैं, और फिर या तो 0 तत्व या 1 का चयन करते हैं, 1 की संपादित दूरी के लिए। यह आमतौर पर अवैध होगा, क्योंकि आप बस सब कुछ हटा सकते हैं लेकिन गणना आप चाहते थे और यह अभी भी काम करेगा। । हालाँकि, प्रत्येक कोड स्निपेट को उसी मानक लाइब्रेरी के लोडिंग पर भरोसा करने के लिए लिखा गया है 'mathn':

• पहले अपने बिलिन का उपयोग करता है prime?
• दूसरा यह mathnबदलने पर निर्भर करता है कि विभाजन कैसे काम करता है - इसे लोड करने से पहले, इसका 3/4मूल्यांकन करता है 0, जबकि बाद में यह अंश का मूल्यांकन करता है (3/4)। चूंकि मध्यवर्ती परिणाम (a+1-i)/iहमेशा एक पूरी संख्या नहीं होती है, इसलिए समग्र परिणाम पुस्तकालय के बिना गलत होता है।

अब हमें बस लाइब्रेरी को लोड करने की आवश्यकता है, बाकी कोड अनधिकृत होने के कारण। हम शेष मुख्य कोड के चरित्र की लंबाई का उपयोग करके मैथन नाम उत्पन्न करके ऐसा करते हैं: संयुक्त गणना की लंबाई 55 है, जो कि दोगुनी 110 है जो 'n' का ASCII मान है। इसलिए इसे स्ट्रिंग 'गणित' पर संक्षिप्त करने से वांछित पुस्तकालय मिलता है।

एक बोनस के रूप में, पुस्तकालय निर्भरता का परिचय भी उचित समय में कोड को चलाता है। विशेष रूप से, nCr के लिए भोली दृष्टिकोण भिन्नात्मक मध्यवर्ती परिणाम उत्पन्न नहीं करेगा।

Answer 4

05AB1E , दूरी 3

nCr

sc

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

isPrime (एक ^ बी 1)

m<p

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

Answer 5

ढेर , दूरी १३

[([@.!]$/{%y!x y-!*})fork!]
[^#-:([]1/$%{!n 1-!})fork!=]

इसे ऑनलाइन आज़माएं! विल्सन के प्रमेय का उपयोग करते हुए, पहला nCr, दूसरा परिमल की गणना करता है।

(f g h) fork!Nस्टैक से चबूतरे आ जाते हैं (उन्हें कॉल करें a0 ... aN) और लागू होता है a0 ... aN f a0 ... aN h g।

पहले कार्यक्रम के लिए:

[([@.!]$/{%y!x y-!*})fork!]
[(                  )fork!]  apply the fork of:
  [@.!]                      equiv. { x y : x ! } => `x!`
       $/                    divided by
         {%        }         two-arg function
           y!                y!
             x y-                 (x - y)!
                 *              *

और दूसरे के लिए:

[^#-:([]1/$%{!n 1-!})fork!=]  
[^                         ]  exponentiate  (a^b)
  #-                          decrement     (a^b-1)
    :                         duplicate     (a^b-1 a^b-1)
     (              )fork!    apply the fork to:
      []1/                    1-arg identity function
          $%                  modulus by
            {!     }          1-arg with `n`:
              n 1-             (n-1)
                  !                 !
                          =   check for equality

Answer 6

अजगर 2 , दूरी 15 , लंबाई 172

कार्य 1

D=lambda k:max(k-1,1)
P=lambda n,k=0:n<k or P(n-1,k)*n/k
lambda a,b:P(a**b-2)**2%D(a**b)

टास्क २

D=lambda k:max(k-1,1)
P=lambda n,k=1:n<k or P(n-1,D(k))*n/k
lambda a,b:P(a,b)/P(a-b)

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

Answer 7

गणितज्ञ, दूरी १०

कार्य 1: PrimeQ[#2^#-1]&

कार्य 2: Binomial[#2,#]&

दोनों कार्य क्रम में इनपुट लेते हैं b,a।

Answer 8

जावास्क्रिप्ट ईएस 7, दूरी 14

धन्यवाद @Conor O'Brien द्वारा दूरी 7 से कम करने के लिए

primality:

f=x=>y=>{t=x**y-1;s=1;for(i=2;i<t;i++){if(!t%i)s=i-i}return s}

यदि 1 अभाज्य नहीं है तो 1 प्रतिफल देता है।

अविश्वसनीय रूप से अक्षम मुख्य जांच, संख्या modulo को हर संख्या की तुलना में छोटा और 1 से अधिक जांचता है ...

nCr:

f=x=>y=>{t=x+1;s=1;for(i=1;i<t;i++){if(y<i)s*=i/(i-y)}return s}

प्रत्येक संख्या को y + 1 से x तक गुणा करें और प्रत्येक संख्या से 1 से xy (x / y!) / / (Xy) में विभाजित करें!

Comments

f=x=>y=>{t=x+1;s=1;for(i=1;i<t;i++){if(y<i)s*=i/(i-y)}return s}संपादित दूरी देने के लिए दूसरा कार्यक्रम बदलना 14. ऑनलाइन प्रयास करें!

— कॉनर ओ'ब्रायन

Answer 9

अष्टक, दूरी १ 17 16 15

nCr

a=input("");b=input("");f=@(x)factorial(x);printf("%d",f(a)/f(b)/f(a-b))

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

isprime(a^b-1)

a=input("");b=input("");f=@(x)isprime(x);printf("%d",f(a^b-f(8-6)))

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

मैं ऑक्टेव में बहुत धाराप्रवाह नहीं हूं, इसलिए मुझे नहीं पता कि क्या एनसीआर की गणना करने के लिए एक बिलिन है।

Answer 10

Matl , दूरी 4, लंबाई 6

बताओ अगर a^b-1प्रधान है:

^qZq

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

गणना nCr(a,b):

Xn

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

यह काम किस प्रकार करता है

बताओ अगर a^b-1प्रधान है:

^      % Power with implicit inputs
q      % Subtract 1
Zq     % Is prime? Implicit display

गणना nCr(a,b):

Xn     % nchoosek with implicit inputs. Implicit display

Answer 11

अजगर, दूरी 4, कुल लंबाई 8

की प्रधानता a^b-1

P_t^F

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

nCr (ए, बी)

.cF

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

दोनों इनपुट्स को पूर्णांक / पूर्णांकों की सूची (जैसे (1,2)) के रूप में लेते हैं ।

Answer 12

PHP, दूरी 14

दो कार्यों के साथ एक कार्यक्रम लिखना और केवल उनमें से एक को कॉल करने से 1 की दूरी हो जाएगी, लेकिन यह बहुत अधिक लंगड़ा होगा।

प्राइम टेस्ट, 100 बाइट्स:

[,$a,$b]=$argv;function f($n){for($i=$n;--$i>0&&$n%$i;);return$i==1;}echo f($a**$b*-1)*(1|f($a-$b));

nCr, 98 बाइट्स:

[,$a,$b]=$argv;function f($n){for($i=$n;--$i>0&&$n*=$i;);return$n*=1;}echo f($a)/(f($b)*f($a-$b));

Answer 13

जेली , दूरी 4, लंबाई 5

कार्य 1

*’ÆP

टास्क २

c

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

यह काम किस प्रकार करता है

कार्य 1

*’ÆP  Main link. Argument: a, b

*     Yield a**b.
 ’    Decrement; yield a**b-1.
  ÆP  Test the result for primality.

टास्क २

c     nCr atom

Answer 14

जावास्क्रिप्ट, स्कोर: 1, लंबाई: 144 142 126 117

function(a,b){s="a=Math.pow(a,b)-t;for(b=2;a%b++;);b>a1for(;b;)t=t*a--/b--";t=s.length-56;return eval(s.split(1)[0])}

समारोह (ए, बी) {s = "एक = Math.pow (क, ख) -s.length + 79; b> a1for (टी = s.length-79; (; एक% ख ++, बी = 2) ; b;) t = t * a - / b - "; वापसी eval (s.plplit (1) [1]}}

function A(a,b){a=Math.pow(a,b)-(B+0).length+63;for(b=2;a%b++;);return b>a;}
function B(a,b){for(t=(A+0).length-76;b;)t=t*a--/b--;return t;}
F=A

दोनों उप-रेखाएं अपने स्वयं के निरंतर की गणना करने के लिए दूसरे की लंबाई का उपयोग करती हैं, इसलिए किसी भी चार को नहीं हटाया जा सकता है