Alternatif Fibonacci dizisinde, önce 1ve ile başlarsınız.1 her zamanki gibi .

Ancak, bir sonraki sayıyı elde etmek için her zaman son iki değeri eklemek yerine, ekleme ile başlayarak ve bunun yerine her çıkardığınızda dönüşümlü olarak çalışırsınız.

Dizi şu şekilde başlar:

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

vb.

^{Bitti başladıktan sonra o alır sonra o Bildirimi 1ve 1tekrar.}

Bir sayı N verildiğinde , alternatif fibonacci dizisinin N terimini yazdırın .

Unutmayın, bu kod golfüdür , bu nedenle en az bayt içeren kod kazanır.

JavaScript (ES6), 25 bayt

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

0 endeksli. 6 bayt eklese de, dizeyi biraz yinelemeli bir sürümle kısaltabilirsiniz:

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

Bu hala kesin özyinelemeli formülden daha kısadır:

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

Python, 31 bayt

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

Değeri hesaplamak için uğraşmaz. Sadece [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]baz 5'te sıkıştırılmış peroidik uzunluk-12 listesine bakar .

1 için 'olan özyinelemeli çözüm (37 bayt) ile karşılaştırın True:

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

veya dize depolama alanına

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

veya aritmetik bir ifade denemesi.

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

Vaha , 10 bayt

Bana daha yerleşik bazı uygulamaları hatırlatıyor: s. Giriş 0 dizinlidir .

Kod:

n>2%x<*c+V

Çevrilmiş sürüm:

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

Ve hesaplar n terimi inci.

Çevrimiçi deneyin!

05AB1E , 10 bayt

•É&†º•sèÍ

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

Pyth - 13 bayt

Baz bir kez döngü serisi kodlanmış, modüler indekslenmiştir.

@-R2jC"
ûx"5

Burada çevrimiçi deneyin .

Jöle, 12 bayt

“½Ġ⁻S’b5_2⁸ị

TryItOnline!

1 tabanlı, birinci ve ikinci değerler verilmiştir 1.

Bunun daha kısa olup olmadığından emin değilim, ancak bunun için serinin 12 periyodu olduğunu belirttim:
[1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]

Yani, bunu aldım ve 2vermek için ekledim , daha
[3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
sonra bunu bir baz 5numarası olarak tabana dönüştürdüm 250:
[11, 197, 140, 84]
(ki 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 bayt

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

Özyinelemeli yaklaşım. 0 endeksli. Ideone üzerinde deneyin. Xnor
sayesinde 7 bayt kaydedildi .

Kullanımı:

Prelude> (1!1!!)11
2

Mathematica, 40 bayt

Sadece bir arama tablosu oluşturur ve ETHproductions'ın cevabında olduğu gibi çevrimsel olarak erişir. Adsız işlev, 1 dizinli.

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

MATL , 17 16 15 bayt

'"Bl)e'F5Za2-i)

Giriş 1 tabanlıdır.

Çevrimiçi deneyin!

açıklama

Dizinin süresi vardır [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 bayt

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

Giriş sahte kayıttan geçirilir $t0. 0 endeksli. Sekanstaki her terimin +2'si 3 bit yapımında saklanır85824331b .

Nasıl çalışır:

? (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.

Örnek çıktı, dizinin ilk 14 değerini basan bir döngü:

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 bayt

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

Bu Java olduğundan yanıt 0 dizinlidir.

Test ve desteksiz:

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

Ideone üzerinde test

Mathematica, 45 41 38 bayt

@MartinEnder'e 3 bayt için teşekkürler.

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

0 endeksli.

kullanım

±5

-2

Perl 6 ,  39 35  32 bayt

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

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

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

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

C #, 117 Bayt

golfed:

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

Test yapmak:

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

R, 38 bayt

@ETHproductions JS yanıtından esinlenen arama tablosu çözümünü kullanır.

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

Düzenleme: Bunun 1 dizinli olduğunu belirtmeyi unuttum.

Actually, 22 bytes

34*@%"334130110314"E≈¬

Try it online!

Explanation:

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

golfed:

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

Try it online

DC, 55 bytes

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

0-indexed.

?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 stores the index of the value. Register n counts the number of iterations completed. Register r stores the main macro. Register y stores the later value in the sequence, while the stack contains the earlier value in the sequence.

Visual explanation of whats going on in the big loop (assuming addition):

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

The check to determine whether to add or subtract takes the counter modulo two and uses this trick to make an if then else construction.

At the end the stack contains a single number, the desired value, which is printed with p.

(I'm new to dc, so I'd expect there are some obvious improvements to be made here.)

ForceLang, 153 bytes

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 indexed

Explanation:

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

Try it online!

ABCR, 43 bytes

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

Explanation: the first part ()AAB)ABB..A))A..A)AA(ABB.)A+A)))A) sets up queue A to contain [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], keeping all other queues empty. iB stores our desired term, and the loop 5aAb(Bx cycles through the the queue that many times. o prints the front of the queue as a number, which will then be our desired answer.

Batch, 49 bytes

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

Takes input as a command-line parameter. Explanation: Closed form uses the following observations:

• Sequence is cyclic with period 12
• Every third term is ±2 while other terms are ±1
• Terms after the third are negative except multiples of 5 (after reducing modulo 12)

We therefore start by reducing modulo 12 (to save 2 bytes). We then reduce modulo three and invert the result, which is 1 for multiples of 3 or 0 otherwise. We then bitwise not that value, giving us -2 for multiples of 3 or -1 otherwise. We then reduce modulo 5 and separately divide by 4, giving zero for terms 1, 2, 3, 5, 10 and 12 (0). Inverting and negating gives us -1 for those values and zero for other values. We then bitwise or that with 1 and multiply with the earlier calculation.

TI-Basic, 26 bytes

Unfortunately, very uninteresting approach. I could not find anything shorter. The list is 1-indexed.

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

C#, 73 71 bytes

This uses 0-indexed values of 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;};

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