EDIT: 2/15/2016 Pazartesi günü bir cevap kabul edeceğim. Baytlar hiç yanınızda olsun!

Onun içinde "N-Bonacci sırası Baskı" meydan okuma , @DJMcGoathem önceki olup, burada N-Bonacci dizilerini tarif N numaraları toplanır yerine Fibonacci dizisi geleneksel 2 ( "olduğu söylenir ikili nacci dizisi"). Daha sonra iki girişli, X ve N, daha sonra çıktıyı almak istedi X inci N -nacci numara.

Ben tam tersini öneriyorum.
Bir sekans verildiğinde, hangi N- nacci sekansının bir alt kümesi olduğu çıktısı verilir. "Altkümesi" diyorum çünkü:

• A) bu diziler sonsuzdur
• B) dizinin başlangıcı verilirse, önde gelen 1'lerin sayısını sayabilirsiniz

Birden fazla N- nacci dizisine ait olabileceği durumda , en düşük olanı seçin.
Herhangi bir N-nacci dizisine ait olmaması durumunda, programınız çıktıyla karıştırılabilecek bir şey yazdırmaktan başka bir şey yapabilir. Bu davranışlar şunları içerir (ancak bunlarla sınırlı değildir): sonsuz döngü, hata, çökme, kendini silme (* öksürük öksürük * vigil * öksürük öksürük *) veya kara delik oluşturma (bu kara delik olabilecek herhangi bir şey üretmediği sürece) geçerli çıktı ile karıştırılmak).
Bu meydan okuma uğruna, bu sekanslar 1 ile başlar. Bu, herhangi bir N- nacci sekansının N ile başladığı anlamına gelir . Ayrıca, Npozitif bir tamsayı olmalıdır. Yani -1- nacci vb. Yok.

Test senaryoları:

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

Ruby, 94

Aynı algoritma içinde bunu ne kadar golf yapabildiğime oldukça şaşırdım! 200'den fazla ile başladım!

->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
    }
}

Python 2, 176 bayt

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;

Bunun için şu biçimde giriş yapılması gerektiğini unutmayın:

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

ziyade

1, 1, 2, 3...

Sadece işleri kolaylaştırmak için oldukça basit bir çözüm. Başka birisi cevap verdiğinde golf oynamak için daha fazla çalışacağım. Bu, @ Data'nın cevabından N-Bonnaci jeneratörünün biraz değiştirilmiş bir versiyonunu kullanır , bu yüzden ona destek olur. Ardından, giriş aralığındaki her N-Bonnaci için, girişin bir alt dizisi olup olmadığını kontrol eder.

Lua, 324323 Bayt

Diğer gönderileri gördüğümde, kodumda bir sorun var gibi hissediyorum ... Ama sonra, bunun Lua olduğunu hatırlıyorum ve tüm bu fantezi işlevler yok: '(

Çok eğlenceliydi, aslında biraz zamanımı aldı.

Düzenleme: Basit bir hile ile 1 bayt kaydedildi: yerine ::label::+ goto labelile sonsuz bir döngü kullanarak 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

Ungolfed ve Açıklamalar

Lua'nın bir dizi, altküme tanımlaması ve hatta bir dizi / tablonun dizin / anahtarını kullanmadan bir değer içerip içermediğini kontrol etmesinin bir yolu yoktur. Bu yüzden parametre olarak aldığım diziden elemanları kaldırmaya karar verdim. hangi öğelerin önceden hesaplandığını ve eşleşip eşleşmediğini bu şekilde kaydederim.

  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'yı çevrimiçi deneyebilir ve bazı testleri çalıştırmak için aşağıdaki kod örneğini kopyalayıp yapıştırabilirsiniz. Bu fonksiyon cevabı bulduğunda çıktığı için (aksi takdirde sonsuz döngü), test[]kullanılan endeksi değiştirmeniz gerekecektir (lua'nın 1 dizinli olduğunu unutmayın :)).

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]))