10

चीनी अवशेष प्रमेय मॉड्यूलर अंकगणित में काफी उपयोगी हो सकता है।

उदाहरण के लिए, बधाई संबंधों के निम्नलिखित सेट पर विचार करें:

इस तरह के संबंध संबंधों के सेट के लिए, जहां सभी आधार ( 3, 5, 7इस उदाहरण में) एक - दूसरे के साथ सह-प्रधान होते हैं, एक और केवल एक पूर्णांक के nबीच 1और आधार के उत्पाद ( 3*5*7 = 105इस उदाहरण में) समावेशी होते हैं जो संबंधों को संतुष्ट करते हैं ।

इस उदाहरण में, संख्या 14इस सूत्र द्वारा उत्पन्न होगी :

2, 4, and 0उपरोक्त उदाहरण से कहां दिए गए हैं।

70, 21, 15कर रहे हैं गुणांक सूत्र के, और वे ठिकानों पर निर्भर हैं 3, 5, 7।

70, 21, 15आधारों के एक सेट के लिए सूत्र के गुणांक ( हमारे उदाहरण में) की गणना करने के लिए, हम निम्नलिखित प्रक्रिया का उपयोग करते हैं।

aठिकानों के सेट में प्रत्येक संख्या के लिए :

अन्य सभी ठिकानों के उत्पाद का पता लगाएं, जैसा कि दर्शाया गया है P।
विभाजित होने पर Pशेष का पहला 1गुण प्राप्त करें a। यह गुणांक है a।

उदाहरण के लिए, गुणांक जो आधार से मेल खाती है, की गणना करने के लिए 3, हम अन्य सभी ठिकानों (यानी 5*7 = 35) के उत्पाद को खोजते हैं और फिर उस उत्पाद के पहले एकाधिक को ढूंढते हैं 1जो आधार द्वारा विभाजित होने पर शेष बचता है ।

इस मामले में, 35के शेष छोड़ देता है 2जब से विभाजित 3है, लेकिन 35*2 = 70पत्तों का एक शेष 1जब से विभाजित 3है, तो 70के लिए इसी गुणांक है 3। इसी तरह, जब 3*7 = 21शेष भाग से 1विभाजित होता है 5और 3*5 = 15शेष को छोड़ देता है, 1जब विभाजित होता है 7।

संक्षेप में

aसंख्याओं के समूह में प्रत्येक संख्या के लिए :

अन्य सभी संख्याओं का गुणनफल ज्ञात कीजिए, जैसा कि निरूपित है P।
विभाजित होने पर Pशेष का पहला 1गुण प्राप्त करें a। यह गुणांक है a।

चुनौती

इसी गुणांक के समुच्चय को खोजने के लिए दो या दो से अधिक ठिकानों के लिए चुनौती है।
आधारों के सेट को जोड़ीदार-प्रधान होने की गारंटी है और प्रत्येक आधार 1 से बड़ा होने की गारंटी है।
आपका इनपुट इनपुट [3,4,5]या स्पेस-अलग-अलग स्ट्रिंग के रूप में पूर्णांकों की एक सूची है "3 4 5"या हालांकि आपके इनपुट काम करते हैं।
आपका आउटपुट या तो पूर्णांक या अंतरिक्ष-पृथक स्ट्रिंग की सूची होनी चाहिए जो गुणांक के सेट को दर्शाता है।

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

input             output
[3,5,7]           [70,21,15]
[2,3,5]           [15,10,6]
[3,4,5]           [40,45,36]
[3,4]             [4,9]
[2,3,5,7]         [105,70,126,120]
[40,27,11]        [9801,7480,6480]
[100,27,31]       [61101,49600,56700]
[16,27,25,49,11]  [363825,2371600,2794176,5583600,529200]

इस चुनौती को लिखने में उनकी मदद के लिए लीक नून को बहुत धन्यवाद। हमेशा की तरह, अगर समस्या स्पष्ट नहीं है, तो कृपया मुझे बताएं। गुड लक और गुड गोल्फिंग!

code-golf math

— Sherlock9
स्रोत

क्या इनपुट में हमेशा 3 नंबर होंगे?

— xnor

@ एक्सनोर नोप। परीक्षण के मामले संपादित किए गए।

— शर्लक 9

5

हास्केल, 61 55 53 बाइट्स

f x=[[p|p<-[0,product x`div`n..],p`mod`n==1]!!0|n<-x]

एक फ़ंक्शन को परिभाषित करता है fजो इनपुट लेता है और पूर्णांक की सूची के रूप में आउटपुट देता है।

f x=[                                          |n<-x]  (1)
              product x                                (2)
                       `div`n                          (3)

पहले हम इनपुट (1) में सभी पूर्णांकों पर लूप करते हैं। फिर हम सभी पूर्णांकों (2) के उत्पाद लेते हैं और n के nपूर्णांक के उत्पाद को प्राप्त करने के लिए n से विभाजित करते हैं, जो P(3) है।

           [0,               ..]                       (4)
     [p|p<-                     ,p`mod`n==1]           (5)
                                            !!0        (6)

