Dans la séquence de Fibonacci alternée, vous commencez d'abord par 1et 1comme d'habitude.

Cependant, au lieu de toujours ajouter les deux dernières valeurs pour obtenir le nombre suivant, vous alternez en commençant par l'ajout et chaque fois que vous soustrayez à la place.

La séquence commence comme ceci:

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.

^{Notez qu'après avoir recommencé, il arrive encore 1et 1encore.}

Étant donné un nombre N , imprimez le N ème terme de la séquence de fibonacci alternée.

N'oubliez pas qu'il s'agit de code-golf , donc le code avec le plus petit nombre d'octets l'emporte.

JavaScript (ES6), 25 octets

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

0 indexé. Vous pouvez raccourcir la chaîne avec une version légèrement récursive, bien qu'elle ajoute 6 octets:

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

C'est encore plus court que la formule récursive définitive:

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

Python, 31 octets

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

Ne prend pas la peine d'essayer de calculer la valeur. Cherche juste dans la liste peroidic length-12 [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], qui est compressée en base 5.

Comparez avec une solution récursive (37 octets) avec True 'pour 1:

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

ou au stockage de chaînes

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

ou une tentative d'expression arithmétique.

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

Oasis , 10 octets

Me rappelle d'implémenter d'autres fonctions intégrées: p. L'entrée est indexée sur 0 .

Code:

n>2%x<*c+V

Version traduite:

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

Et calcule le n ème terme.

Essayez-le en ligne!

05AB1E , 10 octets

•É&†º•sèÍ

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Pyth - 13 octets

Base codée une fois par cycle, indexée modulaire.

@-R2jC"
ûx"5

Essayez-le en ligne ici .

Gelée, 12 octets

“½Ġ⁻S’b5_2⁸ị

TryItOnline!

Basé sur 1, étant donné que les première et deuxième valeurs sont 1.

Je ne sais pas si c'est encore plus court, mais pour cela, j'ai noté que la série a une période de 12:
[1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]

Donc, j'ai pris cela et ajouté 2pour donner
[3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
puis converti cela en 5nombre de base en base 250, pour donner:
[11, 197, 140, 84]
(qui est 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 octets

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

Approche récursive. 0 indexé. Essayez-le sur Ideone.
7 octets enregistrés grâce à xnor .

Usage:

Prelude> (1!1!!)11
2

Mathematica, 40 octets

Il crée simplement une table de recherche et y accède de manière cyclique, comme dans la réponse d'ETHproductions. Fonction sans nom, indexée 1.

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

MATL , 17 16 15 octets

'"Bl)e'F5Za2-i)

L'entrée est basée sur 1.

Essayez-le en ligne!

Explication

La séquence a une période [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 octets

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

L'entrée est transmise via le pseudo-registre $t0. 0 indexé. +2 de chaque terme de la séquence est stocké sur 3 bits85824331b .

Comment ça fonctionne:

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

Exemple de sortie, une boucle imprimant les 14 premières valeurs de la séquence:

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 octets

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

Comme il s'agit de Java, la réponse est indexée 0.

Test et non 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));
    }
  }
}

Test sur Ideone

Mathematica, 45 41 38 octets

Merci à @MartinEnder pour 3 octets.

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

0 indexé.

Usage

±5

-2

Perl 6 ,  39 35  32 octets

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

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

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

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

C #, 117 octets

Golfé:

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

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

Essai:

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

R, 38 octets

Utilise la solution de table de recherche inspirée de la réponse @ETHproductions JS.

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

Edit: J'ai oublié de mentionner qu'il s'agit d'un index 1.

En fait , 22 octets

34*@%"334130110314"E≈¬

Essayez-le en ligne!

Explication:

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

Java 7, 88 82 79 octets

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

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

Essayez-le en ligne

DC, 55 octets

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

0 indexé.

?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

Le registre d stocke l'index de la valeur. Le registre n compte le nombre d'itérations terminées. Register r stocke la macro principale. Le registre y stocke la dernière valeur dans la séquence, tandis que la pile contient la valeur précédente dans la séquence.

Explication visuelle de ce qui se passe dans la grande boucle (en supposant l'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

La vérification pour déterminer s'il faut ajouter ou soustraire prend le compteur modulo deux et utilise cette astuce pour créer une construction if then else.

À la fin, la pile contient un seul numéro, la valeur souhaitée, qui est imprimé avec p.

(Je suis nouveau dc, alors je m'attends à ce qu'il y ait des améliorations évidentes à apporter ici.)

ForceLang , 153 octets

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 octets

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

0 indexé

Explication:

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

Essayez-le en ligne!

ABCR, 43 octets

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

Explication: la première partie ( )AAB)ABB..A))A..A)AA(ABB.)A+A)))A) configure la file d'attente A pour contenir [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2], en laissant toutes les autres files d'attente vides . iBstocke le terme souhaité et la boucle 5aAb(Bxparcourt la file d'attente autant de fois. oimprime le devant de la file d'attente sous forme de nombre, qui sera alors notre réponse souhaitée.

Lot, 49 octets

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

Prend l'entrée comme paramètre de ligne de commande. Explication: le formulaire fermé utilise les observations suivantes:

• La séquence est cyclique avec la période 12
• Chaque troisième terme est ± 2 tandis que les autres termes sont ± 1
• Les termes après le troisième sont négatifs sauf les multiples de 5 (après réduction du modulo 12)

On commence donc par réduire le modulo 12 (pour économiser 2 octets). Nous réduisons ensuite le modulo trois et inversons le résultat, qui est 1 pour des multiples de 3 ou 0 sinon. Nous n'avons alors pas cette valeur au niveau du bit, ce qui nous donne -2 pour les multiples de 3 ou -1 sinon. Nous réduisons ensuite modulo 5 et divisons séparément par 4, donnant zéro pour les termes 1, 2, 3, 5, 10 et 12 (0). L'inversion et la négation nous donnent -1 pour ces valeurs et zéro pour les autres valeurs. Nous avons ensuite au niveau du bit ou celui avec 1 et multiplier avec le calcul précédent.

TI-Basic, 26 octets

Malheureusement, approche très inintéressante. Je n'ai rien trouvé de plus court. La liste est indexée 1.

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

C #, 73 71 octets

Cela utilise des valeurs indexées à 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;};

Version formatée:

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