In der alternierenden Fibonacci-Sequenz beginnen Sie zunächst mit 1und 1wie gewohnt.

Anstatt jedoch immer die letzten beiden Werte zu addieren, um die nächste Zahl zu erhalten, beginnen Sie abwechselnd mit dem Addieren und subtrahieren stattdessen jedes weitere Mal.

Die Sequenz beginnt wie folgt:

1
1
2    # 1 + 1
-1   # 1 - 2
1    # 2 + -1
-2   # -1 - 1
-1   # 1 + -2
-1   # -2 - -1
-2   # -1 + -1
1    # -1 - -2
-1   # -2 + 1
2    # 1 - -1
1    # -1 + 2
1    # 2 - 1

etc.

^{Beachten Sie, dass nach dem Start zu Ende , wenn es bekommt 1und 1wieder.}

Bei einer gegebenen Zahl N wird der N- te Term der alternierenden Fibonacci-Sequenz gedruckt .

Denken Sie daran, dies ist Code-Golf , also gewinnt der Code mit der geringsten Anzahl von Bytes.

JavaScript (ES6), 25 Byte

n=>"334130110314"[n%12]-2

0-indiziert. Sie können die Zeichenfolge mit einer leicht rekursiven Version kürzen, obwohl 6 Bytes hinzugefügt werden:

f=n=>"3341301"[n]-2||f(13-n%12)

Dies ist immer noch kürzer als die endgültige rekursive Formel:

f=n=>n<2||f(n-2)+f(n-1)*(-n%2|1)

Python, 31 Bytes

lambda n:2-33107256/5**(n%12)%5

Macht sich nicht die Mühe, den Wert zu berechnen. Schlägt einfach in der Liste der peroidischen Länge 12 nach [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], die in Basis 5 komprimiert ist.

Vergleiche mit einer rekursiven Lösung (37 Bytes) mit True's for 1:

f=lambda n:n<2or(-1)**n*f(n-1)+f(n-2)

oder zur String-Speicherung

lambda n:int('334130110314'[n%12])-2

oder ein Versuch eines arithmetischen Ausdrucks.

lambda n:4**n%7%3*(-1)**((n+n%2*4)/6)

Oase , 10 Bytes

Erinnert mich daran, weitere integrierte Funktionen zu implementieren: p. Die Eingabe ist 0-indiziert .

Code:

n>2%x<*c+V

Übersetzte Version:

a(n) = (2*((n+1)%2)-1) * a(n-1) + a(n-2)
a(1) = 1
a(0) = 1

Und berechnet den n- ten Term.

Probieren Sie es online!

05AB1E , 10 Bytes

•É&†º•sèÍ

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Pyth - 13 Bytes

Basis einmal codiert, modular indiziert.

@-R2jC"
ûx"5

Probieren Sie es hier online aus .

Gelee, 12 Bytes

“½Ġ⁻S’b5_2⁸ị

TryItOnline!

1-basiert sind die ersten und zweiten Werte gegeben 1.

Ich bin mir nicht sicher, ob dies noch kürzer ist, aber dafür habe ich festgestellt, dass die Serie eine Periode von 12 hat:
[1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]

