En la secuencia alterna de Fibonacci, primero comienza con 1y 1como siempre.

Sin embargo, en lugar de sumar siempre los dos últimos valores para obtener el siguiente número, alterna alternando con la suma, y ​​cada dos veces resta en su lugar.

La secuencia comienza así:

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.

^{Tenga en cuenta que después de que comience de nuevo una vez que llegue 1y 1nuevamente.}

Dado un número N , imprimir el N º término de la secuencia alterna de Fibonacci.

Recuerde, este es el código de golf , por lo que gana el código con el menor número de bytes.

JavaScript (ES6), 25 bytes

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

0 indexado. Puede acortar la cadena con una versión ligeramente recursiva, aunque agrega 6 bytes:

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

Esto es aún más corto que la 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

No se molesta en tratar de calcular el valor. Solo busca en la lista de longitud 12 peroídica [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], que está comprimida en la base 5.

Compare con una solución recursiva (37 bytes) con True's para 1:

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

o para almacenar cadenas

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

o un intento de una expresión aritmética.

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

Oasis , 10 bytes

Me recuerda que implemente algunos más incorporados: p. La entrada está indexada en 0 .

Código:

n>2%x<*c+V

Versión traducida:

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

Y calcula el n º plazo.

Pruébalo en línea!

05AB1E , 10 bytes

•É&†º•sèÍ

Utiliza la codificación CP-1252 . Pruébalo en línea!

Pyth - 13 bytes

Base codificada en una serie de ciclo, modular indexada.

@-R2jC"
ûx"5

Pruébelo en línea aquí .

Jalea, 12 bytes

“½Ġ⁻S’b5_2⁸ị

TryItOnline!

Basado en 1, dado que el primer y el segundo valor son 1.

No estoy seguro si esto es más corto todavía, pero para esto noté que la serie tiene un período de 12:
[1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]

Entonces, tomé eso y agregué 2para dar y
[3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
luego lo convertí como un 5número base a base 250, para dar:
[11, 197, 140, 84]
(que es 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!!)

Enfoque recursivo. 0 indexado. Pruébalo en Ideone.
Guardado 7 bytes gracias a xnor .

Uso:

Prelude> (1!1!!)11
2

Mathematica, 40 bytes

Simplemente crea una tabla de búsqueda y accede a ella cíclicamente, como en la respuesta de ETHproductions. Función sin nombre, 1 indexada.

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

MATL , 17 16 15 bytes

'"Bl)e'F5Za2-i)

La entrada está basada en 1.

Pruébalo en línea!

Explicación

La secuencia tiene punto [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

La entrada se pasa a través del pseudo-registro $t0. 0 indexado. +2 de cada término en la secuencia se almacena en 3 bits haciendo 85824331b.

Cómo 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.

Salida de muestra, un bucle que imprime los primeros 14 valores de la secuencia:

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 se trata de Java, la respuesta está indexada en 0.

Pruebas y sin golf:

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

Prueba de ideona

Mathematica, 45 41 38 bytes

Gracias a @MartinEnder por 3 bytes.

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

0 indexado.

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

Golfizado:

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

Sin golf:

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

Pruebas:

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

R, 38 bytes

Utiliza la solución de tabla de búsqueda inspirada en la respuesta de @ETHproductions JS.

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

Editar: Olvidé mencionar que esto está indexado 1.

En realidad , 22 bytes

34*@%"334130110314"E≈¬

Pruébalo en línea!

Explicación:

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

golfizado:

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

sin golf:

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

Pruébalo en línea

DC, 55 bytes

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

0 indexado.

?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

El registro d almacena el índice del valor. Registrarse n cuenta el número de iteraciones completadas. Registrar r almacena la macro principal. Register y almacena el valor posterior en la secuencia, mientras que la pila contiene el valor anterior en la secuencia.

Explicación visual de lo que está sucediendo en el bucle grande (suponiendo además):

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

La verificación para determinar si se debe sumar o restar toma el módulo dos del contador y usa este truco para hacer una construcción en caso contrario.

Al final, la pila contiene un solo número, el valor deseado, que se imprime con p.

(Soy nuevo dc, así que esperaría que se realicen algunas mejoras obvias aquí).

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

Explicación:

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

Pruébalo en línea!

ABCR, 43 bytes

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

Explicación: la primera parte ( )AAB)ABB..A))A..A)AA(ABB.)A+A)))A) configura la cola A para que contenga [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], manteniendo vacías todas las demás colas . iBalmacena nuestro término deseado, y el ciclo 5aAb(Bxrecorre la cola muchas veces. oimprime el frente de la cola como un número, que luego será nuestra respuesta deseada.

Lote, 49 bytes

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

Toma la entrada como un parámetro de línea de comando. Explicación: El formulario cerrado utiliza las siguientes observaciones:

• La secuencia es cíclica con el período 12
• Cada tercer término es ± 2, mientras que otros términos son ± 1
• Los términos después del tercero son negativos, excepto los múltiplos de 5 (después de reducir el módulo 12)

Por lo tanto, comenzamos reduciendo el módulo 12 (para guardar 2 bytes). Luego reducimos el módulo tres e invertimos el resultado, que es 1 para múltiplos de 3 o 0 de lo contrario. Entonces, a nivel de bits, no ese valor, dándonos -2 para múltiplos de 3 o -1 de lo contrario. Luego reducimos el módulo 5 y dividimos por separado entre 4, dando cero para los términos 1, 2, 3, 5, 10 y 12 (0). Invertir y negar nos da -1 para esos valores y cero para otros valores. Luego, a nivel de bit o eso con 1 y multiplicamos con el cálculo anterior.

TI-Basic, 26 bytes

Desafortunadamente, enfoque muy poco interesante. No pude encontrar nada más corto. La lista está indexada en 1.

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

C #, 73 71 bytes

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

Versión formateada:

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