EDIT: Tôi sẽ chấp nhận câu trả lời vào thứ Hai, ngày 15/2/2016. Có thể các byte được bao giờ có lợi cho bạn!

Trong thử thách "In chuỗi N-Bonacci" của mình , @DJMcGoathem mô tả các chuỗi N-bonacci, trong đó các số N trước đó được tóm tắt, thay vì 2 chuỗi truyền thống (được gọi là " trình tự bộ đôi "). Sau đó, ông yêu cầu lấy hai đầu vào, X và N, sau đó sản lượng X thứ N số -nacci.

Tôi đề nghị ngược lại.
Cho một chuỗi, đầu ra mà chuỗi N -nacci nó là tập con của. Tôi nói "tập hợp con" bởi vì:

• A) các chuỗi này là vô hạn
• B) nếu được bắt đầu chuỗi, bạn có thể đếm số lượng 1 hàng đầu

Trong trường hợp nó có thể thuộc nhiều chuỗi N -nacci, hãy chọn chuỗi thấp nhất.
Trong trường hợp nó không thuộc về bất kỳ chuỗi N-nacci nào , thì chương trình của bạn có thể làm bất cứ điều gì khác ngoài việc in một cái gì đó có thể bị nhầm thành đầu ra. Những hành vi này bao gồm (nhưng không giới hạn): vòng lặp vô hạn, lỗi, sự cố, tự xóa (* ho * cảnh giác * ho ho *) hoặc tạo ra một lỗ đen (miễn là lỗ đen này không tạo ra bất cứ thứ gì có thể bị nhầm với đầu ra hợp lệ).
Vì lợi ích của thử thách này, những chuỗi bắt đầu với 1. Đây có nghĩa là bất kỳ N chuỗi -nacci bắt đầu với N người. Hơn nữa, Nphải là một số nguyên dương. Vì vậy, không -1 -nacci, v.v.

Các trường hợp thử nghiệm:

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

Tôi khá ngạc nhiên khi tôi có thể chơi golf này trong cùng một thuật toán! Tôi bắt đầu với hơn 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}}

Ung dung:

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 byte

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;

Lưu ý rằng điều này yêu cầu đầu vào ở định dạng này:

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

thay vì

1, 1, 2, 3...

Giải pháp khá đơn giản, chỉ để mọi thứ lăn lộn. Tôi sẽ làm việc nhiều hơn với việc đánh gôn xuống khi có người khác trả lời. Điều này sử dụng một phiên bản sửa đổi một chút của trình tạo N-Bonaci từ câu trả lời của @ Data , do đó, đạo cụ cho anh ta. Sau đó, đối với mỗi N-Bonaci trong phạm vi đầu vào, hãy kiểm tra xem đầu vào có phải là con của nó không.

Lua, 324 323 byte

Khi tôi thấy đệ trình khác, tôi cảm thấy có gì đó không đúng với mã của mình ... Nhưng sau đó, tôi nhớ đó là Lua và không có tất cả các chức năng ưa thích này: '(

Đó là rất nhiều niềm vui, thực sự đã cho tôi một thời gian.

Chỉnh sửa: Đã lưu 1 byte với một mẹo đơn giản: sử dụng dấu ::label::+ goto labelthay vì vòng lặp vô hạn được thực hiện với 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 và giải thích

Lua không có cách nào để xác định một tập hợp, tập hợp con hoặc thậm chí kiểm tra xem một mảng / bảng có chứa một giá trị mà không sử dụng chỉ mục / khóa của nó hay không. Đó là lý do tại sao tôi quyết định loại bỏ các phần tử khỏi mảng mà tôi lấy làm tham số. đó là cách tôi ghi lại những yếu tố nào đã được tính toán và nếu nó phù hợp.

  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

Bạn có thể thử Lua trực tuyến và bạn có thể sao chép / dán mẫu mã sau để chạy một số thử nghiệm. Khi hàm này thoát khi tìm thấy câu trả lời (vòng lặp vô hạn khác), bạn sẽ phải thay đổi chỉ mục test[]được sử dụng (đừng quên lua là 1 chỉ mục :)).

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