У послідовної послідовності Фібоначчі спочатку ви починаєте з 1і 1як завжди.

Однак замість того, щоб завжди додавати останні два значення, щоб отримати наступне число, ви чергуєте, починаючи з додавання, і кожен другий раз замість них віднімаєте.

Послідовність починається так:

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

тощо.

^{Зауважте, що після того, як він починається знову, він знову 1і 1знову потрапляє .}

Давши число N , роздрукуйте N- й термін послідовної змінної послідовності.

Пам'ятайте, що це код-гольф , тому виграє код з найменшою кількістю байтів.

JavaScript (ES6), 25 байт

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

0-індексований. Ви можете скоротити рядок за допомогою злегка рекурсивної версії, хоча вона додає 6 байтів:

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

Це ще коротше, ніж остаточна рекурсивна формула:

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

Пітон, 31 байт

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

Не турбує спроби обчислити значення. Просто заглядає в перелік пероїдів довжиною-12 [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], який стискається в базі 5.

Порівняйте рекурсивний розчин (37 байт) з True's для 1:

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

або для зберігання рядків

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

або спроба арифметичного виразу.

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

Оазис , 10 байт

Нагадує мені реалізувати ще кілька вбудованих елементів: p. Вхід 0-індексований .

Код:

n>2%x<*c+V

Перекладена версія:

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

І обчислює n- й термін.

Спробуйте в Інтернеті!

05AB1E , 10 байт

•É&†º•sèÍ

Використовує кодування CP-1252 . Спробуйте в Інтернеті!

Pyth - 13 байт

База закодована серія одного циклу, модульна індексація.

@-R2jC"
ûx"5

Спробуйте його онлайн тут .

Желе, 12 байт

“½Ġ⁻S’b5_2⁸ị

СпробуйтеItOnline!

На основі 1, з огляду на перше і друге значення 1.

Не впевнений, чи це ще коротше, але для цього я зазначив, що серія має період 12:
[1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]

Отже, я взяв це і додав, 2щоб давати
[3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
потім перетворене, що в якості базового 5числа, в базу 250, щоб дати:
[11, 197, 140, 84]
(що є 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 байт

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

Рекурсивний підхід. 0-індексований. Спробуйте це на Ideone.
Збережено 7 байт завдяки xnor .

Використання:

Prelude> (1!1!!)11
2

Математика, 40 байт

Просто створює таблицю пошуку і отримує доступ до неї циклічно, як у відповіді ETHproductions. Безіменна функція, 1-індексована.

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

MATL , 17 16 15 байт

'"Bl)e'F5Za2-i)

Введення на основі 1.

Спробуйте в Інтернеті!

Пояснення

Послідовність має період [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 байт

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

Введення передається через псевдореєстр $t0. 0-індексований. +2 кожного члена в послідовності зберігається в 3 бітах 85824331b.

Як це працює:

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

Вибірка зразка, цикл, що друкує перші 14 значень послідовності:

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 байти

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

Оскільки це Java, відповідь 0-індексовано.

Тестування та незагострення:

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

Математика, 45 41 38 байт

Завдяки @MartinEnder за 3 байти.

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

0-індексований.

Використання

±5

-2

Perl 6 ,  39 35  32 байт

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

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

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

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

C #, 117 байт

Гольф:

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

Безумовно:

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

Тестування:

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

R, 38 байт

Використовується рішення таблиці пошуку, натхнене відповіддю @ETHproductions JS.

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

Редагувати: Забув зазначити, що це 1-індексація.

Власне , 22 байти

34*@%"334130110314"E≈¬

Спробуйте в Інтернеті!

Пояснення:

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

Java 7, 88 82 79 байт

гольф:

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

неозорений:

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

Спробуйте в Інтернеті

DC, 55 байт

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

0-індексований.

?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

Реєстрація d зберігає індекс значення. Реєстр n підраховує кількість виконаних ітерацій. Реєстрація r зберігає основний макрос. Реєстрація y зберігає пізніше значення в послідовності, тоді як стек містить попереднє значення в послідовності.

Візуальне пояснення того, що відбувається у великому циклі (якщо припустити додавання):

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

Перевірка, щоб визначити, додавати чи віднімати, займає лічильник по модулю два та використовує цей трюк щоб зробити конструкцію if if else.

В кінці стека міститься єдине число, потрібне значення, яке друкується разом із p .

(Я новачок dc, тому очікую, що тут мають бути зроблені явні поліпшення.)

ForceLang , 153 байти

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 байт

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

0 індексовано

Пояснення:

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

Спробуйте в Інтернеті!

ABCR, 43 байти

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

Пояснення: перша частина ( )AAB)ABB..A))A..A)AA(ABB.)A+A)))A) встановлює чергу A, щоб містити [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], зберігаючи всі інші черги порожніми . iBзберігає наш бажаний термін, і цикл 5aAb(Bxперебирає чергу, яка багато разів. oдрукує лицьову сторону черги як число, яке потім стане нашою бажаною відповіддю.

Пакетна, 49 байт

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

Вводиться як параметр командного рядка. Пояснення: Закрита форма використовує такі спостереження:

• Послідовність циклічна з періодом 12
• Кожен третій член - ± 2, а інші терміни - ± 1
• Умови після третього від’ємні, за винятком кратних 5 (після зменшення модуля 12)

Тому ми починаємо з зменшення модуля 12 (щоб зберегти 2 байти). Потім зменшуємо модуль три і інвертуємо результат, який дорівнює 1 для кратних 3 або 0 в іншому випадку. Тоді ми побітно не є цією величиною, даючи нам -2 для кратних 3 або -1 в іншому випадку. Потім зменшуємо модуль 5 і окремо ділимо на 4, даючи нуль для термінів 1, 2, 3, 5, 10 і 12 (0). Інвертування та заперечення дає нам -1 для цих значень, а нуль для інших значень. Потім розряджаємо порозрядно на 1 і множимо на попередній обчислення.

TI-Basic, 26 байт

На жаль, дуже нецікавий підхід. Я нічого коротшого не міг знайти. Список 1-індексований.

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

C #, 73 71 байт

При цьому використовуються 0-індексовані значення 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;};

Відформатована версія:

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