Напишите программу или именованную функцию, которая будет выводить или возвращать последовательность с точностью до nцелого числа в последовательности Iccanobif, задокументированной в OEIS как A014258 . Обратите внимание, что только нулевой элемент в sequence ( 0) будет напечатан, если nравен нулю.

Последовательность генерируется, начиная со стандартной последовательности Фибоначчи, но после добавления двух предыдущих чисел вы переворачиваете результат и отбрасываете все ведущие нули. Интересный факт, по крайней мере для меня, заключается в том, что эта последовательность не увеличивается строго (см. Список ниже). Кажется также, что она (и, вероятно, есть) строго больше или равна последовательности Фибоначчи.

Ввод вашей программы должен быть целым числом.

Первые 20 номеров последовательности приведены здесь для вашего удобства просмотра:

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

Стандартные лазейки запрещены.

Кратчайшая программа выигрывает.

РЕДАКТИРОВАТЬ: Добавлено примечание, чтобы уточнить, что последовательность начинается с нулевого элемента и должна быть включена, если nравен нулю.

Примеры возможностей ввода / вывода:

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 байта. Следует также отметить, что эта программа
 не может достичь переполнения стека. Он работает для n = 5000 менее чем за 10 секунд.

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

Это создает функцию, которая принимает целое число в качестве входных данных и возвращает массив целых чисел.

Ungolfed + объяснение:

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. Добавление в CAST для bigints позволит ему пойти дальше до 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}

Простая модификация одного из примеров в No Stinking Loops .

Фраза .|$переводит число в строку, переворачивает его и затем оценивает.

Редактировать:

Небрежное внимание к граничным условиям с моей стороны. Вернее сейчас:

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

Haskell, 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и добавляет a 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

Попробуйте онлайн здесь

Ява - 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-Пролог, 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] 

Требуется около 10 секунд, чтобы вывести результат a(10000,X).на мой компьютер.

Изменить: 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).

> <> (Рыба) 592 254 байта

Не супер-гольф (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;}

Ничего особенного, только обычный алгоритм Фибоначчи со строкой обратной магии.

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 байт

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

Напористый , 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.
}