В чередующейся последовательности Фибоначчи вы начинаете с 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)

Python, 31 байт

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

Не надо пытаться вычислить значение. Просто просматривает список peroidic length-12 [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], который сжат в базе 5.

Сравните с рекурсивным решением (37 байт) с Trues для 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 байт

Напоминает мне реализовать еще несколько встроенных функций: с. Вход 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⁸ị

TryItOnline!

На основе 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

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

Тест на идеоне

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

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

Тестирование:

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

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

Попробуйте онлайн

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

Объяснение: first part ( )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;
};