EDIT: Ich werde eine Antwort Montag, 15.02.2016 akzeptieren. Mögen die Bytes immer zu Ihren Gunsten sein!

In seiner Challenge "Print the N-Bonacci Sequence" beschreibt @DJMcGoathem die N-Bonacci-Sequenzen, wobei die vorherigen N- Zahlen anstelle der traditionellen 2 der Fibonacci-Sequenz (die als " Duo- Nacci-Sequenz" bezeichnet wird) summiert werden. Er bat dann, zwei Eingaben zu nehmen, X und N, und dann die X- te N- Ncci-Zahl auszugeben.

Ich schlage das Gegenteil vor.
Bei gegebener Sequenz wird ausgegeben, von welcher N- NACCI-Sequenz sie eine Teilmenge ist. Ich sage "Teilmenge von", weil:

• A) Diese Sequenzen sind unendlich
• B) Wenn Sie den Beginn der Sequenz angeben, können Sie einfach die Anzahl der führenden Einsen zählen

Für den Fall, dass es zu mehreren N- NACCI-Sequenzen gehören könnte, wählen Sie die niedrigste aus.
In dem Fall, dass es zu keiner N-Nacci- Sequenz gehört, kann Ihr Programm etwas anderes tun, als etwas auszudrucken, das mit der Ausgabe verwechselt werden könnte. Zu diesen Verhaltensweisen gehören (ohne darauf beschränkt zu sein): Endlosschleife, Fehler, Absturz, Löschen (* Husten * Mahnwache * Husten *) oder Erstellen eines Schwarzen Lochs (solange dieses Schwarze Loch nichts produziert, was dies könnte) für eine gültige Ausgabe gehalten werden).
Aus diesem Grund beginnen diese Sequenzen mit 1. Dies bedeutet, dass jede N- NACCI-Sequenz mit N beginnt . Darüber hinaus ist Nmuss eine positive ganze Zahl sein. Also keine -1 -nacci usw.

Testfälle:

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

Ich bin ziemlich überrascht, wie weit ich das mit dem gleichen Algorithmus geschafft habe! Ich habe mit über 200 angefangen!

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

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;

Beachten Sie, dass hierfür Eingaben in folgendem Format erforderlich sind:

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

eher, als

1, 1, 2, 3...

Ziemlich einfache Lösung, nur um die Dinge ins Rollen zu bringen. Sobald jemand anders antwortet, werde ich mich mehr mit dem Golfspielen befassen. Dies verwendet eine leicht modifizierte Version des N-Bonnaci-Generators aus @Datas Antwort , so schlägt ihn. Dann wird für jeden N-Bonnaci im Bereich der Eingabe geprüft, ob die Eingabe eine Untersequenz davon ist.

Lua, 324 323 Bytes

Wenn ich andere Einsendungen sehe, habe ich das Gefühl, dass mit meinem Code etwas nicht stimmt ... Aber ich erinnere mich, dass das Lua ist, und es gibt nicht alle diese ausgefallenen Funktionen: '(

Es hat sehr viel Spaß gemacht, hat mich tatsächlich einige Zeit gekostet.

Bearbeiten: 1 Byte mit einem einfachen Trick gespeichert: Verwenden eines ::label::+ goto labelanstelle einer Endlosschleife mit 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 und Erklärungen

Lua hat keine Möglichkeit, eine Menge, eine Teilmenge oder auch nur zu überprüfen, ob ein Array / eine Tabelle einen Wert enthält, ohne seinen Index / Schlüssel zu verwenden. Aus diesem Grund habe ich mich entschieden, Elemente aus dem Array zu entfernen, das ich als Parameter nehme. Auf diese Weise kann ich aufzeichnen, welche Elemente bereits berechnet wurden und ob sie übereinstimmen.

  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

Sie können Lua online testen und das folgende Codebeispiel kopieren / einfügen, um einige Tests auszuführen. Da diese Funktion beendet wird, wenn sie die Antwort findet (ansonsten Endlosschleife), müssen Sie den verwendeten Index ändern test[](nicht vergessen, dass lua 1-indiziert ist :)).

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