Scrivi un programma o una funzione con nome che genererà o restituirà la sequenza fino al nnumero intero nella sequenza Iccanobif, documentato su OEIS come A014258 . Si noti che 0verrà stampato solo l'elemento zeroth nella sequenza ( ) se nè zero.

La sequenza viene generata iniziando come la sequenza standard di Fibonacci, ma dopo aver aggiunto i due numeri precedenti, capovolgi il risultato e rilasci eventuali zeri iniziali. Un fatto interessante, almeno per me, è che questa sequenza non è strettamente crescente (vedi la lista qui sotto). Sembra anche essere (e probabilmente lo è) strettamente maggiore o uguale alla sequenza di Fibonacci.

L'input del tuo programma deve essere un numero intero.

I primi 20 numeri della sequenza sono forniti qui per il tuo piacere di visione:

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

Sono vietate le scappatoie standard.

Vince il programma più breve.

EDIT: aggiunta una nota per chiarire che la sequenza inizia con l'elemento zeroth e dovrebbe essere inclusa se nè zero.

Esempio di possibilità 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]

Ora che ci sono diverse risposte, di seguito sono riportate le mie implementazioni in Python 2 che ho lavorato duramente per nascondere con il markup:

Iterativo:

# Più vicino al mio programma iniziale. 73 byte. Va anche notato che questo programma
 impossibile raggiungere un overflow dello stack. Funziona per n = 5000 in meno di 10 secondi.

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

Ricorsivo:

# Notare che questo stampa nnuove righe finali. 64 byte.
 Colpirà un errore di overflow dello stack per valori elevati di 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

Provalo online

L'implementazione molto semplice, inizia con range(2)e aggiunge un numero di elementi pari all'input, quindi suddivide gli extra pop-up dell'ultimo elemento.

Grazie @Jakube per aver segnalato l' >inversione.

Spiegazione

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 byte

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

Utilizza strper convertire anziché backtick perché i numeri abbastanza grandi in Python 2 sono scritti con una L alla fine. Ho provato una funzione ricorsiva, ma si è rivelata più lunga (61):

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

Julia, 79 byte

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

Questo crea una funzione che accetta un intero come input e restituisce un array intero.

Ungolfed + spiegazione:

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

Esempi:

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

Funzione di tabella inline molto diretta che utilizza una query CTE ricorsiva. Dato che utilizza INT, questo supererà il 37. L'aggiunta di CAST per i bigints gli consentirà di andare oltre a 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

È usato come segue

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 byte

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

Una semplice modifica di uno degli esempi in No Stinking Loops .

La frase .|$lancia un numero in una stringa, lo inverte e quindi lo valuta.

Modificare:

Scarsa attenzione alle condizioni al contorno da parte mia. Più corretto ora:

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

Modifica 2:

(x+1)#può essere sostituito con -1_, salvando 2 caratteri. Lo spazio è necessario perché altrimenti _xsarebbe un identificatore, quando voglio che l'operatore "drop" venga applicato a una variabile chiamata x.

Haskell, 64 49 byte

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

Esempio di utilizzo: q 15->[0,1,1,2,3,5,8,31,93,421,415,638,3501,9314,51821,53116]

Come funziona: !crea ricorsivamente un elenco infinito di numeri iccanobif a partire dal suo primo argomento (il secondo argomento deve essere il prossimo numero iccanobif). qprende i primi nnumeri dall'elenco iccanobif che iniziano con 1, 1e antepone a 0.

CJam, 18 byte

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

Come funziona

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

Provalo online qui

Java - 126 124

Non vedo Java attorno a questo sito da un po '...

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

SWI-Prolog, 141 131 121 byte

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).Uscite in esecuzione :

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

Sono necessari circa 10 secondi per visualizzare il risultato a(10000,X).sul mio computer.

Modifica: la versione di 121 byte sopra è una definizione di predicato = una riga. La vecchia versione di 131 byte è la seguente (deve essere eseguita come 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).

> <> (Pesce) 592 254 byte

Non super golf (42/43 spazi bianchi che non fanno nulla e un totale di 30 token di reindirizzamento), ma è stato un esercizio interessante farlo funzionare in primo luogo.

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

Puoi testarlo qui , fornendo la lunghezza desiderata nello stack iniziale.

EDIT: numero di byte più che dimezzato

PHP, 114 , 109 byte

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

Niente di speciale, solo un algoritmo fibonacci medio con la magia inversa della stringa.

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 byte

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'esecuzione della macro richiederà all'utente di inserire un valore per n.

I risultati verranno quindi stampati riga per riga nella colonna A:

JavaScript (ES2015), 81 73 byte

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

Esecuzione di questa funzione (denominata f) con 6:

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

seme , 13 byte

Sono abbastanza sicuro che tutte le funzionalità utilizzate in questo programma fossero presenti in Pip prima che questa domanda fosse posta.

LaSio:+RVi+oi

Accetta input come argomento della riga di comando. Provalo online!

Spiegazione

               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

I valori delle due variabili si evolvono così:

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 byte (non concorrenti)

Z1{:2d+vFs@KjkvF;_

Provalo online!

Non è il più elegante dei programmi, ma funziona.

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 byte (non competitiva)

0+ṚV$¥Ð¡1

Provalo online!

R, 134 byte

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

Esempio:

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

Mi piacerebbe vedere se qualcuno avesse un'alternativa R migliore che prendere il tuo numero, renderlo una stringa, invertirlo e trasformarlo di nuovo in un numero.

Groovy, 70 byte

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