मैजिक सीक्वेंस ऑफ लेंथ एन

Question

एक जादू अनुक्रम गैर-नकारात्मक पूर्णांकों का एक अनुक्रम है x[0..n-1]जैसे कि बिल्कुल x[i]उदाहरण हैंi

उदाहरण के लिए, 6,2,1,0,0,0,1,0,0,0 एक जादू अनुक्रम है क्योंकि वहाँ 6 0, 2 1, और इसी तरह के हैं।

एक फ़ंक्शन लिखें, जब n दिया जाता है, लंबाई n के सभी जादू अनुक्रमों को आउटपुट करता है

---

वह प्रोग्राम जो 10 सेकंड की जीत के भीतर n के उच्चतम मूल्य के लिए सही आउटपुट का उत्पादन कर सकता है। (सभी कार्यक्रमों का स्वागत है, हालांकि)

उदाहरण के लिए, एलिस का कार्यक्रम 10 सेकंड के भीतर n = 15 तक निपट सकता है जबकि बॉब एक ​​ही समय में n = 20 तक सौदा कर सकता है। बॉब जीतता है।

प्लेटफ़ॉर्म: लिनक्स 2.7GHz @ 4 सीपीयू

Comments

PPCG में आपका स्वागत है! यह एक बड़ी चुनौती है, लेकिन आपको जीत की कसौटी चाहिए। उदाहरण के लिए, आप कह सकते हैं कि विजेता सबसे छोटा कार्यक्रम है।

— यपनीपैन

प्रासंगिक: स्व-वर्णनात्मक संख्या

— Sp3000

जवाब पोस्ट किए जाने के बाद कृपया जीतने की कसौटी को न बदलें। इसके अलावा, यह कोड गोल्फ के रूप में सबसे तेज़ कोड की तुलना में बहुत बेहतर था, कम से कम मेरी राय में।

— एलेक्स ए

@xnor आप n के पूर्णांक विभाजन को उत्पन्न करके शुरू कर सकते हैं और जाँच सकते हैं कि क्या वे स्व-वर्णनात्मक हो सकते हैं।

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

क्या n>5समाधान के साथ सबसे छोटा है फार्म का नहीं [n-4, 2, 1, ..., 0, 0, 1, 0, 0, 0]? मैंने देखा है n=20और एक नहीं मिला है, और सोच रहा हूं कि क्या मैं एक त्रुटि बना रहा हूं।

— xnor

Answer 1

अजगर, nth10 ⁸

def magic_sequences(n):
    if n==4:
        return (1, 2, 1, 0),(2, 0, 2, 0) 
    elif n==5:
        return (2, 1, 2, 0, 0),
    elif n>=7:
        return (n-4,2,1)+(0,)*(n-7)+(1,0,0,0),
    else:
        return ()

यह इस तथ्य का उपयोग करता है, जो मैं साबित करूंगा, कि लंबाई का एकमात्र मैजिक अनुक्रम n हैं:

• [1, 2, 1, 0] तथा [2, 0, 2, 0] लिएn=4
• [2, 1, 2, 0, 0] के लिये n=5
• [n-4, 2, 1, 0, 0, ..., 0, 0, 1, 0, 0, 0] के लिये n>=7

तो, n>=7एक के लिए , केवल एक विशाल टपल वापस करने की आवश्यकता है। मैं n=10^8अपने लैपटॉप पर लगभग ऐसा कर सकता हूं, जो संभवतः स्मृति द्वारा सीमित है; किसी भी अधिक और यह जमा देता है। (सूचियों के बजाय टुपल्स का उपयोग करने के विचार के लिए ट्राइकोप्लेक्स के लिए धन्यवाद।) या, यदि कोई इसके बजाय नॉनज़ेरो प्रविष्टियों का एक शब्दकोश प्रिंट कर सकता है, तो कोई भी गिन्नॉर्मस के लिए {0:n-4, 1:2, 2:1, (n-4):1}ऐसा कर सकता है n।

मैं के लिए विशिष्टता साबित n>=7; अन्य लोगों को क्रूर बल या कैसवर्क द्वारा जांचा जा सकता है।

की प्रविष्टियों का योग lसूची की सभी संख्याओं की कुल गणना है, जो इसकी लंबाई है n। सूची में l[0]शून्य है, और इसलिए n-l[0]नॉनज़ेरो प्रविष्टियाँ हैं। लेकिन परिभाषा के अनुसार l[0]नॉनज़रो होना चाहिए या हमें एक विरोधाभास मिल सकता है, और प्रत्येक अन्य नॉनज़ेरो प्रविष्टियों में से कम से कम 1. यह पहले से ही एक राशि के लिए खाता हैl[0] + (n-l[0]-1)*1 = n-1 से ही कुल योग से बाहर के योग के लिए है n। तो गिनती नहीं l[0], अधिकतम 2 पर हो सकती है और 2 से बड़ी कोई प्रविष्टि नहीं।

लेकिन इसका मतलब है कि केवल नॉनज़ेरो प्रविष्टियाँ हैं l[0], l[1], l[2], and l[l[0]], जिनके मान अधिकतम हैं l[0]और एक क्रमपरिवर्तन है 1,1,2, जो अधिकतम राशि देता है l[0]+4। चूंकि यह राशि है n, जो कम से कम 7 है, हमारे पास है l[0]>=3, और इसी तरह l[l[0]]=1। अब, कम से कम एक है 1, जिसका अर्थ है l[1]>=1, लेकिन अगर l[1]==1वह दूसरा है 1, तो l[1]>=2, जिसका अर्थ l[1]है अकेला 2। यह देता है l[2]=1, और सभी शेष प्रविष्टियां हैं 0, इसलिए l[0]=n-4, जो समाधान पूरा करती है।

