चीनी अवशेष प्रमेय

Question

चीनी अवशेष प्रमेय हमें बताता है कि हम हमेशा एक संख्या पा सकते हैं जो अलग-अलग प्रमुख तरीकों के तहत किसी भी आवश्यक अवशेष का उत्पादन करता है। आपका लक्ष्य बहुपद समय में ऐसी संख्या को आउटपुट करने के लिए कोड लिखना है। सबसे छोटा कोड जीतता है।

उदाहरण के लिए, मान लें कि हमें ये बाधाएँ दी गई हैं ( %मॉड का प्रतिनिधित्व करता है):

n % 7  == 2
n % 5  == 4
n % 11 == 0

एक उपाय है n=44। पहला बाधा संतुष्ट है क्योंकि 44 = 6*7 + 2, और इसलिए 44शेष 2जब विभाजित होता है 7, और इस प्रकार 44 % 7 == 2। अन्य दो बाधाओं को भी पूरा किया जाता है। अन्य समाधान मौजूद हैं, जैसे कि n=814और n=-341।

इनपुट

जोड़े की एक गैर-रिक्त सूची (p_i,a_i), जहां प्रत्येक मापांक p_iएक अलग प्रमुख है और प्रत्येक लक्ष्य a_iसीमा में एक प्राकृतिक संख्या है 0 <= a_i < p_i। जो भी रूप सुविधाजनक है उसमें आप इनपुट ले सकते हैं; यह वास्तव में जोड़े की सूची नहीं है। आप यह नहीं मान सकते हैं कि इनपुट छांटा गया है।

उत्पादन

एक पूर्णांक nजैसे कि n % p_i == a_iप्रत्येक सूचकांक के लिए i। यह इस तरह के सबसे छोटे मूल्य नहीं है, और नकारात्मक हो सकता है।

बहुपद समय प्रतिबंध

सस्ता समाधान है कि बस की कोशिश को रोकने के लिए n=0, n=1, n=2, और इतने पर, अपने कोड बहुपद समय में में चलाना चाहिए इनपुट की लंबाई । ध्यान दें कि mइनपुट में एक संख्या की लंबाई है Θ(log m), इसलिए mस्वयं इसकी लंबाई में बहुपद नहीं है। इसका मतलब यह है कि आप mएक ऑपरेशन के mसमय को गिन या नहीं कर सकते हैं , लेकिन आप मानों पर अंकगणितीय संचालन की गणना कर सकते हैं।

हो सकता है कि आप इसके आस-पास प्राप्त करने के लिए एक अक्षम इनपुट प्रारूप का उपयोग न करें।

अन्य प्रतिबंध

अंतर्निहित इन्स को निम्नलिखित करने की अनुमति नहीं है: चीनी रेमिनेडर प्रमेय को लागू करें, समीकरणों को हल करें, या कारक संख्याएं।

आप मॉड का पता लगाने के लिए बिल्ट-इन का उपयोग कर सकते हैं और मॉड्यूलर जोड़, घटाव, गुणा, और घातांक (प्राकृतिक-संख्या प्रतिपादक के साथ) कर सकते हैं। आप मॉड्यूलर उलटा, विभाजन, और आदेश-खोज सहित अन्य अंतर्निहित मॉड्यूलर संचालन का उपयोग नहीं कर सकते हैं ।

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

ये सबसे छोटा गैर-नकारात्मक समाधान देते हैं। आपका उत्तर अलग हो सकता है। यह शायद बेहतर है यदि आप सीधे जांचते हैं कि आपका आउटपुट प्रत्येक बाधा को संतुष्ट करता है।

[(5, 3)] 
3

[(7, 2), (5, 4), (11, 0)]
44

[(5, 1), (73, 4), (59, 30), (701, 53), (139, 112)]
1770977011

[(982451653, 778102454), (452930477, 133039003)]
68121500720666070

Comments

कोई विभाजन क्यों?

— jimmy23013

@ user23013 कोई मॉड्यूलर विभाजन नहीं है, क्योंकि यह मूल रूप से मॉड्यूलर उलटा है।

— xnor

क्या मैट्रिक्स उलटा समीकरणों को हल करने के रूप में गिना जाता है?

— दोष

@flawr: मुझे ऐसा लगता है।

— एलेक्स ए।

@xnor: आपको क्या लगता है? और अनुकूलन कार्यों के बारे में कैसे?

— दोष

Answer 1

गणितज्ञ, ५५ ५१ ४५

मॉड्यूलर उलटा प्रतिबंधित है, लेकिन मॉड्यूलर घातांक की अनुमति है। द्वारा फर्मा थोड़ा प्रमेय, n^(-1) % p == n^(p-2) % p।

