Schreiben Sie ein Programm oder eine benannte Funktion, die die Sequenz bis zur nth Ganzzahl in der Iccanobif-Sequenz ausgibt oder zurückgibt, die in OEIS als A014258 dokumentiert ist . Beachten Sie, dass nur das nullte Element in der Sequenz ( 0) gedruckt wird, wenn nNull ist.

Die Sequenz wird wie die Standard-Fibonacci-Sequenz erzeugt, aber nachdem Sie die beiden vorherigen Zahlen addiert haben, kehren Sie das Ergebnis um und löschen alle führenden Nullen. Zumindest für mich ist es eine interessante Tatsache, dass diese Reihenfolge nicht unbedingt zunimmt (siehe Liste unten). Es scheint auch streng größer oder gleich der Fibonacci-Sequenz zu sein (und ist es wahrscheinlich auch).

Die Eingabe Ihres Programms muss eine Ganzzahl sein.

Die ersten 20 Nummern der Sequenz werden hier für Ihr Sehvergnügen bereitgestellt:

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

Standardlücken sind verboten.

Kürzeste Sendung gewinnt.

BEARBEITEN: Es wurde ein Hinweis hinzugefügt, um zu verdeutlichen, dass die Sequenz mit dem nullten Element beginnt und eingeschlossen werden sollte, wenn nNull ist.

Beispiel IO Möglichkeiten:

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]

Nachstehend finden Sie einige Antworten auf meine Implementierungen in Python 2, die ich intensiv mit Markup ausgeblendet habe:

Iterativ:

#Nächste zu meinem ursprünglichen Programm. 73 Bytes. Es ist auch zu beachten, dass dieses Programm
 kann keinen Stapelüberlauf erreichen. Es läuft für n = 5000 in weniger als 10 Sekunden.

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

Rekursiv:

#Beachten Sie, dass nhiermit nachgestellte Zeilenumbrüche gedruckt werden. 64 Bytes.
 Trifft einen Stapelüberlauffehler für große Werte von 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

Probieren Sie es online aus

Sehr einfache Implementierung, beginnt mit range(2)und fügt eine Anzahl von Elementen hinzu, die der Eingabe entsprechen, und schneidet die Extras vom letzten Element ab.

Vielen Dank an @Jakube für den Hinweis auf das >Umkehr-Ding.

Erläuterung

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

Anwendungen strzu konvertieren , anstatt Backticks , weil groß genug Zahlen in Python 2 mit einem L am Ende geschrieben werden. Ich habe eine rekursive Funktion ausprobiert, aber es hat sich herausgestellt, dass sie länger dauert (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])

Dadurch wird eine Funktion erstellt, die eine Ganzzahl als Eingabe akzeptiert und ein Ganzzahl-Array zurückgibt.

Ungolfed + Erklärung:

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

Beispiele:

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

Sehr einfache Inline-Tabellenfunktion, die eine rekursive CTE-Abfrage verwendet. Da es INTs verwendet, wird dies bei 37 an erster Stelle stehen. Das Hinzufügen von CASTs für Bigints ermöglicht es, weiter auf 63 zu gehen

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

Es wird wie folgt verwendet

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}

Eine einfache Modifikation eines der Beispiele bei No Stinking Loops .

Die Phrase .|$wandelt eine Zahl in eine Zeichenfolge um, kehrt sie um und wertet sie dann aus.

Bearbeiten:

Schlampige Beachtung der Randbedingungen meinerseits. Richtiger jetzt:

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

Bearbeiten 2:

(x+1)#kann durch ersetzt werden -1_, wobei 2 Zeichen gespeichert werden. Das Leerzeichen ist notwendig, da sonst _xein Bezeichner wäre, wenn ich den "drop" -Operator auf eine aufgerufene Variable anwenden möchte x.

Haskell, 64 49 Bytes

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

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

So funktioniert es: !Erstellt rekursiv eine unendliche Liste von iccanobif-Nummern, beginnend mit dem ersten Argument (das zweite Argument muss die nächste iccanobif-Nummer sein). Nimmt qdie ersten nZahlen aus der iccanobif-Liste 1, 1und stellt sie voran 0.

CJam, 18 Bytes

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

Wie es funktioniert

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

Probieren Sie es hier online aus

Java - 126 124

Ich habe seit einiger Zeit kein Java mehr auf dieser Seite gesehen ...

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

Laufende a(17,X).Ausgaben:

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

Die Ausgabe des Ergebnisses a(10000,X).auf meinem Computer dauert ungefähr 10 Sekunden .

Bearbeiten: Die 121-Byte-Version oben ist eine Ein-Prädikat-Definition = ein Liner. Die alte 131-Byte-Version ist die folgende (muss als ausgeführt werden 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).

> <> (Fisch) 592 254 Bytes

Nicht besonders gut gespielt (42/43 Leerzeichen, die nichts bewirken, und insgesamt 30 Umleitungs-Token), aber es war eine interessante Übung, um es überhaupt zum Laufen zu bringen.

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

Sie können es testen hier und die gewünschte Länge im Anfangsstapel angeben.

EDIT: Mehr als die Hälfte der Byteanzahl

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

Nichts Besonderes, nur ein durchschnittlicher Fibonacci-Algorithmus mit umgekehrter Magie.

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

Das Ausführen des Makros fordert den Benutzer auf, einen Wert für n einzugeben.

Die Ergebnisse werden dann zeilenweise in Spalte A ausgedruckt:

JavaScript (ES2015), 81 73 Bytes

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

Ausführen dieser Funktion (benannt f) mit 6:

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

Pip , 13 Bytes

Ich bin mir ziemlich sicher, dass alle in diesem Programm verwendeten Funktionen in Pip vorhanden waren, bevor diese Frage gestellt wurde.

LaSio:+RVi+oi

Übernimmt die Eingabe als Befehlszeilenargument. Probieren Sie es online!

Erläuterung

               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

Die Werte der beiden Variablen entwickeln sich folgendermaßen:

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

Z1{:2d+vFs@KjkvF;_

Probieren Sie es online!

Es ist nicht das eleganteste Programm, aber es funktioniert.

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.

Gelee , 9 Bytes (nicht konkurrierend)

0+ṚV$¥Ð¡1

Probieren Sie es 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)}

Beispiel:

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

Würde gerne sehen, ob jemand eine bessere R-Alternative hat, als Ihre Nummer zu nehmen, eine Zeichenfolge daraus zu machen, sie umzukehren und sie wieder in eine Zahl umzuwandeln.

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