विभाजन पारस्परिक

Question

संख्या n> 77 को देखते हुए , एक प्रोग्राम या फ़ंक्शन लिखिए जो अलग-अलग पॉजिटिव पूर्णांक का एक सेट ढूंढता है जैसे कि सेट का योग n के बराबर होता है , और सेट के पारस्परिक के योग 1 के बराबर होता है।

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

80 = 2 + 4 + 10 + 15 + 21 + 28 1/ 1/2 + 1/4 + 1/10 + 1/15 + 1/21 +28 + 1

आपका प्रोग्राम या फ़ंक्शन किसी भी n <2 ^{32 के} लिए (सैद्धांतिक रूप से) काम करना चाहिए , और फ्लोटिंग पॉइंट राउंडिंग त्रुटियों के लिए बहाना नहीं है। ध्यान दें कि समाधान सभी n> 77 के लिए मौजूद हैं ।

---

बाइट्स में सबसे छोटा कोड जीतता है।

एक बोनस प्रोत्साहन है: मैं सबसे छोटे समाधान के लिए इनाम दूंगा जो किसी भी n के लिए काम करता है और लॉग (n) चलाता है । छोटे एन के लिए यह तेज़ होना चाहिए (मेरे विवेक पर निर्धारित)। हां, यह संभव है।

Comments

क्या ऐसे अपघटन हमेशा मौजूद रहने की गारंटी है? कोई भी संख्या-सिद्धांत प्रमेय जो कि आश्वस्त करता है?

— लुइस मेंडो

ऐसा लगता है कि वहाँ सभी n> 77 के लिए। (मैंने हर विवरण की जाँच नहीं की।) जो आपकी चुनौती के विवरण में होना चाहिए था ...

— त्रुटी

@flawr, मुझे लगता है कि उन्होंने उस संदर्भ को शामिल नहीं किया क्योंकि यह O(log n)एल्गोरिथ्म को दूर करता है।

— पीटर टेलर

