Na sequência alternada de Fibonacci, você começa com 1e 1como de costume.

No entanto, em vez de sempre adicionar os dois últimos valores para obter o próximo número, você alterna entre começar e adicionar e, em todas as outras vezes, subtrai.

A sequência começa assim:

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.

^{Observe que, depois que ele recomeça, quando ele chega 1e 1novamente.}

Dado um número N , imprimir o N ° termo da sequência alternada de Fibonacci.

Lembre-se de que isso é código-golfe , portanto o código com o menor número de bytes vence.

JavaScript (ES6), 25 bytes

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

Indexado a 0. Você pode encurtar a string com uma versão ligeiramente recursiva, embora adicione 6 bytes:

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

Isso ainda é mais curto que a fórmula recursiva definitiva:

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

Python, 31 bytes

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

Não se incomoda em tentar calcular o valor. Apenas aparece na lista peroidic length-12 [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], que é compactada na base 5.

Compare com uma solução recursiva (37 bytes) com True's para 1:

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

ou para armazenamento de strings

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

ou uma tentativa de expressão aritmética.

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

Oásis , 10 bytes

Lembra-me de implementar mais alguns recursos internos: p. A entrada é indexada em 0 .

Código:

n>2%x<*c+V

Versão traduzida:

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

E calcula o n º prazo.

Experimente online!

05AB1E , 10 bytes

•É&†º•sèÍ

Usa a codificação CP-1252 . Experimente online!

Pitão - 13 bytes

Base codificada uma vez série de ciclo, indexada modular.

@-R2jC"
ûx"5

Experimente online aqui .

Gelatina, 12 bytes

“½Ġ⁻S’b5_2⁸ị

TryItOnline!

1, dado que o primeiro e o segundo valores são 1 .

Não tenho certeza se isso é mais curto ainda, mas por isso observei que a série tem um período de 12:
[1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]

Então, eu peguei isso e adicionei 2para dar e
[3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
depois converti isso como um 5número base para base 250, para dar:
[11, 197, 140, 84]
(que é 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!!)

Abordagem recursiva. Indexado a 0. Experimente em Ideone.
Economizou 7 bytes graças ao xnor .

Uso:

Prelude> (1!1!!)11
2

Mathematica, 40 bytes

Apenas cria uma tabela de pesquisa e a acessa ciclicamente, como na resposta da ETHproductions. Função sem nome, indexada em 1.

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

MATL , 17 16 15 bytes

'"Bl)e'F5Za2-i)

A entrada é baseada em 1.

Experimente online!

Explicação

A sequência tem período [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

A entrada é passada através do pseudo-registro $t0. Indexado a 0. +2 de cada termo na sequência é armazenado em três bits 85824331b.

Como funciona:

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

Saída de amostra, um loop imprimindo os primeiros 14 valores da sequência:

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

Como esse é Java, a resposta é indexada em 0.

Testando e não destruído:

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

Teste em Ideona

Mathematica, 45 41 38 bytes

Obrigado a @MartinEnder por 3 bytes.

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

Indexado a 0.

Uso

±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

Golfe:

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

Teste:

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

R, 38 bytes

Usa a solução da tabela de pesquisa inspirada na resposta JS @ETHproductions.

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

Edit: Esqueci de mencionar que este é 1 indexado.

Na verdade , 22 bytes

34*@%"334130110314"E≈¬

Experimente online!

Explicação:

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

Experimente online

DC, 55 bytes

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

Indexado a 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

O registro d armazena o índice do valor. Register n conta o número de iterações concluídas. Registrar r armazena a macro principal. O registro y armazena o valor posterior na sequência, enquanto a pilha contém o valor anterior na sequência.

Explicação visual do que está acontecendo no loop grande (assumindo a adição):

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

A verificação para determinar se você deseja adicionar ou subtrair usa o contador módulo dois e usa esse truque para criar uma construção if then else.

No final, a pilha contém um único número, o valor desejado, que é impresso com p.

(Sou iniciante dc, então espero que haja algumas melhorias óbvias a serem feitas aqui.)

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 indexado

Explicação:

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

Experimente online!

ABCR, 43 bytes

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

Explicação: a primeira parte ( )AAB)ABB..A))A..A)AA(ABB.)A+A)))A) configura a fila A para conter [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], mantendo todas as outras filas vazias . iBarmazena o termo desejado e o loop 5aAb(Bxpercorre a fila várias vezes. oimprime a frente da fila como um número, que será nossa resposta desejada.

Lote, 49 bytes

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

Recebe a entrada como um parâmetro da linha de comando. Explicação: O formulário fechado usa as seguintes observações:

• Sequência é cíclica com período 12
• Cada terceiro termo é ± 2, enquanto outros termos são ± 1
• Os termos após o terceiro são negativos, exceto múltiplos de 5 (após a redução do módulo 12)

Portanto, começamos reduzindo o módulo 12 (para economizar 2 bytes). Em seguida, reduzimos o módulo três e invertemos o resultado, que é 1 para múltiplos de 3 ou 0, caso contrário. Em seguida, bit a bit não é esse valor, fornecendo -2 para múltiplos de 3 ou -1 caso contrário. Reduzimos então o módulo 5 e dividimos separadamente por 4, dando zero para os termos 1, 2, 3, 5, 10 e 12 (0). Inverter e negar nos dá -1 para esses valores e zero para outros valores. Em seguida, bit a bit ou isso com 1 e multiplicamos pelo cálculo anterior.

TI-Basic, 26 bytes

Infelizmente, abordagem muito desinteressante. Não consegui encontrar nada mais curto. A lista é indexada em 1.

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

C #, 73 71 bytes

Isso usa valores indexados 0 de 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;};

Versão formatada:

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