रिवर्स-इंजीनियर एन-बोनविस अनुक्रम [s]

Question

EDIT: मैं एक उत्तर सोमवार, 2/15/2016 को स्वीकार करूंगा। बाइट्स कभी भी आपके पक्ष में हो सकते हैं!

अपनी "प्रिंट एन- बोनियासी सीक्वेंस" चुनौती में , @DJMcGoathem ने एन-बोनियास अनुक्रमों का वर्णन किया है, जिसमें पिछले एन संख्याओं को सारांशित किया गया है, बजाय पारंपरिक 2 के फाइबोनैचि अनुक्रम (" डुओ नेवीस अनुक्रम" कहा जाता है)। फिर उसने दो इनपुट लेने के लिए कहा, एक्स और एन, फिर एक्स वें एन- एनआईएससी नंबर का उत्पादन किया ।

मैं इसके विपरीत प्रस्ताव करता हूं।
एक अनुक्रम को देखते हुए, आउटपुट जो N -nacci अनुक्रम है, वह एक सबसेट है। मैं कहता हूँ "सबसेट का" क्योंकि:

• ए) ये क्रम अनंत हैं
• बी) यदि अनुक्रम की शुरुआत दी गई है, तो आप केवल प्रमुख 1s की संख्या की गणना कर सकते हैं

इस मामले में कि यह कई N -nacci अनुक्रम से संबंधित हो सकता है , सबसे कम को चुना।
इस मामले में कि यह किसी एन-नेक्सस अनुक्रम से संबंधित नहीं है , तो आपका प्रोग्राम कुछ और प्रिंट के अलावा कुछ भी कर सकता है जो कि आउटपुट के लिए गलत हो सकता है। इन व्यवहारों में शामिल हैं (लेकिन इन तक सीमित नहीं हैं): अनंत लूप, त्रुटि, क्रैश, स्वयं को हटाएं (* खांसी खांसी * सतर्कता * खांसी खांसी)), या एक ब्लैक होल बनाएं (जब तक यह ब्लैक होल कुछ भी पैदा नहीं करता है जो कुछ भी कर सकता है) मान्य आउटपुट के लिए गलत हो)।
इस चुनौती के लिए, ये क्रम 1 से शुरू होता है। इसका मतलब है कि कोई भी एन- सीक्वेंस अनुक्रम एन वालों से शुरू होता है। इसके अलावा, एनएक सकारात्मक पूर्णांक होना चाहिए। तो कोई -1 -nacci, आदि।

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

1,1,1 -> 1
49, 97 -> 7
55, 89, 144 -> 2
1 -> 1
6765 -> 2
12, 23, 45, 89 -> 12
100, 199 -> 100

Comments

create a black hole (as long as this black hole does not produce anything that could be mistaken for valid output).मेरा, ब्लैक होल के सर्पिल सुनहरे अनुपात में परिवर्तित हो रहे हैं! यह डुओवेसी अनुक्रम के लिए वैध आउटपुट होना चाहिए!

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ यह एक सुंदर सुनहरा अनुपात हो सकता है, लेकिन ब्लैक होल के पास मत जाओ! youtube.com/watch?v=TTUQyEr-sg0

— स्तर नदी सेंट

ओह मेरी, यह बहुत मुश्किल है जितना मैंने सोचा था ...

— GamrCorps

@ mbomb007 सकारात्मक पूर्णांकों और प्राकृतिक संख्याओं के बीच क्या अंतर है?

— नहीं कि चार्ल्स

@ mbomb007 आह। मुझे लगा कि 1 पहली प्राकृतिक संख्या थी। मैं संख्या गिनने के बारे में सोच रहा होगा

— नहीं कि चार्ल्स

Answer 1

रूबी, 94

मुझे काफी आश्चर्य है कि मैं इसे एक ही एल्गोरिथ्म में गोल्फ में कितना दूर कर पाया हूँ! मैंने 200 से अधिक के साथ शुरुआत की!

->a{1.step.find{|s|x=[1]*(s+z=a.size)
x<<x[-s,s].inject(:+)while x.max<a.max&&s>1
x[-z,z]==a}}

Ungolfed:

l=->a{
    # ooh! a built-in infinite incrementer!
    1.step.find{|s|
        # if n == 1, z is important, otherwise s.
        x=[1]*(s+z=a.size)
        ## add the next nacci number until we hit or overshot max. 
        ## if s == 1, we don't increment, so don't bother
        x<<x[-s,s].inject(:+)while x.max<g&&s>1
        # eval to true if there's a match, false if not
        x[-z,z]==a
    }
}

Comments

x=[1]*(s+z=a.size)ठीक कैसे काम करता है?

— साइओस

@Cyoce यदि n == 1, तो हम कभी भी वेतन वृद्धि नहीं करेंगे, इसलिए हमें 1 की एक सरणी की आवश्यकता है, हालांकि इनपुट लंबा है। यदि n > 1, तो हमें nअनुक्रम के लिए कम से कम 1 की आवश्यकता है । इसलिए किसी भी लंबाई के लिए s+a.sizeकवर n == 1किया गया है a, और यह किसी भी अन्य अनुक्रम की शुरुआत को कवर करता है, इसलिए हम बस sबल्ले से अंक जोड़ना शुरू कर सकते हैं । क्या इसका कोई मतलब है?

— नहीं है कि चार्ल्स

@Cyoce और अगर आप रूबी में एक अलग सवाल पूछ रहे हैं, तो [1]*numberलंबाई के साथ 1 का एक सरणी देता है number। तो करने के लिए x=[1]*(s+z=a.size)असाइन करता a.sizeहै z, तो x1 की लंबाई के एक सरणी को असाइन करता है s+z।