फिर भी उन्होंने उल्लेख किया है कि यह सेट दिए गए n के लिए मौजूद है। (और मैंने शीर्षक

— पाते

@flawr, मुझे इसे खोजने में लगभग 10 मिनट लगे। मुझे मिस्र के अंशों पर एक पृष्ठ के माध्यम से मिला, और आप निंजा मुझे 10 सेकंड तक रोकेंगे।

— पीटर टेलर

Answer 1

मैथेमेटिका, 54 बाइट्स

Select[IntegerPartitions@#,Unequal@@#&&Tr[1/#]==1&,1]&

के रूप में के रूप में यह अक्षम हो जाता है, लेकिन यह n = 78लगभग 9 सेकंड में हल करता है ।

परिणाम एक सूची में लिस्ट के रूप में दिया जाता है, जैसे:

{{45, 12, 9, 5, 4, 3}}

Comments

मुझे आश्चर्य है कि अगर यह बहुत बड़े एन के लिए काम करता है।

— njpipeorgan

@njpipeorgan पर्याप्त स्मृति और समय को देखते हुए, हाँ।

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

मुझे IntegerPartition [n] की लंबाई का एक अनुमान मिला, जो exp (sqrt (n)), ~ 10 ^ 10 ^ 4.5 के लिए n = 2 ^ 30 के क्रम में है। मैं वास्तव में विश्वास नहीं करता कि गणितज्ञ (या यहां तक ​​कि किसी भी वास्तुकला) सरणी को धारण करने में सक्षम है।

— njpipeorgan

@njpipeorgan चुनौती स्पष्ट रूप से कहा गया है कि एल्गोरिथ्म 2 ^ 32 अप करने के लिए काम करना चाहिए सैद्धांतिक रूप से , (नहीं व्यावहारिक रूप से, के रूप में आमतौर पर कोड गोल्फ के लिए माना जाता है, जब तक कि चुनौती स्पष्ट रूप से की आवश्यकता है कि कार्यक्रम वास्तव में समय और स्मृति के लिए उचित समय में सभी आदानों के लिए खत्म )।

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

Answer 2

पायथन 3, 7306 1995 बाइट्स

यह समाधान लॉग (n) जटिलता (जहां तक ​​मैं बता सकता हूं) में चलता है।

def i(s,t):
 for n in s[::-1]:t=t.replace(*n)
 return [[]]*78+[list(bytearray.fromhex(a))for a in t.split(",")]
def f(n):
 g,h=lambda c,n:c+[[[2],[3,7,78,91]][n[len(c)]%2]+[i*2for i in c[-1]]],lambda n:[]if n<78 else h((n-[2,179][n%2])//2)+[n]
 v=h(n);c=[i([['g',',03040'],['h',',,0306080'],['i',',020'],['j','b0c1'],['k','21'],['l','60'],['m','30'],['n','141'],['o','k24'],['p',',g'],['q','618'],['r','0c0'],['s','1e'],['t',',0ml'],['u','283c'],['v','e0f1'],['w','2a38'],['x','80'],['y','a0'],['z','01'],['A','50'],['B','24'],['C','i40'],['D','plb1'],['E','gl'],['F','48'],['G','bre1'],['H','28'],['I','6k'],['J','416s'],['K',',040Al'],['L','90'],['M','2a'],['N','54'],['O','k6o'],['P','3c'],['Q','il'],['R','18'],['S','px'],['T','im'],['U','70'],['V','b1'],['W','23'],['X','pj'],['Y','hj'],['Z','0n']],'020lxycHTaRHCyf1517CyfneC91k51cCLdneQU912MCyf0dBiALyf2dClfPEyfneT9s2dELdneEjIgmLydHg5rd14BKLardsE3n8sQ9rd1517Q9rdneplmdRBgUmcRMC5sPEyf102bgA6sPE91z2miAj41IQmc0dRBQUen7spl31z82bT9RFT3wE7neMgmyf0dRBgUmaHMELc1b36EUdBMQLyfs2d,C710M2bgLardRHT3BFQ9rf0dPQ7rdBMQm9Rs2d,0mAl9100d142bE710M2bQmc0fRPtxarfn8sEc1k4sBTfnePExcwtxarf1k8BExcuT3kkT91663C51964,0mAl71k4BMELe12NTcRwQjOT820ltmarf1z8mExeRNCqBFtmyjIHKLa100ds2bQU91bM36garf1k4sBTcRBFgxarfwE91keB2dtUxcn8sME9nbs36gm9rduC5R78,0mAUyf0d14BME91kbB36QLc12AB2dgyjqkHEUeMNT9157eQU9RMFT8s78C8neuixLc1zk4AtUxc1z8Mmt8re0fn8sWhLyc1bH36pl8neu,Kxycsw,iAxc1420l,K8ren8NS9n81bs36hc0vz8WmYzqkmhyv2WBHhyVOHXkJoSjIwSjIuSvz4WASVZIAXZ6skmSj6oFXzOmplvcsW46D61csk46plv8WBFDqoF,tarvk8WBH,tyjkqoHhGqkN,tmvZ8sWmhVZqskmpc0vZ8WAXZqkAplbnImASbn6skwSbn6skuSVOwSVOupGONSbn6soFpyVkJk5aSj6sk78YJkuDkIP5aYOuhvzk4WBAhVzk416oA,tyjkJ265a,,0mxyjk41q53sYzIHmPXkqowXkqouhyVqoHFYz6omFhb0e1zqkmNSyVIP78YJ20klpyVOHwYk620olpc0vz8WBmFXzqomFpG61ckH38PhyjIP78Yz620kmlDkImLDzINUhGIuNDzIA78hb0e1ZIANYkqk366chG6oFNXkJkP5ahVZ6somFSb0e1620kNlhVk41qomADzIFLXkqso78pGqoFNXzkImP5a,tyjk620oHlhG620kNlXzqskm78,tjZqskHmPYqouFD6sku78YzqkNU,tjZqsomF')[v[0]]]
 for o in range(len(v)-1):c=g(c,v)
 return c[-1]

आप परीक्षण कर सकते हैं जो f(2**32 - 1)लगभग तुरंत चलता है

मैंने इस कागज़ को कंप्यूटिंग के लिए एक विधि पर प्रयोग किया । इस पद्धति के साथ 168 के बाद के नंबरों के लिए पूर्व-निर्धारित मानों के लिए डेटा का एक विशाल हिस्सा है जो 168 के बाद भी संख्या के बिना है। मैं इस डेटा को कुछ छोटे में बदलना चाहता था और मुझे कोई भी अच्छा संपीड़न एल्गोरिदम नहीं पता था। अपना बनाया।

जिस तरह से मैंने इसे संकुचित किया वह स्ट्रिंग रिप्लेस नियमों की एक सूची थी। मैंने एक ऐसा तरीका बनाया, जिसमें स्ट्रिंग रिप्लेस रूल पाया गया, जो नियम को परिभाषित करने वाले खाते को लेने में सबसे अधिक सामग्री को काट देगा। मैंने तब तक इसे पुन: लागू किया जब तक कि मैं कोई और नियम नहीं बना सका (मैंने वर्ण gz और AZ का उपयोग किया)। मैंने जिस स्ट्रिंग को बदलने के लिए बनाया वह संख्याओं में से प्रत्येक के लिए हेक्स मूल्यों की एक अल्पविराम से अलग की गई सूची थी। रेट्रोस्पेक्ट में, उन्हें अपने हेक्स मानों में परिवर्तित करना सबसे बुद्धिमान विकल्प नहीं हो सकता है, यह शायद उन्हें दशमलव में छोड़ने के लिए कम होगा, क्योंकि हेक्स केवल 3 अंकों की संख्या के लिए बचाएगा, लेकिन एकल अंकों की संख्या के लिए 0 जोड़ देगा।

वह पंक्ति जहाँ मैं ग सेट करता हूँ, आप प्रतिस्थापित नियमों की सूची और उस पाठ को देख सकते हैं जिस पर यह चलता है। नियमों को रिवर्स में भी लागू करने की आवश्यकता है क्योंकि कुछ नियमों में अन्य नियमों से निर्मित वर्ण शामिल हैं।

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

Comments

n=218आउटपुट [2]की उम्मीद है ??

— आधिकारिक

नहीं, मैं देखूंगा कि ऐसा क्यों हो रहा है। मैं क्षमाप्रार्थी हूं। शुरू में मेरे द्वारा संकुचित डेटा में त्रुटि हो सकती है।

— कैमरन Aavik

Answer 3

हास्केल, 93 बाइट्स

import Data.List
import Data.Ratio
p n=[x|x<-subsequences[2..n],sum x==n,1==sum(map(1%)x)]!!0

बुरी तरह से धीमा ¹ लेकिन यह निरंतर मेमोरी में चलता है। तुच्छ समाधान: [2..n]योग और प्रत्याहार के योग के सभी बाद की जाँच करें ।

एक के बजाय सभी समाधानों को वापस करना 3 बाइट्स छोटा है: बस हटा दें !!0(सावधान रहें: चलने का समय हमेशा चार्ट से दूर रहेगा)।

---

¹ चलने का समय इस बात पर निर्भर करता है कि परिणाम बाद की सूची में कितना जल्दी दिखाई देता है। अगर पहला मैच मिला तो हस्केल का आलस खोज को रोक देता है। जब संकलित किया गया, p 89(परिणाम [3,4,6,9,18,21,28]:) 35 में मेरे (4 वर्षीय) लैपटॉप पर चलता है। अन्य मान, यहां तक ​​कि छोटे भी, घंटे लग सकते हैं।

Answer 4

जूलिया, 77 बाइट्स

n->collect(filter(i->i==∪(i)&&sum(j->Rational(1,j),i)==1,partitions(n)))[1]

यह एक अकुशल लंबोदर फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक सरणी देता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

हम पूर्णांक के विभाजनों का उपयोग करके प्राप्त करते हैं partitions। फिर हम केवल उन अनूठे तत्वों वाले विभाजनों के सेट को फ़िल्टर करते हैं जिनके पारस्परिक योग 1 होते हैं। यह सुनिश्चित करने के लिए कि कोई राउंडऑफ़ त्रुटि नहीं होती है, हम Rationalपारस्परिक का निर्माण करने के लिए जूलिया के प्रकार का उपयोग करते हैं। filterएक पुनरावृत्ति देता है, इसलिए हमें करना होगाcollect इसे एक सरणी में होगा। यह हमें ऐरे का एक सरणी देता है (केवल एक ही तत्व के साथ), इसलिए हम पहली बार उपयोग कर सकते हैं [1]।

अब, जब मैं अक्षम कहता हूं, तो मेरा मतलब है। N = 80 के लिए इसे चलाने पर मेरे कंप्यूटर पर 39.113 सेकंड लगते हैं और 13.759 GB मेमोरी आवंटित होती है।