(PowerMod[x=1##&@@#/#,#-2,#]x).#2&@@Thread@#&

उदाहरण:

In[1]:= f = (PowerMod[x=1##&@@#/#,#-2,#]x).#2&@@Thread@#&;

In[2]:= f[{{5, 3}}]

Out[2]= 3

In[3]:= f[{{7, 2}, {5, 4}, {11, 0}}]

Out[3]= 1584

In[4]:= f[{{5, 1}, {73, 4}, {59, 30}, {701, 53}, {139, 112}}]

Out[4]= 142360350966

---

सिर्फ मनोरंजन के लिए:

ChineseRemainder@@Reverse@Thread@#&

Comments

आप अंतरतम फ़ंक्शन के तर्कों के क्रम को अदला-बदली करके बचा सकते हैं, जैसे कि आप उपयोग कर सकते हैं PowerMod[#2,#-2,#]और मुझे यह भी नहीं लगता कि फ़ंक्शन को नाम देने की आवश्यकता है, इसे 48 पर लाएं।

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

हां, अनाम कार्य ठीक हैं।

— xnor

Answer 2

पायथन 2, 165 101 99 98 85 बाइट्स

अन्य उत्तरों की तरह फ़र्मेट की छोटी प्रमेय का उपयोग करना। मॉड्यूलर रेंज के भीतर अंतिम राशि रखने से परेशान नहीं हैं, क्योंकि हम सबसे छोटे समाधान में रुचि नहीं रखते हैं। 13 बाइट बचाने के लिए धन्यवाद अस्थिरता।

l=input();x=reduce(lambda a,b:a*b[0],l,1)
print sum(x/a*b*pow(x/a,a-2,a)for a,b in l)

[(5, 3)]
3
[(7, 2), (5, 4), (11, 0)]
1584
[(5, 1), (73, 4), (59, 30), (701, 53), (139, 112)]
142360350966

Comments

आप पहले स्थान को हटा सकते हैं for।

— isaacg

x/a*b*pow(x/a,a-2,a)for a,b in lकार्य करना चाहिए।

— उतार

बहुत बढ़िया बात! मैं वहाँ स्पष्ट अतिरेक से छुटकारा पाने की कोशिश कर रहा था, लेकिन यह भूल गया कि मैं बस अनपैक कर सकता हूं।

— उरई ग्रांट

Answer 3

पायथ, 40 37 36 29

M*G.^G-H2Hsm*edg/u*GhHQ1hdhdQ

एलेफाल्फा के लिए फ़र्मेट की छोटी प्रमेय का उपयोग करता है। इस सूत्र का उपयोग करके गणना करता है ।

Answer 4

रूबी, 129

ठीक है, कामरेड, ऐसा लगता है कि रूबी समाधान अधिक लंबा होना चाहिए क्योंकि ओपनस्प्ल लाइब्रेरी लोड किए बिना और ओपनएसएसएल :: बीएन पर रूपांतरण किए बिना मॉड्यूलर घातांक उपलब्ध नहीं है। फिर भी, इसे लिखने में मज़ा आया:

require("openssl")
z=eval(gets)
x=1
z.map{|a,b|x*=a}
s=0
z.map{|a,b|e=a.to_bn;s+=(x/a).to_bn.mod_exp(e-2,e).to_i*b*x/a}
puts(s)

Comments

जब बुला आप कोष्ठक की जरूरत नहीं है require, evalया puts।

— टटलमैन

Answer 5

अजगर 2, 61

n=P=1
for p,a in input():n+=P*(a-n)*pow(P,p-2,p);P*=p
print n

यह उत्पाद निर्माण की एक भिन्नता का उपयोग करता है जिसका अन्य उत्तर उपयोग करते हैं।

विचार बाधाओं पर लूप करना है और nपहले वाले को गड़बड़ाने के बिना मौजूदा बाधा को पूरा करने के लिए समाधान को अद्यतन करना है। ऐसा करने के लिए, हम Pअब तक देखे गए अपराधों के उत्पाद को ट्रैक करते हैं, और निरीक्षण करते हैं कि Pकिसी भी प्रकार के प्रभाव को जोड़ने के लिए कोई प्रभाव नहीं है, जो पहले से ही देखा गया है।

इसलिए, हमें केवल सही कई जोड़कर nसंतुष्ट करने के लिए बदलने की आवश्यकता है । हम गुणांक के लिए हल करते हैं :n%p == aPc

(n + P*c) % p == a

इसके लिए आवश्यक है कि c = (a-n) * P^(-1), उलटा मोडुलो लिया जाए p। जैसा कि अन्य लोग ध्यान देते हैं, व्युत्क्रम की गणना Fermat की लिटिल प्रमेय द्वारा की जा सकती है P^(-1) = pow(P,p-2,p)। तो, c = (a-n) * pow(P,p-2,p)है, और हम अद्यतन nद्वारा n+= P * (a-n) * pow(P,p-2,p)।

Answer 6

हास्केल, 68 100 बाइट्स

f l=sum[p#(m-2)*n*p|(m,n)<-l,let a#0=1;a#n=(a#div n 2)^2*a^mod n 2`mod`m;p=product(map fst l)`div`m]

उपयोग: f [(5,1), (73,4), (59,30), (701,53), (139,112)]->142360350966।

संपादित करें: अब एक तेज "पावर / मॉड" फ़ंक्शन के साथ। पुराने संस्करण (68 बाइट्स) इनबिल्ट पावर फंक्शन के साथ:

f l=sum[l#m^(m-2)`mod`m*n*l#m|(m,n)<-l]
l#m=product(map fst l)`div`m

Comments

मुझे संदेह है कि पावर-मॉड का आपका कार्यान्वयन बहुपद-समय नहीं है क्योंकि एक्सपोर्टर मॉड से पहले एक बड़ी संख्या का उत्पादन करता है। क्या आपने अंतिम परीक्षण मामले की कोशिश की है?

— xnor

@xnor: अंतिम परीक्षण का मामला मेरी 2GB मशीन पर कुछ सेकंड के बाद मेमोरी से बाहर हो जाता है। मैंने एक तेज़ पॉवर / मॉड फंक्शन जोड़ा है।

— निमि