EDIT: J'accepterai une réponse le lundi 15/02/2016. Que les octets soient toujours en votre faveur!

Dans son défi "Imprimer la séquence N-Bonacci" , @DJMcGoathem décrit les séquences N-bonacci, dans lesquelles les nombres N précédents sont additionnés, au lieu des 2 traditionnels de la séquence Fibonacci (qui serait la " séquence duo nacci"). Il a ensuite demandé de prendre deux entrées, X et N, puis de sortir le X e N -nacci.

Je propose le contraire.
Étant donné une séquence, affichez la séquence N -nacci dont elle est un sous-ensemble. Je dis "sous-ensemble de" parce que:

• A) ces séquences sont infinies
• B) si donné le début de la séquence, vous pouvez simplement compter le nombre de 1 en tête

Dans le cas où il pourrait appartenir à plusieurs séquences N- nacci, choisissez la plus basse.
Dans le cas où il n'appartient à aucune séquence N-nacci , votre programme peut faire autre chose que d'imprimer quelque chose qui pourrait être confondu avec la sortie. Ces comportements incluent (mais ne sont pas limités à): boucle infinie, erreur, crash, se supprimer (* toux toux * vigil * toux toux *), ou créer un trou noir (tant que ce trou noir ne produit rien qui pourrait être confondu avec une sortie valide).
Pour relever ce défi, ces séquences commencent par 1. Cela signifie que toute séquence N- nacci commence par N unités . De plus, N doit être un entier positif. Donc pas de -1 -acci, etc.

Cas de test:

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

Rubis, 94

Je suis assez surpris de voir jusqu'où j'ai pu jouer au golf avec le même algorithme! J'ai commencé avec plus de 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}}

Non golfé:

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 octets

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;

Notez que cela nécessite une entrée dans ce format:

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

plutôt que

1, 1, 2, 3...

Solution assez simple, juste pour faire avancer les choses. Je travaillerai davantage sur le golf une fois que quelqu'un d'autre aura répondu. Cela utilise une version légèrement modifiée du générateur N-Bonnaci de la réponse de @ Data , donc accessoires pour lui. Ensuite, pour chaque N-Bonnaci dans la plage de l'entrée, vérifie si l'entrée en est une sous-séquence.

Lua, 324 323 octets

Quand je vois une autre soumission, j'ai l'impression qu'il y a quelque chose qui ne va pas avec mon code ... Mais alors, je me souviens que c'est Lua, et il n'y a pas toutes ces fonctionnalités fantaisistes: '(

C'était très amusant, ça m'a pris du temps en fait.

Edit: 1 octet enregistré avec une astuce simple: en utilisant un ::label::+ à la goto labelplace d'une boucle infinie effectuée avec 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

Non golfé et explications

Lua n'a aucun moyen de définir un ensemble, un sous-ensemble ou même de vérifier si un tableau / table contient une valeur sans utiliser son index / clé. C'est pourquoi j'ai décidé de supprimer des éléments du tableau que je prends comme paramètre. c'est ainsi que je garde la trace des éléments qui ont déjà été calculés et s'ils correspondent.

  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

Vous pouvez essayer Lua en ligne et vous pouvez copier / coller l'exemple de code suivant pour exécuter des tests. Comme cette fonction se termine lorsqu'elle trouve la réponse (boucle infinie sinon), vous devrez changer l'index test[]utilisé (n'oubliez pas que lua est 1-indexé :)).

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