Comments

और भाषा है ...?

— edc65

@ edc65 यह अजगर की तरह दिखता है। लेकिन मुझे यकीन नहीं।

— इस्माइल मिगुएल

Answer 2

अजगर 3, n≈40

def plausible_suffix(l,N):
    if sum(l)>N:
        return False

    pairs = [(N-1-i,l[i]) for i in range(len(l))]

    if sum(i*x for i,x in pairs)>N:
        return False

    num_remaining = N - len(l)

    for index, desired_count in pairs:
        count = l.count(index)
        more_needed = desired_count - count
        if more_needed<0: 
            return False
        num_remaining -= more_needed
        if num_remaining<0:
            return False
    return True

plausible_func = plausible_suffix

def generate_magic(N):
    l=[0]
    while l:
        extend = False
        if plausible_func(l,N):
            if len(l)==N:
                yield l[::-1]
            else:
                extend = True
        if extend:
            l.append(0)
        else:
            while l[-1]>=N-2:
                l.pop(-1)
                if not l:raise StopIteration
            l[-1]+=1

n=40 #test parameter

if n>0:
    for x in generate_magic(n):
        print(n,x)

क्या संभावित सूचियों की चौड़ाई-पहली खोज, दाईं से बाईं ओर प्रविष्टियाँ भरना, खोज को किसी प्रत्यय पर रोकना यदि यह प्रशंसनीय नहीं है, जो कि हो सकती है:

• प्रत्यय में प्रविष्टियों का योग पार हो जाता है n(पूरी सूची का योग होना चाहिए n)
• i*l[i]प्रत्यय का भारित योग से अधिक है n(पूरी सूची के लिए योग होना चाहिए n)
• प्रत्यय में कोई भी संख्या अधिक बार दिखाई देती है जो प्रत्यय कहता है कि यह होना चाहिए
• सभी संख्याओं के लिए शेष अनफ़िल्ड स्पॉट की संख्या बहुत कम है जिन्हें अधिक बार प्रदर्शित करने की आवश्यकता होती है।

मेरे पास मूल परीक्षण उपसर्ग दाएं से बाएं थे, लेकिन यह अधिक धीरे-धीरे चला गया।

इस तक आउटपुट n=30हैं:

4 [1, 2, 1, 0]
4 [2, 0, 2, 0]
5 [2, 1, 2, 0, 0]
7 [3, 2, 1, 1, 0, 0, 0]
8 [4, 2, 1, 0, 1, 0, 0, 0]
9 [5, 2, 1, 0, 0, 1, 0, 0, 0]
10 [6, 2, 1, 0, 0, 0, 1, 0, 0, 0]
11 [7, 2, 1, 0, 0, 0, 0, 1, 0, 0, 0]
12 [8, 2, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0]
13 [9, 2, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
14 [10, 2, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
15 [11, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
16 [12, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
17 [13, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
18 [14, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
19 [15, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
20 [16, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
21 [17, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
22 [18, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
23 [19, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
24 [20, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
25 [21, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
26 [22, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
27 [23, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
28 [24, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
29 [25, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
30 [26, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]

पहले तीन सूचियों को छोड़कर [1, 2, 1, 0], [2, 0, 2, 0], [2, 1, 2, 0, 0], प्रत्येक लंबाई की बिल्कुल एक सूची है n>6, और इसका रूप है [n-4, 2, 1, ..., 0, 0, 1, 0, 0, 0]। यह पैटर्न कम से कम तक बना रहता है n=50। मुझे संदेह है कि यह हमेशा के लिए रहता है, इस मामले में यह इनकी एक बड़ी संख्या के उत्पादन के लिए तुच्छ है। यदि नहीं, तो भी संभव समाधानों पर गणितीय समझ एक खोज को गति प्रदान करेगी।

Comments

@Ypnypn मैं विशेष आवरण है n=0। मुझे याद था कि हम एक एकल के लिए परिणाम लौटा रहे हैं n, गिनती नहीं कर रहे हैं n। यह मुझे मिलता है n=40।

— xnor

Answer 3

पायथ - 15 बाइट्स

लीन के सभी संभावित अनुक्रमों द्वारा ब्रूट बल का उपयोग करता है nऔर फिर फ़िल्टर करता है।

f.A.eq/TkYT^UQQ

पूर्ण विवरण जल्द ही आ रहा है।

इसे यहाँ ऑनलाइन प्रयास करें ।

Comments

FYI करें, ओपी ने जीत की कसौटी को सबसे तेज़ कोड में बदल दिया।

— एलेक्स ए

जीत की कसौटी के बावजूद, यहाँ एक 3 बाइट गोल्फ है: `fqm / TdQT ^ UQQ`

— जकुबे

Answer 4

के, 26 बाइट्स

{f@&{x~(+/x=)'!#x}'f:!x#x}

जैसे माल्टीसेन का दृष्टिकोण, पाशविक बल। कार्यक्रम का दिल एक विधेय है जो परीक्षण करता है कि क्या एक दिया गया वेक्टर "जादू" है:

{x~(+/x=)'!#x}

इनपुट वेक्टर ( !#x) के रूप में लंबे समय तक एक कोटा वेक्टर बनाएं , प्रत्येक अंक की घटनाओं को गिनें ( (+/x=)') और इनपुट टेम्पलेट के साथ परिणाम की तुलना करें (x~ ) के । यदि कोई मेल है, तो आपके पास एक जादू अनुक्रम है।

दुर्भाग्य से, यह पहला छुरा बहुत धीमा प्रतीत होता है। परीक्षण का उपयोग कर Kona मेरे लैपटॉप पर n = 7 को संभालने में लगभग 12 सेकंड लगते हैं। मुझे इसे थोड़ा और सोचने की जरूरत है।