कुशलतापूर्वक सभी वेक्टर विभाजन उत्पन्न करते हैं

Question

एक वेक्टर विभाजन वेक्टर की एक श्रृंखला को विभाजित कर रहा है जैसे कि उनका योग मूल है। यहाँ कुछ विभाजन दिए गए हैं:

[3, 1, 2] = [3, 1, 2]
[3, 1, 2] = [0, 0, 1] + [0, 0, 1] + [0, 1, 0] + [1, 0, 0] + [2, 0, 0]
[3, 1, 2] = [1, 1, 2] + [2, 0, 0]

यहाँ वेक्टर जोड़ तत्व-वार किया जाता है। एक वैध विभाजन में नकारात्मक पूर्णांक, या सभी-शून्य वेक्टर के साथ कोई वैक्टर नहीं होता है।

अब चुनौती एक प्रोग्राम या फ़ंक्शन लिखना है जो एक लक्ष्य वेक्टर दिए गए सभी संभावित वेक्टर विभाजन उत्पन्न करता है। यह अपेक्षाकृत आसान लग सकता है ...

... लेकिन एक ट्विस्ट है। यदि इनपुट वेक्टर का आकार L है, और यह सबसे बड़ा विभाजन उत्पन्न करता है जिसमें M तत्व हैं, तो आप O (L * M) मेमोरी से अधिक उपयोग नहीं कर सकते हैं।

आप मान सकते हैं कि एक पूर्णांक O (1) मेमोरी का उपयोग करता है। इसका मतलब है कि आपको विभाजन को आउटपुट करना चाहिए क्योंकि आप उन्हें उत्पन्न करते हैं। उसके ऊपर, आपको प्रत्येक विभाजन को केवल एक बार ही आउटपुट करना होगा। उदाहरण के लिए, ये समान विभाजन हैं:

[3, 1, 2] = [3, 0, 2] + [0, 1, 0]
[3, 1, 2] = [0, 1, 0] + [3, 0, 2]

यदि आप आउटपुट करते हैं तो आपका उत्तर दोनों अमान्य है।

---

इसके लिए सभी विभाजन [3, 2]:

[3, 2]
[0, 1] + [3, 1]
[0, 1] + [0, 1] + [3, 0]
[0, 1] + [0, 1] + [1, 0] + [2, 0]
[0, 1] + [0, 1] + [1, 0] + [1, 0] + [1, 0]
[0, 1] + [1, 0] + [2, 1]
[0, 1] + [1, 0] + [1, 0] + [1, 1]
[0, 1] + [1, 1] + [2, 0]
[0, 2] + [3, 0]
[0, 2] + [1, 0] + [2, 0]
[0, 2] + [1, 0] + [1, 0] + [1, 0]
[1, 0] + [2, 2]
[1, 0] + [1, 0] + [1, 2]
[1, 0] + [1, 1] + [1, 1]
[1, 1] + [2, 1]
[1, 2] + [2, 0]

अपने उत्तर का परीक्षण करने के लिए, इसे चलाएं [3, 2, 5, 2]। इसमें 17939 विभाजन उत्पन्न होने चाहिए, जो सभी के योग हैं [3, 2, 5, 2], और ये सभी अद्वितीय हैं (आप प्रत्येक विभाजन को पहले क्रमबद्ध करके विशिष्टता के लिए परीक्षण कर सकते हैं)।

---

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

Answer 1

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

सरल जानवर बल एल्गोरिथ्म। आधार में एक संख्या के रूप में पूरी सूची को व्यवहार करता है max(input)+1( b), और [0, b**(L*M))यह देखने के लिए कि सीमा में प्रत्येक "संख्या" की जाँच करता है:

1. सही मात्रा में रकम
2. वर्णमाला क्रम में है (विशिष्टता सुनिश्चित करता है)

यदि सूची इन मानदंडों से मेल खाती है, तो प्रोग्राम इसे सभी ऑल-जीरो वैक्टर से छीन लेता है।

स्मृति उपयोग

इस कार्यक्रम में मेरे द्वारा उपयोग की जाने वाली सबसे बड़ी डेटा संरचना एक डबल-नेस्टेड सूची है, एक सूची Mजिसमें मेमोरी Lदेने के लिए लिस की लंबाई होती है O(L*M)।

मेरी अन्य डेटा संरचनाओं के लिए, मेरे पास 3 वैश्विक इनट्स O(3), 1 सूची लंबाई L( O(L)), 1 सरणी लंबाई M( O(M)), और आउटपुट करते समय सबसे बड़ी सरणी की एक प्रति ( O(L*M)) है।

कुल मिलाकर, यह मुझे एक स्मृति उपयोग देता O(2*L*M + L + M + 3)है O(L*M), जो मानदंडों को पूरा करने के लिए सरल करता है।

समय की जटिलता

एक जानवर बल एल्गोरिथ्म होने के नाते, यह एल्गोरिथ्म बेहद धीमा है। लूप को छोड़ने के लिए, सरणी में अंतिम इंट को होना चाहिए b-1। ऐसा b**(L*M)होने से पहले लूप को कई बार चलाना होगा।

इसके अलावा, हर बार जब सूची चलती है, तो इसे L*M+L+Mपुनरावृत्तियों का उपयोग करते हुए, दोनों स्थितियों की जांच करने और सबसे खराब स्थिति में सूची को प्रिंट करने की आवश्यकता होती है । यह एक समग्र देने के लिए सरल करता है O(L*M * b**(L*M))। मैंने अपने कार्यक्रम को परखने की कोशिश की [3, 2, 5, 2], लेकिन 45 मिनट बाद ही हार मान ली।

गोल्फ का कार्यक्रम

v=input()
L=len(v)
M=sum(v)
b=max(v)
R=range
t=[L*[0]for i in R(M)]
def A(l,i):
 if i<L*M-1and~-b<l[i/L][i%L]:A(l,i+1)
 l[i/L][i%L]=-~l[i/L][i%L]%-~b
while t[-1][-1]<b:
 if v==[sum(q[i]for q in t)for i in R(L)]and all(`t[i]`>=`t[i+1]`for i in R(M-1)):print[x for x in t if[0]*L!=x]
 A(t,0)

मैं इसे थोड़ा और अधिक करने में सक्षम हो सकता हूं, विशेषकर वेतन वृद्धि का हिस्सा। अघोषित कोड आ रहा है।

Comments

निश्चित रूप से उस दक्षता के बारे में नहीं जब मैं इस प्रश्न को पोस्ट करने के लिए उम्मीद कर रहा था, लेकिन मुझे लगता है कि यह तकनीकी रूप से समस्या का हल करता है :)

— orlp