— नहीं है कि चार्ल्स

Answer 2

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

def r(n,x):i,f=n,[1]*n;exec"f+=sum(f[i-n:]),;i+=1;"*(x-n);return f
l=input()
m=max(l)+len(l)
for i in range(1,m):
 if any(l==r(i,m)[b:b+len(l)]for b in range(m)):print i;break;

ध्यान दें कि इस प्रारूप में इनपुट की आवश्यकता है:

[1, 1, 2, 3...]

बजाय

1, 1, 2, 3...

बहुत ही सरल समाधान, बस चीजों को लुढ़कने के लिए। मैं किसी और के जवाब के बाद इसे नीचे गोल्फिंग पर अधिक काम करूंगा। यह @ डेटा के उत्तर से एन-बोन्नासी जनरेटर के थोड़ा संशोधित संस्करण का उपयोग करता है , इसलिए उसे सहारा देता है। फिर इनपुट की सीमा में प्रत्येक एन-बोनैसी के लिए, जांचता है कि इनपुट इसके बाद का है।

Comments

उन्हीं सुझावों को आज़माएँ जो मैंने उन्हें दिए थे: बदलाव के f.appendलिएf+=

— Cyoce

@ कइसे ओह दुह। मुझे विश्वास नहीं हो रहा है कि मैं कुछ बुनियादी याद किया। fp

— जेम्स

क्या ट्रेलिंग ;आवश्यक है?

— साइओस

Answer 3

लूआ, 324 323 बाइट्स

जब मैं अन्य सबमिशन देखता हूं, तो मुझे ऐसा लगता है कि मेरे कोड में कुछ गड़बड़ है ... लेकिन फिर, मुझे याद है कि यह लुआ है, और ये सभी फैंसी समारोह नहीं हैं: '(

यह बहुत मजेदार था, मुझे वास्तव में कुछ समय लगा।

संपादित करें: एक साधारण चाल के साथ 1 बाइट को बचाया: एक ::label::+ का उपयोग करके goto labelएक अनंत लूप के साथ किया गया while''।

function f(l)c=2 y,z=table.remove,os.exit while(l[1]<2)do y(l,1)if(#l<1)then print(1)z()end end ::q:: a={}for i=1,c do a[i]=1 end b={}for i=1,#l do b[i]=l[i]end while(a[#a]<b[1])do x=0 for i=(#a-c+1>0 and #a-c+1 or 1),#a do x=x+a[i]end a[#a+1]=x if a[#a]==b[1]then y(b,1)end if #b<1 then print(c)z()end end c=c+1 goto q end

असंगठित और स्पष्टीकरण

लुआ के पास सेट, सब्मिट, या यहां तक ​​कि यह जांचने का कोई तरीका नहीं है कि किसी सरणी / तालिका में उसके सूचकांक / कुंजी का उपयोग किए बिना कोई मान है या नहीं। इसलिए मैंने उन तत्वों को हटाने का फैसला किया है जिन्हें मैं एक पैरामीटर के रूप में लेता हूं। यह है कि मैं कैसे रिकॉर्ड रखता हूं कि कौन से तत्व पहले से ही गणना किए गए हैं, और यदि यह मेल खाता है।

  function f(l)
  c=2
  y,z=table.remove,os.exit           -- Create pointers on table.remove and os.exit
                                     -- saves a total of 9 bytes
  while(l[1]<2)                      -- loop used to remove leading 1
  do 
    y(l,1)
    if(#l<1)                         -- we also check if it was a 1-only array
    then 
      print(1)                       -- if so, we print 1 and exit
      z()
    end 
  end

  ::q::                              -- label q, start of the infinite loop
    a={}for i=1,c do a[i]=1 end      -- fill an array with c 1s
    b={}for i=1,#l do b[i]=l[i]end   -- copy the sequence array
    while(a[#a]<b[1])                -- while max(a)<min(b)
    do
      x=0 for i=(#a-c+1>0            -- iterate from index a.length-c to
                    and #a-c+1       -- to a.length
                    or 1),#a 
      do 
        x=x+a[i]                     -- summing a's elements
      end
      a[#a+1]=x                      -- append x to a
      if a[#a]==b[1]then y(b,1)end   -- if x is equal ot a member of the sequence
                                     -- remove it
      if #b<1 then print(c)z()end    -- if b is empty, it means the subset is in a
                                     -- we print c and exit
    end                              -- else we loop again
    c=c+1                            -- with c+1
  goto q                             -- return to the start of this block
end

आप Lua को ऑनलाइन आज़मा सकते हैं , और कुछ परीक्षण चलाने के लिए आप निम्नलिखित कोड नमूने को कॉपी / पेस्ट कर सकते हैं। जैसे ही यह फ़ंक्शन बाहर निकलता है जब यह उत्तर (अनंत लूप अन्यथा) पाया जाता है, तो आपको test[]उपयोग किए गए इंडेक्स को बदलना होगा (यह मत भूलो कि लुआ 1-इंडेक्सेड है :))।

function f(l)c=2 y,z=table.remove,os.exit while(l[1]<2)do y(l,1)if(#l<1)then print(1)z()end end ::q:: a={}for i=1,c do a[i]=1 end b={}for i=1,#l do b[i]=l[i]end while(a[#a]<b[1])do x=0 for i=(#a-c+1>0 and #a-c+1 or 1),#a do x=x+a[i]end a[#a+1]=x if a[#a]==b[1]then y(b,1)end if #b<1 then print(c)z()end end c=c+1 goto q end

test={{1,1,1},
{49, 97},
{55, 89, 144},
{1},
{6765},
{12, 23, 45, 89},
{100, 199}}

print(f(test[1]))