Napisz program lub nazwaną funkcję, która wyświetli lub zwróci sekwencję do nczwartej liczby całkowitej w sekwencji Iccanobif, udokumentowanej w OEIS jako A014258 . Zauważ, że tylko zero elementu w sekwencji ( 0) zostanie wydrukowane, jeśli nwynosi zero.

Sekwencję generuje się, zaczynając od standardowej sekwencji Fibonacciego, ale po dodaniu dwóch poprzednich liczb odwracasz wynik i upuszczasz zera wiodące. Ciekawym faktem, przynajmniej dla mnie, jest to, że ta sekwencja nie zwiększa się ściśle (patrz lista poniżej). Wydaje się również, że jest (i prawdopodobnie jest) ściśle większa lub równa sekwencji Fibonacciego.

Dane wejściowe programu muszą być liczbą całkowitą.

Pierwsze 20 numerów sekwencji podano tutaj dla Twojej przyjemności oglądania:

0, 1, 1, 2, 3, 5, 8, 31, 93, 421, 415, 638, 3501, 9314, 51821, 53116, 739401, 715297, 8964541, 8389769

Standardowe luki są zabronione.

Najkrótszy program wygrywa.

EDYCJA: Dodano notatkę wyjaśniającą, że sekwencja zaczyna się od elementu zerowego i powinna być uwzględniona, jeśli nwynosi zero.

Przykładowe możliwości IO:

0    ->    0
1    ->    0 1
6    ->    0 1 1 2 3 5 8
17   ->    [0, 1, 1, 2, 3, 5, 8, 31, 93, 421, 415, 638, 3501, 9314, 51821, 53116, 739401, 715297]

Teraz, gdy jest kilka odpowiedzi, poniżej są moje implementacje w Pythonie 2, które ciężko pracowałem, aby ukryć za pomocą znaczników:

Wielokrotny:

# Najbliżej mojego początkowego programu. 73 bajty. Należy również zauważyć, że ten program
 nie można osiągnąć przepełnienia stosu. Działa przez n = 5000 w mniej niż 10 sekund.

i,a,b=input(),0,1
print a
while i:print b;i,a,b=i-1,b,int(str(a+b)[::-1])

Rekurencyjne:

# Zauważ, że to drukuje nkońcowe znaki nowej linii. 64 bajty.
 Uderzy błąd przepełnienia stosu dla dużych wartości n.

def f(n,i=0,j=1):print i,n and f(n-1,j,int(str(i+j)[::-1]))or'';

Pyth, 17 15 14