तब हम परिणाम ( P) को शून्य (4) से शुरू होने वाली श्रेणी के लिए चरण मान के रूप में उपयोग करते हैं । हम परिणाम लेते हैं [0, P, 2P, 3P, ...], और इसे उन मानों पर फ़िल्टर करते हैं जिनके लिए एक मॉड-एन ऑपरेशन का परिणाम एक (5) है। अंत में, हम पहला तत्व लेते हैं, जो आलसी मूल्यांकन (6) के लिए धन्यवाद काम करता है।

2 बाइट्स के लिए @xnor को धन्यवाद !

— Doorknob
स्रोत

1

Haskell में आपका स्वागत है! मुझे लगता है कि आपका quotएक हो सकता है div, और headहो सकता है !!0।

— xnor

4

जेली , 11 7 बाइट्स

P:*ÆṪ%P

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

Let पी और एक कड़ाई से सकारात्मक, हो coprime पूर्णांकों।

प्रश्न में दो-चरणीय प्रक्रिया - पी के एक बहु को खोजना जो 1 के शेष भाग को छोड़ देता है जब ए द्वारा विभाजित किया जाता है - इसे निम्नलिखित अनुरूपता समीकरण द्वारा वर्णित किया जा सकता है।

रेखीय सर्वांगसम समीकरण

द्वारा यूलर-फर्मेट प्रमेय , हमारे पास है

यूलर-फरमेट प्रमेय

जहां φ यूलर के कुल कार्य को दर्शाता है । इस परिणाम से, हम निम्नलिखित घटाते हैं।

रैखिक सर्वांगसम समीकरण के लिए सूत्र

अंत में, चूंकि चुनौती के लिए हमें Px की गणना करने की आवश्यकता है , इसलिए हम इसका पालन करते हैं

अंतिम परिणाम के लिए सूत्र

जहां पा को सभी मॉडुली के उत्पाद के रूप में गणना की जा सकती है।

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

P:*ÆṪ%P  Main link. Argument: A (list of moduli)

P        Yield the product of all moduli.
 :       Divide the product by each modulus in A.
   ÆṪ    Apply Euler's totient function to each modulus.
  *      Raise each quotient to the totient of its denominator.
     %P  Compute the remainder of the powers and the product of all moduli.

— डेनिस
स्रोत

2

जे, 13 बाइट्स

*/|5&p:^~*/%]

@ डेनिस के अद्भुत जवाब पर आधारित ।

प्रयोग

कुछ परीक्षण मामलों को विस्तारित पूर्णांक के रूप में इनपुट की आवश्यकता होगी, जिसमें एक प्रत्यय है x।

   f =: */|5&p:^~*/%]
   f 3 5 7
70 21 15
   f 40x 27 11
9801 7480 6480
   f 16x 27 25 49 11
363825 2371600 2794176 5583600 529200

व्याख्या

*/|5&p:^~*/%]  Input: list B
         */    Reduce B using multiplication to get the product of the values
            ]  Identity function, get B
           %   Divide the product by each value in B, call the result M
   5&p:        Apply the totient function to each value in B, call the result P
       ^~      Raise each value in M to the power of its corresponding value in P
*/             The product of the values in B
  |            Compute each power modulo the product and return

इसे यहाँ आज़माएँ।

— मील की दूरी पर
स्रोत

2

गणितज्ञ, 27 बाइट्स

