EDYCJA: Przyjmę odpowiedź w poniedziałek, 15.02.2016. Niech bajty będą zawsze na twoją korzyść!

W swoim wyzwaniu „Print the N-Bonacci Sequence” @DJMcGoathem opisuje sekwencje N-bonacci, w których sumuje się poprzednie liczby N , zamiast tradycyjnych 2 sekwencji Fibonacciego (mówi się, że jest to „ sekwencja duo nacci”). Następnie poprosił o wzięcie dwóch sygnałów wejściowych, X i N, a następnie wypisanie X- tej liczby N- nacci.

Proponuję coś przeciwnego.
Biorąc pod uwagę sekwencję, wyjście, której N -sekwencja jest podzbiorem. Mówię „podzbiór”, ponieważ:

• A) sekwencje te są nieskończone
• B) jeśli podano początek sekwencji, możesz po prostu policzyć liczbę wiodących 1

W przypadku, gdy może należeć do wielu sekwencji N- nacci, wybierz najniższą.
W przypadku, gdy nie należy on do żadnej sekwencji N-nacci , twój program może zrobić cokolwiek innego niż wydrukować coś, co można pomylić z wyjściem. Zachowania te obejmują między innymi: nieskończoną pętlę, błąd, awarię, usunięcie samego siebie (* kaszel * czuwanie * kaszel *) lub tworzenie czarnej dziury (o ile ta czarna dziura nie wytwarza niczego, co mogłoby pomylić z prawidłowym wyjściem).
Przez wzgląd na to wyzwanie, te sekwencje zacząć 1. Oznacza to jakieś N -nacci sekwencja zaczyna się od N nich. Ponadto N. musi być dodatnią liczbą całkowitą. Więc nie -1-nacci itp.

Przypadki testowe:

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

Jestem dość zaskoczony, jak daleko udało mi się zagrać w golfa w ramach tego samego algorytmu! Zacząłem z ponad 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}}

Nie golfowany:

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 bajtów

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;

Pamiętaj, że wymaga to wprowadzenia danych w tym formacie:

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

zamiast

1, 1, 2, 3...

Dość proste rozwiązanie, tylko po to, aby wszystko działało. Popracuję nad golfem, gdy ktoś inny odpowie. To używa nieco zmodyfikowanej wersji generatora N-Bonnaci z odpowiedzi @ Data , więc mu się podoba . Następnie dla każdego N-Bonnaci w zakresie danych wejściowych sprawdza, czy dane wejściowe są jego podsekwencją.

Lua, 324 323 bajtów

Kiedy widzę inne przesłanie, mam wrażenie, że coś jest nie tak z moim kodem ... Ale potem pamiętam, że to Lua i nie ma tych wszystkich wymyślnych funkcji: ”(

To była świetna zabawa, właściwie zajęło mi to trochę czasu.

Edycja: Zapisano 1 bajt za pomocą prostej sztuczki: używając ::label::+ goto labelzamiast nieskończonej pętli zakończonej 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

Niegolfowane i objaśnienia

Lua nie ma sposobu na zdefiniowanie zestawu, podzbioru, a nawet sprawdzenie, czy tablica / tabela zawiera wartość bez użycia jej indeksu / klucza. Właśnie dlatego postanowiłem usunąć elementy z tablicy, którą biorę jako parametr. w ten sposób rejestruję, które elementy zostały już obliczone i czy pasowały.

  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

Możesz wypróbować Lua online , a także skopiować / wkleić poniższy przykład kodu, aby uruchomić niektóre testy. Ponieważ ta funkcja kończy działanie, gdy znajdzie odpowiedź (w przeciwnym razie nieskończona pętla), będziesz musiał zmienić indeks test[]używanego (nie zapomnij, że lua ma indeks 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]))