Also nahm ich das und fügte hinzu 2, um zu geben,
[3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
dann konvertierte ich das als Basiszahl 5zu Basis 250, um zu geben:
[11, 197, 140, 84]
(was ist 184222584).

“½Ġ⁻S’b5_2⁸ị - Main link: n
“½Ġ⁻S’       - base 250 number      184222584
      b5     - convert to base 5   [3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
        _2   - subtract 2          [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]
          ⁸  - left argument, n
           ị - index into (1-based and modular)

Haskell, 33 26 Bytes

a!b=a:b:(a+b)!(-a)
(1!1!!)

Rekursiver Ansatz. 0-indiziert. Probieren Sie es auf Ideone.
7 Bytes gespart dank xnor .

Verwendung:

Prelude> (1!1!!)11
2

Mathematica, 40 Bytes

Erstellt einfach eine Nachschlagetabelle und greift zyklisch darauf zu, wie in der Antwort von ETHproductions. Unbenannte Funktion, 1-indiziert.

Join[s={2,1,1,2,-1,1},-s][[#~Mod~12+1]]&

MATL , 17 16 15 Bytes

'"Bl)e'F5Za2-i)

Die Eingabe ist 1-basiert.

Probieren Sie es online!

Erläuterung

Die Sequenz hat Punkt [1 1 2 -1 1 -2 -1 -1 -2 1 -1 2].

'"Bl)e     % Compressed array [1 1 2 -1 1 -2 -1 -1 -2 1 -1 2] with source 
           % alphabet [-2 -1 0 1 2]
F5Za       % Decompress with target alphabet [0 1 2 3 4]
2-         % Subtract 2 to transform alphabet into [-2 -1 0 1 2]
i)         % Input N and use as (modular, 1-based) index into the sequence

WinDbg, 26 Bytes

?(85824331b>>@$t0%c*3&7)-2

Die Eingabe wird über das Pseudoregister weitergeleitet $t0. 0-indiziert. +2 jedes Terms in der Sequenz wird in 3 Bit gespeichert 85824331b.

Wie es funktioniert:

? (85824331b >> @$t0 % c * 3 & 7) - 2 ;*? Evalutes the expression. Shifts 85824331b to get
                                       *the 3 bits for the @$t0'th term (mod c (12) when
                                       *the sequence repeats). Bitwise AND by 7 to get the
                                       *desired 3 bits, finally subtract 2 since the terms
                                       *where stored as +2.

Beispielausgabe, eine Schleife, die die ersten 14 Werte der Sequenz druckt:

0:000> .for(r$t0=0;@$t0<e;r$t0=@$t0+1){?(85824331b>>@$t0%c*3&7)-2}
Evaluate expression: 1 = 00000001
Evaluate expression: 1 = 00000001
Evaluate expression: 2 = 00000002
Evaluate expression: -1 = ffffffff
Evaluate expression: 1 = 00000001
Evaluate expression: -2 = fffffffe
Evaluate expression: -1 = ffffffff
Evaluate expression: -1 = ffffffff
Evaluate expression: -2 = fffffffe
Evaluate expression: 1 = 00000001
Evaluate expression: -1 = ffffffff
Evaluate expression: 2 = 00000002
Evaluate expression: 1 = 00000001
Evaluate expression: 1 = 00000001

Java, 32 Bytes

n->"334130110314".charAt(n%12)-50

Da dies Java ist, ist die Antwort 0-indiziert.

Testen und ungolfed:

class Ideone {
  public static void main (String[] args) throws Exception {
    java.util.function.IntFunction f = n->"334130110314".charAt(n%12)-50;
    for (int i = 0; i < 12; i++) {
      System.out.printf("%d -> %d%n", i, f.apply(i));
    }
  }
}

Test auf Ideone

Mathematica, 45 41 38 Bytes

Danke an @MartinEnder für 3 Bytes.

±0=±1=1;±n_:=±(n-2)+±(n-1)(1-2n~Mod~2)

0-indiziert.

Verwendung

±5

-2

Perl 6 ,  39 35  32 Bytes

{(1,1,{|(($/=$^a+$^b),$b-$/)}...*)[$_]}

{(|(334130110314.comb X-2)xx*)[$_]}

{(|334130110314.comb xx*)[$_]-2}

{334130110314.substr($_%12,1)-2}

C #, 117 Bytes

Golf gespielt:

int A(int n){var f=new List<int>{0,1,1};for(int i=3;i<=n;i++){f.Add(i%2>0?f[i-1]+f[i-2]:f[i-2]-f[i-1]);}return f[n];}

Ungolfed:

public int A(int n)
{
  var f = new List<int> { 0, 1, 1 };

  for (int i = 3; i <= n; i++)
  {
    f.Add(i % 2 > 0 ? f[i - 1] + f[i - 2] : f[i - 2] - f[i - 1]);
  }

  return f[n];
}

Testen:

var alternatingFibonacci = new AlternatingFibonacci();
Console.WriteLine(alternatingFibonacci.B(10));
1

R, 38 Bytes

Verwendet die von @ETHproductions JS answer inspirierte Lookup-Table-Lösung.

c(s<-c(2,1,1,2,-1,1),-s)[scan()%%12+1]

Bearbeiten: Ich habe vergessen zu erwähnen, dass dies 1-indiziert ist.

Eigentlich 22 Bytes

34*@%"334130110314"E≈¬

Probieren Sie es online!

Erläuterung:

34*@%"334130110314"E≈¬
34*@%                   input % 12
     "334130110314"E    get that character in the string
                    ≈¬  convert to int, subtract 2

Java 7, 88 82 79 Bytes

Golf gespielt:

int f(int n){int c,i=0,a=1,b=1;for(;i<n;){c=i++%2>0?a-b:a+b;a=b;b=c;}return b;}

ungolfed:

int f(int n)
{
    int c, i = 0, a = 1, b = 1;
    for (; i < n;)
    {
        c = i++ % 2 > 0 ? a - b : a + b;
        a = b;
        b = c;
    }
    return b;
}

Probieren Sie es online aus

DC, 55 Bytes

?sd[ln1+snly[[+2Q]sEln2%1=E-]xlyrsylnld>r]sr1sy0sn1lrxp

0-indiziert.

?sd                                                     takes input and stores
                                                        it in register d

                                            1sy0sn1     stores 1 in register y
                                                        and 0 in register n and
                                                        appends 1 to the stack

   [ln1+snly                                            adds 1 to register n and
                                                        appends the value of
                                                        register y to the stack

            [[+2Q]sEln2%1=E-]                           adds or subtracts the
                                                        the two values on the
                                                        stack depending on
                                                        parity of n

                             xlyrsylnld>r]              does the rest of the
                                                        stuff required to store
                                                        the new values properly
                                                        and quits if it has
                                                        done enough iterations

                                          sr            stores the main macro
                                                        in register r

                                                   lrxp executes the macro and
                                                        prints the stack

Register d speichert den Index des Wertes. Register n zählt die Anzahl der durchgeführten Iterationen. Register r speichert das Hauptmakro. Register y speichert den späteren Wert in der Sequenz, während der Stapel den früheren Wert in der Sequenz enthält.

Visuelle Erklärung, was in der großen Schleife vor sich geht

register: y=1     y=1   y=1    y=1   y=1    y=2
stack:     1      1 1    2     2 1   1 2     1
               ly     +     ly     r     sy

Die Prüfung, ob addiert oder subtrahiert werden soll, nimmt das Zählermodul zwei und verwendet diesen Trick , um eine If-Then-else-Konstruktion zu erstellen.

Am Ende enthält der Stapel eine einzelne Zahl, den gewünschten Wert, mit dem gedruckt wird p .

(Ich bin neu in dc, daher würde ich erwarten, dass hier einige offensichtliche Verbesserungen vorgenommen werden müssen.)

ForceLang , 153 Byte

def s set
s a 1
s b 1
s p 1
s k io.readnum()
if k=0
goto b
label a
s c b.mult p
s c a+c
s a b
s b c
s p p.mult -1
s k k+-1
if k
goto a
label b
io.write a

Turtlèd , 35 Bytes

#112-1_--_1-2#?:[*l+].(-r'1)(_"-2")

0 indiziert

Erläuterung:

#112-1_--_1-2#                      the 12 values of sequence. - is -1, _ is -2
              ?:                    input a number and move right that many
                [*l+]               move back to the asterisk on start cell, 
                                    increment sting pointer by amount moved
                     .              write pointed char
                      (-r'1)        if it was -, move right, write 1
                            (_"-2") if it was _, write "-2"
      [print grid]

Probieren Sie es online!

ABCR, 43 Bytes

)AAB)ABB..A))A..A)AA(ABB.)A+A)))AiB5aAb(Bxo

Erläuterung: Der erste Teil ( )AAB)ABB..A))A..A)AA(ABB.)A+A)))A) richtet die Warteschlange A so ein, dass sie [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2] enthält, wobei alle anderen Warteschlangen leer bleiben . iBspeichert unseren gewünschten Begriff und die Schleife 5aAb(Bxdurchläuft die Warteschlange so oft. odruckt die Vorderseite der Warteschlange als Zahl aus, die dann unsere gewünschte Antwort ist.

Batch, 49 Bytes

@cmd/cset/a"n=%1%%12,~!(n%%3)*(1|-!(n%%5*(n/4)))"

Übernimmt die Eingabe als Befehlszeilenparameter. Erläuterung: In der geschlossenen Form werden die folgenden Beobachtungen verwendet:

• Die Sequenz ist mit Periode 12 zyklisch
• Jeder dritte Term ist ± 2, während andere Terme ± 1 sind
• Terme nach dem dritten sind negativ, mit Ausnahme von Vielfachen von 5 (nach Reduzierung von Modulo 12)

Wir beginnen daher mit der Reduzierung von Modulo 12 (um 2 Bytes zu sparen). Wir reduzieren dann Modulo drei und invertieren das Ergebnis, das sonst 1 für ein Vielfaches von 3 oder 0 ist. Wir geben dann bitweise nicht diesen Wert an, sondern -2 für Vielfache von 3 oder -1. Wir reduzieren dann Modulo 5 und dividieren getrennt durch 4, wobei wir für die Terme 1, 2, 3, 5, 10 und 12 (0) Null ergeben. Invertieren und Negieren ergibt -1 für diese Werte und Null für andere Werte. Wir werden dann bitweise oder das mit 1 und multiplizieren mit der früheren Berechnung.

TI-Basic, 26 Bytes

Leider sehr uninteressanter Ansatz. Ich konnte nichts kürzeres finden. Die Liste ist 1-indiziert.

Input :{1,1,2,-1,1,-2:augment(Ans,-Ans:Ans(X

C # 73 71 Bytes

Dies verwendet 0-indizierte Werte von n.

n=>{int a=1,b=1,i=0,r;for(;++i<n;){r=i%2>0?a+b:a-b;a=b;b=r;}return b;};

Formatierte Version:

Func<int, int> f = n =>
{
    int a = 1, b = 1, i = 0, r;

    for(; ++i < n;)
    {
        r = i % 2 > 0 ? a + b : a - b;
        a = b;
        b = r;
    }

    return b;
};