PowerMod[a=LCM@@#/#,-1,#]a&

— alephalpha
स्रोत

1

अजगर , 14 बाइट्स

mhfq1%Td*R/*FQ

परीक्षण सूट।

एल्गोरिथ्म के Naive कार्यान्वयन।

— लीक नन
स्रोत

1

जेली, 14 13 बाइट्स

P:×"Ḷð%"’¬æ.ḷ

@ डेनिस को एक बाइट धन्यवाद दिया !

चुनौती युक्ति में वर्णित प्रक्रिया का उपयोग करता है। इनपुट आधारों की एक सूची है और आउटपुट गुणांक की एक सूची है।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

P:×"Ḷð%"’¬æ.ḷ  Input: a list B
P              Get the product of the list
 :             Divide it by each value in the B, call it M
    Ḷ          Get a range from 0 to k for k in B
  ×"           Vectorized multiply, find the multiples of each M
     ð         Start a new dyadic chain. Input: multiples of M and B
      %"       Vectorized modulo, find the remainders of each multiple by B
        ’      Decrement every value
               If the remainder was 1, decrementing would make it 0
         ¬     Logical NOT, zeros become one and everything else becomes 0
            ḷ  Get the multiples of M
          æ.   Find the dot product between the modified remainders and the multiples
               Return

— मील की दूरी पर
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 80 बाइट्स

a.map(e=>[...Array(e).keys()].find(i=>p*i/e%e==1)*p/e,p=a.reduce((i,j)=>i*j))

मैंने विस्तारित यूक्लिडियन एल्गोरिथ्म की कोशिश की, लेकिन इसमें 98 बाइट्स लगते हैं:

a=>a.map(e=>(r(e,p/e)+e)%e*p/e,p=a.reduce((i,j)=>i*j),r=(a,b,o=0,l=1)=>b?r(b,a%b,t,o-l*(a/b|0)):o)

यदि मान सभी प्रमुख हैं, तो ES7 56 बाइट्स में कर सकता है:

a=>a.map(e=>(p/e%e)**(e-2)%e*p/e,p=a.reduce((i,j)=>i*j))

— नील
स्रोत

1

पायथन + सिम्पी, 71 बाइट्स

from sympy import*
lambda x:[(prod(x)/n)**totient(n)%prod(x)for n in x]

यह मेरे जेली उत्तर से एल्गोरिथ्म का उपयोग करता है । I / O SymPy नंबरों की सूचियों के रूप में है।

— डेनिस
स्रोत

1

पायथन 2, 87 84 बाइट्स

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

a=input();p=1
for i in a:p*=i
print[p/i*j for i in a for j in range(i)if p/i*j%i==1]

— Sherlock9
स्रोत

एक पूर्ण कार्यक्रम 3 बाइट्स को बचाएगा।

— डेनिस

1

चेडर , 64 बाइट्स

n->n.map(i->(|>i).map(j->(k->k%i>1?0:k)(n.reduce((*))/i*j)).sum)

— लीक नन
स्रोत

मैं एक जोड़ना चाहिए .productजो करता .reduce((*))सरणियों के लिए ...

— Downgoat

0

जीएपी , 51 बाइट्स

जीएपी में एक फ़ंक्शन होता है जो प्रेरक उदाहरण के साथ गणना कर सकता है ChineseRem([2,5,7],[2,4,0]), लेकिन यह अभी भी गुणांक प्राप्त करने में आसान नहीं बनाता है। हम दूसरे तर्क के रूप में अन्य पदों पर n-th स्थिति और शून्य में एक के साथ सूची का उपयोग करके n-वें गुणांक प्राप्त कर सकते हैं। इसलिए हमें इन सूचियों को बनाने और उन सभी पर फ़ंक्शन लागू करने की आवश्यकता है:

l->List(Basis(Integers^Size(l)),b->ChineseRem(l,b))

— क्रिश्चियन सिवर्स
स्रोत

0

बैच, 148 बाइट्स

@set p=%*
@set/ap=%p: =*%
@for %%e in (%*)do @for /l %%i in (1,1,%%e)do @call:l %%e %%i
@exit/b
:l
@set/an=p/%1*%2,r=n%%%1
@if %r%==1 echo %n%

— नील
स्रोत

0

दरअसल, 14 बाइट्स

यह डेनिस के जेली उत्तर में एल्गोरिथ्म का उपयोग करता है । मेरे पायथन उत्तर पर आधारित एक और उत्तर आगामी है। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

;π;)♀\;♂▒@♀ⁿ♀%

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

                 Implicit input a.
;                Duplicate a.
 π;)             Take product() of a, duplicate and rotate to bottom.
    ♀\           Integer divide the product by each element of a. Call this list b.
      ;♂▒        Take that list, duplicate, and get the totient of each element.
         @♀ⁿ     Swap and take pow(<item in b>, <corresponding totient>)
            ♀%   Modulo each item by the remaining duplicate product on the stack.
                 Implicit return.

22 बाइट्स पर मेरे पायथन जवाब के आधार पर एक और जवाब। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

;π╖`╝╛╜\╛r*"╛@%1="£░`M

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

            Implicit input a.
;π╖         Duplicate, take product of a, and save to register 0.
`...`M      Map over a.
  ╝           Save the item, b, in register 1.
  ╛╜\         product(a) // b. Call it P.
  ╛r          Take the range [0...b].
  *           Multiply even item in the range by P. Call this list x.
  "..."£░     Turn a string into a function f.
              Push values of [b] where f returns a truthy value.
    ╛@%         Push b, swap, and push <item in x> % b.
    1=          Does <item> % b == 1?
            Implicit return.

— Sherlock9
स्रोत

बधाई के लिए एक सूत्र

संक्षेप में

चुनौती

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

हास्केल, 61 55 53 बाइट्स

जेली , 11 7 बाइट्स

पृष्ठभूमि

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

जे, 13 बाइट्स

प्रयोग

व्याख्या

गणितज्ञ, 27 बाइट्स

अजगर , 14 बाइट्स

जेली, 14 13 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 80 बाइट्स

पायथन + सिम्पी, 71 बाइट्स

पायथन 2, 87 84 बाइट्स

चेडर , 64 बाइट्स

जीएपी , 51 बाइट्स

बैच, 148 बाइट्स

दरअसल, 14 बाइट्स