Escreva um programa ou função nomeada que produzirá ou retornará a sequência até o nnúmero inteiro na sequência Iccanobif, documentada no OEIS como A014258 . Observe que apenas o elemento zeroth na sequência ( 0) será impresso se nfor zero.

A sequência é gerada iniciando como a sequência padrão de Fibonacci, mas após adicionar os dois números anteriores, você inverte o resultado e elimina os zeros à esquerda. Um fato interessante, pelo menos para mim, é que essa sequência não está aumentando estritamente (veja a lista abaixo). Também parece ser (e provavelmente é) estritamente maior ou igual à sequência de Fibonacci.

A entrada do seu programa deve ser um número inteiro.

Os primeiros 20 números da sequência são fornecidos aqui para seu prazer visual:

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

As brechas padrão são proibidas.

O programa mais curto vence.

EDIT: Adicionada uma nota para esclarecer que a sequência começa com o elemento zeroth e deve ser incluída se nfor zero.

Exemplo de possibilidades de E / S:

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]

Agora que existem várias respostas, abaixo estão minhas implementações no Python 2 que trabalhei duro para ocultar com a marcação:

Iterativo:

#Mais próximo ao meu programa inicial. 73 bytes. Note-se também que este programa
 não pode atingir um estouro de pilha. É executado por n = 5000 em 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:

# Observe que isso imprime nnovas linhas à direita. 64 bytes.
 Acertará um erro de estouro de pilha 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'';

Pitão, 17 15 14

Pu+Gs_`s>2GQU2

Experimente online

A implementação muito básica, começa com range(2)e adiciona um número de elementos igual à entrada e, em seguida, corta os extras e sai do último elemento.

Obrigado @Jakube por apontar a >reversão.

Explicação

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

Usa strpara converter em vez de backticks, porque números grandes o suficiente no Python 2 são escritos com um L no final. Tentei uma função recursiva, mas ficou mais tempo (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])

Isso cria uma função que aceita um número inteiro como entrada e retorna uma matriz inteira.

Ungolfed + explicação:

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

Exemplos:

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

Função de tabela embutida muito direta que usa uma consulta CTE recursiva. Como ele está usando INTs, esse valor chega a 37. A adição de CASTs para bigints permitirá que ele vá além 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

É usado da seguinte maneira

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}

Uma modificação simples de um dos exemplos em No Stinks Loops .

A frase .|$converte um número em uma sequência, reverte-a e depois avalia-a.

Editar:

Atenção desleixada às condições de contorno da minha parte. Mais correto agora:

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

Edição 2:

(x+1)#pode ser substituído por -1_, salvando 2 caracteres. O espaço é necessário porque, caso contrário, _xseria um identificador, quando eu quero que o operador "drop" seja aplicado a uma variável chamada x.

Haskell, 64 49 bytes

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

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

Como funciona: !cria recursivamente uma lista infinita de números do iccanobif começando com seu primeiro argumento (o segundo argumento deve ser o próximo número do iccanobif). qpega os primeiros nnúmeros da lista iccanobif começando com 1, 1e precede a 0.

CJam, 18 bytes

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

Como 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

Experimente online aqui

Java - 126 124

Eu não vejo Java em torno deste site há algum tempo ...

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) impressões 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).Saídas em execução :

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

Demora cerca de 10 segundos para produzir o resultado a(10000,X).no meu computador.

Edit: A versão de 121 bytes acima é uma definição de um predicado = um forro. A versão antiga de 131 bytes é a seguinte (deve ser executada 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).

> <> (Peixe) 592 254 bytes

Não era super golfista (42/43 espaços em branco que não fazem nada e um total de 30 tokens de redirecionamento), mas foi um exercício interessante para fazê-lo funcionar em primeiro 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{~~~{/

Você pode testá-lo aqui , fornecendo o comprimento desejado na pilha inicial.

EDIT: Mais do que a contagem de bytes pela metade

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 extravagante, apenas um algoritmo médio de fibonacci com a mágica reversa de cordas.

Ungolfed:

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

A execução da macro solicitará que o usuário insira um valor para n.

Os resultados serão impressos linha por linha na coluna A:

JavaScript (ES2015), 81 73 bytes

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

Executando esta função (nomeada f) com 6:

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

Pip , 13 bytes

Tenho certeza de que todos os recursos usados ​​neste programa estavam presentes no Pip antes que essa pergunta fosse feita.

LaSio:+RVi+oi

Recebe entrada como argumento da linha de comando. Experimente online!

Explicação

               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

Os valores das duas variáveis ​​evoluem da seguinte forma:

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 (não concorrente)

Z1{:2d+vFs@KjkvF;_

Experimente online!

Não é o mais elegante dos programas, mas 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 (não concorrente)

0+ṚV$¥Ð¡1

Experimente online!

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

Exemplo:

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

Gostaria de ver se alguém tem uma alternativa R melhor do que pegar seu número, transformá-lo em uma string, inverter e transformá-lo novamente em um número novamente.

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