Pu+Gs_`s>2GQU2

Wypróbuj online

Bardzo podstawowa implementacja, zaczyna się od range(2)i dodaje liczbę elementów równą wartości wejściowej, a następnie odcina dodatki odskakuje od ostatniego elementu.

Dzięki @Jakube za wskazanie sprawy >odwrócenia.

Wyjaśnienie

Pu+Gs_`s>2GQU2    : Q = eval(input) (implicit)
P                 : all but the last element
 u         QU2    : reduce Q times starting with [0, 1]
  +G              : add to the previous result
       s>2G       : sum of the last two elements of G
    s_`           : int(reversed(repr(above value)))

Python 2, 58 bajtów

a=0;b=1
exec"print a;a,b=b,int(str(a+b)[::-1]);"*-~input()

Używa strdo konwersji zamiast odwrotnych, ponieważ wystarczająco duże liczby w Pythonie 2 są napisane z literą L na końcu. Próbowałem funkcji rekurencyjnej, ale okazało się to dłużej (61):

f=lambda n,a=0,b=1:-~n*[0]and[a]+f(n-1,b,int(str(a+b)[::-1]))

Julia, 79 bajtów

f=n->(t=[0,1];for i=2:n push!(t,t[i]+t[i-1]|>string|>reverse|>int)end;t[1:n+1])

Tworzy to funkcję, która przyjmuje liczbę całkowitą jako dane wejściowe i zwraca tablicę liczb całkowitych.

Niegolfowane + wyjaśnienie:

function f(n)
    # Start with the usual Fibonacci stuff
    t = [0,1]

    # Looooooooooooooop
    for i = 2:n
        # Compute the Iccanobif number by piping results
        iccanobif = t[i] + t[i-1] |> string |> reverse |> int

        # Jam it into t
        push!(t, iccanobif)
    end

    # Return the first n + 1
    t[1:n+1]
end

Przykłady:

julia> f(1)
2-element Array{Int64,1}:
 0
 1

julia> f(17)
18-element Array{Int64,1}:
      0
      1
      1
      2
      3
      5
      8
     31
     93
    421
    415
    638
   3501
   9314
  51821
  53116
 739401
 715297

T-SQL, 149

Bardzo prosta funkcja wbudowanej tabeli, która wykorzystuje rekurencyjne zapytanie CTE. Ponieważ używa INTów, osiągnie limit 37. Dodanie CAST dla bigintów pozwoli mu pójść dalej do 63

create function i(@ int)returns table return with r as(select 0I,1N union all select n,reverse(i+n)+0from r)select 0n union all select top(@)n from r

Używa się go w następujący sposób

select * from i(0)
n
-----------
0

(1 row(s) affected)

select * from i(1)
n
-----------
0
1

(2 row(s) affected)

select * from i(6)
n
-----------
0
1
1
2
3
5
8

(7 row(s) affected)

select * from i(17)
n
-----------
0
1
1
2
3
5
8
31
93
415
421
638
3501
9314
51821
53116
715297
739401

(18 row(s) affected)

K, 25 23 bajtów

{-1_ x{x,.|$+/-2#x}/!2}

Prosta modyfikacja jednego z przykładów w No Stinking Loops .

Fraza .|$rzuca liczbę na ciąg, odwraca ją, a następnie ocenia.

Edytować:

Niechlujna uwaga z mojej strony na warunki brzegowe. Bardziej poprawne teraz:

  {-1_ x{x,.|$+/-2#x}/!2}'0 1 6 10
(,0
 0 1
 0 1 1 2 3 5 8
 0 1 1 2 3 5 8 31 93 421 415)

Edycja 2:

(x+1)#można zastąpić -1_, oszczędzając 2 znaki. Spacja jest konieczna, ponieważ w przeciwnym razie _xbyłby to identyfikator, gdy chcę, aby operator „upuść” zastosował zmienną o nazwie x.

Haskell, 64 49 bajtów

a!b=a:b!(read$reverse$show$a+b)
q n=0:take n(1!1)

Przykład użycia: q 15->[0,1,1,2,3,5,8,31,93,421,415,638,3501,9314,51821,53116]

Jak to działa: !rekurencyjnie buduje nieskończoną listę liczb iccanobif, zaczynając od pierwszego argumentu (drugi argument musi być kolejnym numerem iccanobif). qpobiera pierwsze nliczby z listy iccanobif zaczynając od 1, 1i poprzedza a 0.

CJam, 18 bajtów

U1{_2$+sW%i}ri*;]p

Jak to działa

U1                      e# First two numbers in the series
  {        }ri*         e# Run the loop input numbers times
   _2$+                 e# Get sum of last two numbers in the series
       sW%i             e# Convert to string, inverse and convert back to a number
                ;       e# Remove the last number to get only first n + 1 numbers.
                 ]p     e# Wrap all numbers in an array and print the array

Wypróbuj online tutaj

Java - 126 124

Od jakiegoś czasu nie widziałem Java w tej witrynie ...

void f(int b){for(int c=0,d=1,g;b-->=0;d=Integer.valueOf(new StringBuilder(c+(c=d)+"").reverse()+""))System.out.println(c);}

f(5) odbitki 0 1 1 2 3 5 8 31 93 421 415 638

SWI-Prolog, 141 131 121 bajtów

a(X,R):-X>1,A is X-1,a(A,B),reverse(B,[K,L|_]),W is K+L,name(W,Z),reverse(Z,Y),name(E,Y),nth0(X,R,E,B);X=1,R=[0,1];R=[0].

a(17,X).Wyjścia bieżące :

[0, 1, 1, 2, 3, 5, 8, 31, 93, 421, 415, 638, 3501, 9314, 51821, 53116, 739401, 715297] 

Wydrukowanie wyniku a(10000,X).na moim komputerze zajmuje około 10 sekund .

Edycja: 121-bajtowa wersja powyżej jest definicją jednego predykatu = jedna linijka. Stara 131 bajtowa wersja jest następująca (należy ją uruchomić jako p(17,X)):

a(0,[0]).
a(1,[1,0]).
a(X,[E|B]):-A is X-1,a(A,B),B=[K,L|_],W is K+L,name(W,Z),reverse(Z,Y),name(E,Y).
p(X,Y):-a(X,Z),reverse(Z,Y).

> <> (Ryby) 592 254 Bajtów

Nie super golfa (42/43 blanki, które nic nie robią i łącznie 30 żetonów przekierowania), ale było ciekawym ćwiczeniem, które sprawiło, że zadziałało.

10!/{:}0=?v/{1-}}:{+:0}!/a,:1%-:0=?!v~{:1!/$:@0=?!v$~}}:&{{&*\
/-$/    ;n/\oo", "n:    \       }+1{/     \$-1$*a /|.!20}}01@/
* :{:}(?v:{!":}-1!/$:@0=?!v$~{:}1!/$:@0=?!v$~}}}:&{{{&*:1%-*&{{&+}}{1+}02.
b .1 +bb   \      \$-1$*a /       \$-1$,a /
\*9{~~~{/

Możesz to przetestować tutaj , podając pożądaną długość w początkowym stosie.

EDYCJA: Liczba bajtów większa niż o połowę

PHP, 114 , 109 bajtów

function f($n){if($n==0)return 0;$f=[0,1];for($i=2;$i<=$n;++$i){$f[$i]=strrev($f[$i-1]+$f[$i-2]);}return $f;}

Nic szczególnego, tylko przeciętny algorytm Fibonacciego z odwrotną magią strun.

Nie golfowany:

function f($n)
{
    if($n == 0) return 0;
    $f = [0, 1];
    for ($i=2; $i<=$n; ++$i){
        $f[$i] = strrev($f[$i-1] + $f[$i-2]);
    }
    return $f;
}

Excel VBA, 279 bajtów

n = InputBox("n")
For i = 0 To n
If i < 2 Then
Cells(i + 1, 1) = i
ElseIf i > 6 Then
x = Cells(i, 1) + Cells(i - 1, 1)
l = Len(x)
v = CStr(x)
For j = 1 To l
r = r + Right(v, 1)
v = Left(v, l - j)
Next j
Cells(i + 1, 1) = r
r = ""
Else
Cells(i + 1, 1) = Cells(i, 1) + Cells(i - 1, 1)
End If
Next i

Uruchomienie makra poprosi użytkownika o wprowadzenie wartości n.

Wyniki zostaną następnie wydrukowane wiersz po wierszu w kolumnie A:

JavaScript (ES2015), 81 73 bajtów

(a,b=0,c=1)=>{for(;a-->-1;c=[...(b+(b=+c)+"")].reverse().join``)alert(b)}

Uruchamianie tej funkcji (o nazwie f) z 6:

f(6);// alerts: 0, 1, 1, 2, 3, 5, 8

Pip , 13 bajtów

Jestem prawie pewien, że wszystkie funkcje użyte w tym programie były obecne w Pipie przed zadaniem tego pytania.

LaSio:+RVi+oi

Pobiera dane wejściowe jako argument wiersza polecenia. Wypróbuj online!

Wyjaśnienie

               a is 1st cmdline arg; i is 0; o is 1 (implicit)
La             Loop (a) times:
       RVi+o   Reverse of i+o
      +        Unary + treats its operand as a number, thus removing leading 0's
    o:         Assign the result to o...
  Si           ... before swapping i and o
            i  After the loop, output i

Wartości dwóch zmiennych ewoluują tak:

Iter   o   i (output)
   0   1   0
   1   0   1
   2   1   1
   3   1   2
   4   2   3
   5   3   5
   6   5   8
   7   8  31
   8  31  93
   9  93 421
  10 421 415

Pushy , 18 bajtów (niekonkurencyjny)

Z1{:2d+vFs@KjkvF;_

Wypróbuj online!

To nie jest najbardziej elegancki program, ale działa.

Z1     \ Push 0 and 1 to begin the sequence
{:     \ Input times do:
 2d+   \   Add the last two terms
 vF    \   Send to second stack
 s     \   Split into digits
 @Kjk  \   Reverse and join into one number
 vF;    \   Send back to first stack
_      \ At the end of the program, print the whole stack.

Galaretka , 9 bajtów (niekonkurencyjna)

0+ṚV$¥Ð¡1

Wypróbuj online!

R, 134 bajty

i=function(n){s=c(0,1);for(i in 3:n){s[i]=as.numeric(paste0(rev(strsplit(as.character(s[i-2]+s[i-1]),'')[[1]]),collapse=''))};cat(s)}

Przykład:

> i(10)
0 1 1 2 3 5 8 31 93 421

Chciałbym zobaczyć, czy ktoś ma lepszą alternatywę R niż wziąć twój numer, uczynić z niego ciąg znaków, odwrócić go i ponownie zamienić z powrotem na liczbę.

Groovy, 70 bajtów

{r={"$it".reverse() as int};f={n->n<3?1:r(f(n-1))+r(f(n-2))};r(f(it))}

{
    r={"$it".reverse() as int};       // Reverse digits, costly using string.
    f={n->n<3?1:r(f(n-1))+r(f(n-2))}; // Recursive Iccanobbif implementation.
    r(f(it))                          // Reverse final output.
}