编写程序或命名函数，该程序或函数将输出或返回序列，直到nIccanobif序列中的第th个整数，在OEIS上记录为A014258。请注意，0如果n为零，则仅打印序列（）中的第零个元素。

该序列是通过像标准Fibonacci序列一样开始而生成的，但是在将前两个数字相加后，可以翻转结果并删除所有前导零。至少对我而言，一个有趣的事实是该序列没有严格增加（请参见下面的列表）。它似乎也（可能）严格大于或等于斐波那契数列。

程序的输入必须是整数。

为了您的观看乐趣，此处提供了序列的前20个数字：

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

禁止出现标准漏洞。

最短的程序获胜。

编辑：添加了一条注释，以澄清该序列从第零个元素开始，如果n为零，则应包括在内。

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]

现在有几个答案，下面是我在Python 2中通过标记努力隐藏的实现：

迭代式：

＃最接近我的初始程序。73个字节 还应注意，该程序
 无法达到堆栈溢出。它在不到10秒的时间内运行n = 5000。

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

递归：

＃注意，这会打印n结尾的换行符。64个字节。
 对于较大的n值，将遇到堆栈溢出错误。

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

佩斯，17 15 14

Pu+Gs_`s>2GQU2

在线尝试

非常基本的实现，首先range(2)添加等于输入的元素，然后添加多个元素，然后将多余的部分切掉，最后一个元素弹出。

感谢@Jakube指出了>逆转事情。

说明

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个字节

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

用于str转换而不是反引号，因为Python 2中足够大的数字以结尾的L编写。我尝试了一个递归函数，但结果更长了（61）：

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

朱莉娅79字节

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

这将创建一个接受整数作为输入并返回整数数组的函数。

取消+说明：

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

例子：

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

非常简单的内联表函数，它使用递归CTE查询。由于它使用的是INT，因此最高可达37。为bigints添加CAST将使它进一步发展到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

它的用法如下

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字节

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

对“ 无臭循环 ”示例之一的简单修改。

该短语.|$将数字转换为字符串，将其取反然后求值。

编辑：

我对边界条件草率地关注。现在更正确：

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

编辑2：

(x+1)#可以替换为-1_，节省2个字符。该空间是必需的，因为_x当我希望将“ drop”运算符应用于名为的变量时，否则将是标识符x。

哈斯克尔， 64个 49字节

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

用法示例：q 15->[0,1,1,2,3,5,8,31,93,421,415,638,3501,9314,51821,53116]

工作原理：!以第一个参数（第二个参数必须是下一个iccanobif编号）开头递归构建iccanobif编号的无限列表。q取第一n从iccanobif列表开始与数字1, 1，并预置一个0。

CJam，18个字节

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

怎么运行的

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

在这里在线尝试

Java- 126 124

我有一段时间没有在这个网站上看到Java了...

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

SWI-Prolog的，141个 131 121字节

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).输出：

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

a(10000,X).在我的计算机上输出结果大约需要10秒钟。

编辑：上面的121字节版本是一个谓词定义=一个衬里。旧的131字节版本如下（必须以方式运行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).

> <>（鱼） 592254字节

不是超级高尔夫球手（42/43空白不执行任何操作，总共执行30个重定向令牌），但是让它首先工作是一个有趣的练习。

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

您可以在此处进行测试，并在初始堆栈中提供所需的长度。

编辑：字节数减半

PHP，114，109个字节

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

没什么，只是一个普通的斐波那契算法与字符串反向魔术。

取消高尔夫：

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个字节

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

运行宏将提示用户输入n的值。

然后，结果将在A列中逐行打印：

JavaScript（ES2015），81 73字节

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

使用来运行此功能（名为f）6：

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

点，13字节

我很确定在问这个问题之前，该程序中使用的所有功能都已存在于Pip中。

LaSio:+RVi+oi

将输入作为命令行参数。在线尝试！

说明

               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

这两个变量的值演变如下：

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字节（非竞争）

Z1{:2d+vFs@KjkvF;_

在线尝试！

它不是最优雅的程序，但是可以工作。

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.

果冻，9字节（无竞争）

0+ṚV$¥Ð¡1

在线尝试！

R，134个字节

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

例：

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

很想看看是否有人有一个更好的R替代方法，而不是将您的数字取为字符串，将其取反，然后将其重新转换为数字。

Groovy，70个字节

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