Escriba un programa o función con nombre que generará o devolverá la secuencia hasta el nnúmero entero en la secuencia Iccanobif, documentada en OEIS como A014258 . Tenga en cuenta que solo 0se imprimirá el elemento cero en la secuencia ( ) si nes cero.

La secuencia se genera comenzando como la secuencia estándar de Fibonacci, pero después de sumar los dos números anteriores, cambia el resultado y elimina los ceros iniciales. Un hecho interesante, al menos para mí, es que esta secuencia no está aumentando estrictamente (ver la lista a continuación). También parece ser (y probablemente sea) estrictamente mayor o igual que la secuencia de Fibonacci.

La entrada de su programa debe ser un número entero.

Los primeros 20 números de la secuencia se proporcionan aquí para su placer visual:

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

Las lagunas estándar están prohibidas.

El programa más corto gana.

EDITAR: se agregó una nota para aclarar que la secuencia comienza con el elemento cero y debe incluirse si nes cero.

Ejemplo de posibilidades de 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]

Ahora que hay varias respuestas, a continuación están mis implementaciones en Python 2 que trabajé duro para ocultar con el marcado:

Iterativo:

#Cerca de mi programa inicial. 73 bytes. También debe tenerse en cuenta que este programa
 No se puede alcanzar un desbordamiento de pila. Se ejecuta para n = 5000 en menos de 10 segundos.

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

Recursivo:

# Tenga en cuenta que esto imprime las nnuevas líneas finales. 64 bytes.
 Llegará a un error de desbordamiento de pila para valores grandes de 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

Pruébalo en línea

Implementación muy básica, comienza con range(2)y agrega una cantidad de elementos igual a la entrada, luego corta los extras que aparecen en el último elemento.

Gracias @Jakube por señalar la >cosa de la inversión.

Explicación

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 bytes

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

Utiliza strpara convertir en lugar de backticks porque los números lo suficientemente grandes en Python 2 se escriben con una L al final. Intenté una función recursiva, pero resultó más larga (61):

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

Julia, 79 bytes

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

Esto crea una función que acepta un entero como entrada y devuelve una matriz de enteros.

Ungolfed + explicación:

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

Ejemplos:

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

Función de tabla en línea muy sencilla que utiliza una consulta CTE recursiva. Como está usando INTs, esto alcanzará un máximo de 37. Agregar CASTs para bigints le permitirá ir más allá de 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

Se usa de la siguiente manera

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 bytes

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

Una modificación simple de uno de los ejemplos en No Stinking Loops .

La frase .|$arroja un número a una cadena, lo invierte y luego lo evalúa.

Editar:

Atención descuidada a las condiciones de contorno de mi parte. Más correcto ahora:

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

Edición 2:

(x+1)#se puede reemplazar con -1_, guardando 2 caracteres. El espacio es necesario porque de lo contrario _xsería un identificador, cuando quiero que el operador "soltar" se aplique a una variable llamada x.

Haskell, 64 49 bytes

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

Ejemplo de uso: q 15->[0,1,1,2,3,5,8,31,93,421,415,638,3501,9314,51821,53116]

Cómo funciona: !construye recursivamente una lista infinita de números de iccanobif comenzando con su primer argumento (el segundo argumento debe ser el siguiente número de iccanobif). qtoma los primeros nnúmeros de la lista iccanobif que comienzan con 1, 1y antepone a 0.

CJam, 18 bytes

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

Cómo funciona

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

Pruébalo en línea aquí

Java - 126 124

No he visto Java en este sitio desde hace un tiempo ...

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) huellas dactilares 0 1 1 2 3 5 8 31 93 421 415 638

SWI-Prolog, 141 131 121 bytes

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).Salidas corrientes :

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

Toma alrededor de 10 segundos para mostrar el resultado a(10000,X).en mi computadora.

Editar: La versión de 121 bytes anterior es una definición de un predicado = un revestimiento. La versión anterior de 131 bytes es la siguiente (debe ejecutarse como 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).

> <> (Pez) 592254 Bytes

No super golf (42/43 espacios en blanco que no hacen nada y un total de 30 tokens de redireccionamiento), pero fue un ejercicio interesante para que funcione en primer lugar.

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{~~~{/

Puede probarlo aquí , proporcionando la longitud deseada en la pila inicial.

EDITAR: recuento de bytes más de la mitad

PHP, 114 , 109 bytes

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;}

Nada de lujos, solo un algoritmo promedio de Fibonacci con la magia inversa de la cuerda.

Sin golf:

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 bytes

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

La ejecución de la macro solicitará al usuario que ingrese un valor para n.

Los resultados se imprimirán fila por fila en la columna A:

JavaScript (ES2015), 81 73 bytes

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

Ejecutando esta función (nombrada f) con 6:

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

Pip , 13 bytes

Estoy bastante seguro de que todas las características utilizadas en este programa estaban presentes en Pip antes de que se hiciera esta pregunta.

LaSio:+RVi+oi

Toma entrada como argumento de línea de comando. Pruébalo en línea!

Explicación

               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

Los valores de las dos variables evolucionan así:

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 bytes (no competidor)

Z1{:2d+vFs@KjkvF;_

Pruébalo en línea!

No es el más elegante de los programas, pero funciona.

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.

Gelatina , 9 bytes (no competitiva)

0+ṚV$¥Ð¡1

Pruébalo en línea!

R, 134 bytes

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

Ejemplo:

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

Me encantaría ver si alguien tiene una mejor alternativa R que tomar su número, convertirlo en una cadena, invertirlo y volverlo a convertir en un número nuevamente.

Groovy, 70 bytes

{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.
}