Écrivez un programme ou une fonction nommée qui ngénérera ou renverra la séquence jusqu'au nombre entier dans la séquence Iccanobif, documenté sur OEIS sous le numéro A014258 . Notez que seul l'élément zéro dans la séquence ( 0) sera imprimé sin est zéro.

La séquence est générée en démarrant comme la séquence Fibonacci standard, mais après avoir ajouté les deux nombres précédents, vous retournez le résultat et supprimez les zéros de tête. Un fait intéressant, du moins pour moi, est que cette séquence n'est pas strictement croissante (voir la liste ci-dessous). Elle semble également être (et est probablement) strictement supérieure ou égale à la séquence de Fibonacci.

L'entrée de votre programme doit être un entier.

Les 20 premiers numéros de la séquence sont fournis ici pour votre plus grand plaisir:

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

Les failles standard sont interdites.

Le programme le plus court gagne.

EDIT: Ajout d'une note pour préciser que la séquence commence par l'élément zeroth et doit être incluse si n est zéro.

Exemples de possibilités d'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]

Maintenant qu'il y a plusieurs réponses, voici mes implémentations en Python 2 que j'ai travaillé dur pour cacher avec le balisage:

Itératif:

# Plus proche de mon programme initial. 73 octets. Il convient également de noter que ce programme
 ne peut pas atteindre un débordement de pile. Il fonctionne pour n = 5000 en moins de 10 secondes.

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

Récursif:

# Notez que cela imprime ndes nouvelles lignes de fin. 64 octets.
 Frappera une erreur de débordement de pile pour les grandes valeurs 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

Essayez-le en ligne

Implémentation très basique, commence par range(2)et ajoute un nombre d'éléments égal à l'entrée, puis supprime les extras pour faire disparaître le dernier élément.

Merci @Jakube d'avoir signalé le >truc de l' inversion.

Explication

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 octets

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

Utilise strpour convertir plutôt que pour les backticks car un nombre suffisamment grand en Python 2 est écrit avec un L à la fin. J'ai essayé une fonction récursive, mais elle s'est avérée plus longue (61):

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

Julia, 79 octets

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

Cela crée une fonction qui accepte un entier en entrée et renvoie un tableau d'entiers.

Non golfé + explication:

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

Exemples:

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

Fonction de table en ligne très simple qui utilise une requête CTE récursive. Comme il utilise des INT, cela dépassera à 37. L'ajout de CAST pour les bigints lui permettra d'aller plus loin à 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

Il est utilisé comme suit

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 octets

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

Une simple modification d'un des exemples de No Stinking Loops .

La phrase .|$transforme un nombre en chaîne, l'inverse et l'évalue.

Modifier:

Attention bâclée aux conditions aux limites de ma part. Plus correct maintenant:

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

Modifier 2:

(x+1)#peut être remplacé par -1_, économisant 2 caractères. L'espace est nécessaire car sinon_x serait un identifiant, quand je veux que l'opérateur "drop" soit appliqué à une variable appelée x.

Haskell, 64 49 octets

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

Exemple d'utilisation: q 15 ->[0,1,1,2,3,5,8,31,93,421,415,638,3501,9314,51821,53116]

Comment ça marche: !construit récursivement une liste infinie de nombres iccanobif commençant par son premier argument (le deuxième argument doit être le prochain numéro iccanobif). qprend les premiers nnuméros de la liste iccanobif en commençant par 1, 1et ajoute a 0.

CJam, 18 octets

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

Comment ça marche

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

Essayez-le en ligne ici

Java - 126 124

Je n'ai pas vu Java autour de ce site depuis un moment ...

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

SWI-Prolog, 141 131 121 octets

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

Exécution de a(17,X).sorties:

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

Prend environ 10 secondes pour produire le résultat de a(10000,X). sur mon ordinateur.

Edit: la version de 121 octets ci-dessus est une définition d'un prédicat = un liner. L'ancienne version de 131 octets est la suivante (doit être exécutée en tant que 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).

> <> (Poisson) 592 254 octets

Pas super golfé (42/43 blancs qui ne font rien et un total de 30 jetons de redirection), mais c'était un exercice intéressant pour le faire fonctionner en premier lieu.

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

Vous pouvez le tester ici , en fournissant la longueur souhaitée dans la pile initiale.

EDIT: nombre d'octets divisé par deux

PHP, 114 , 109 octets

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

Rien d'extraordinaire, juste un algorithme fibonacci moyen avec la chaîne de magie inverse.

Non 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 octets

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

L'exécution de la macro invitera l'utilisateur à entrer une valeur pour n.

Les résultats seront ensuite imprimés ligne par ligne dans la colonne A:

JavaScript (ES2015), 81 73 octets

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

Exécuter cette fonction (nommée f) avec 6:

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

Pépin , 13 octets

Je suis presque sûr que toutes les fonctionnalités utilisées dans ce programme étaient présentes dans Pip avant que cette question ne soit posée.

LaSio:+RVi+oi

Prend l'entrée comme argument de ligne de commande. Essayez-le en ligne!

Explication

               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

Les valeurs des deux variables évoluent comme suit:

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 octets (non concurrent)

Z1{:2d+vFs@KjkvF;_

Essayez-le en ligne!

Ce n'est pas le plus élégant des programmes, mais ça marche.

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.

Gelée , 9 octets (non concurrent)

0+ṚV$¥Ð¡1

Essayez-le en ligne!

R, 134 octets

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

Exemple:

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

J'aimerais voir si quelqu'un a une meilleure alternative à R que de prendre votre numéro, d'en faire une chaîne, de l'inverser et de le reconvertir en nombre.

Groovy, 70 octets

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