Étant donné N, sortir le Nième terme de cette séquence infinie:

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ... etc.

N peut être indexé 0 ou 1 comme vous le souhaitez.

Par exemple, si 0-indexés puis entrées 0, 1, 2, 3, 4devrait produire des sorties respectives -1, 2, -2, 1, -3.

Si l' index 1 entrées puis 1, 2, 3, 4, 5devrait produire des sorties respectives -1, 2, -2, 1, -3.

Pour être clair, cette séquence est générée en prenant la séquence d’entiers positifs répétés deux fois

1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 ...

et réarranger chaque paire de nombres impairs pour entourer les nombres pairs juste au-dessus

1 2 2 1 3 4 4 3 5 6 6 5 7 8 8 7 9 10 10 9 11 12 12 11 ...

et finalement nier tous les autres termes, en commençant par le premier

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ...

Le code le plus court en octets gagne.

Python 2 , 23 octets

lambda n:~n/2+n%2*(n|2)

Les entrées impaires donnent à peu près les n/2mêmes -n/2. Donc, j'ai commencé -n/2+n%2*net modifié à partir de là.

Essayez-le en ligne!

Mathematica, 29 octets

((#~GCD~4/. 4->-2)+#)/2(-1)^#&

Fonction pure prenant une entrée à 1 index. Hormis les signes alternants (-1)^#, la séquence double est proche de l’entrée, les différences étant de 1, 2, 1, -2 de manière cyclique. C'est bien que #~GCD~4, le plus grand commun diviseur de l'entrée et 4, soit 1, 2, 1, 4 cycliquement; donc nous venons de remplacer manuellement 4->-2et appelons un jour. J'aime cette approche car elle évite la plupart des commandes Mathematica comportant de nombreux caractères.

Pip , 24 22 octets

v**a*YaBA2|1+:--a//4*2

Prend l'entrée, indexé 1, comme argument de ligne de commande. Essayez-le en ligne ou vérifiez-le 1-20 .

Explication

Observez que la séquence peut être obtenue en combinant trois autres séquences, l’une indexée à zéro et l’autre indexée:

• Commencez avec 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(indexé sur 0);
• Add 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, où BAest bitwise AND et |est logique OU (indexé 1);
• Multipliez la somme par -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(indexé 1).

Si nous commençons avec a1-indexé, nous pouvons d'abord calculer les parties 1-indexées (en lisant l'expression de gauche à droite), puis les décrémenter apour la partie 0-indexée. En utilisant la variable intégrée v=-1, nous obtenons

v**a*((aBA2|1)+--a//4*2)

Pour supprimer deux octets supplémentaires, nous devons utiliser des astuces de manipulation de priorité. Nous pouvons éliminer les parenthèses internes en les remplaçant +par +:(équivalent à +=dans beaucoup de langues). Tout opérateur de calcul et d’affectation a une très faible priorité, aBA2|1+:--a//4*2est donc équivalent à (aBA2|1)+:(--a//4*2). Pip émettra un avertissement sur l'affectation de quelque chose qui n'est pas une variable, mais uniquement si les avertissements sont activés.

La seule chose qui est prioritaire sur la :est - Y, l'opérateur de Yank * Il attribue sa valeur d'opérande à la. yVariable et passe sans modification; afin que nous puissions éliminer les parenthèses extérieures ainsi que par la valeur plutôt l' accroche alors que ce parenthèse: YaBA2|1+:--a//4*2.

_{* rint Pet Output ont la même priorité que Yank, mais ne sont pas utiles ici.}

Gelée , 8 7 octets

H^Ḃ~N⁸¡

Cela utilise l'algorithme de ma réponse Python , qui a été amélioré de manière significative par @GB .

Essayez-le en ligne!

Comment ça marche

H^Ḃ~N⁸¡  Main link. Argument: n

H        Halve; yield n/2. This returns a float, but ^ will cast it to int.
  Ḃ      Bit; yield n%2.
 ^       Apply bitwise XOR to both results.
   ~     Take the bitwise NOT.
    N⁸¡  Negate the result n times.

Java 8, 19 octets

n->~(n/2)+n%2*(n|2)

Java 7, 47 37 octets

int c(int n){return~(n/2)+n%2*(n|2);}

La première fois, Java (8) est en concurrence et est plus court que d’autres réponses. Vous ne pouvez toujours pas battre les langues de golf réelles comme Jelly et autres, cependant (duhuh .. quelle surprise.>.>; P)

Port 0 indexé de la réponse Python 2 de @Xnor .
-10 octets grâce à @GB

Essayez ici.

Jelly , 15 12 11 octets

Ḷ^1‘ż@N€Fị@

Essayez-le en ligne!

Comment ça marche

Ḷ^1‘ż@N€Fị@  Main link. Argument: n

Ḷ            Unlength; yield [0, 1, 2, 3, ..., n-1].
 ^1          Bitwise XOR 1; yield [1, 0, 3, 2, ..., n-1^1].
   ‘         Increment; yield [2, 1, 4, 3, ..., (n-1^1)+1].
      N€     Negate each; yield [-1, -2, -3, -4, ..., -n].
    ż@       Zip with swapped arguments; 
             yield [[-1, 2], [-2, 1], [-3, 4], [-4, 3], ..., [-n, (n-1^1)+1]].
        F    Flatten, yield [-1, 2, -2, 1, -3, 4, -4, 3, ..., -n, (n-1^1)+1].
         ị@  At-index with swapped arguments; select the item at index n.

RProgN 2 , 31 25 22 octets

nx=x2÷1x4%{+$-1x^*}#-?

A expliqué

nx=                         # Convert the input to a number, set x to it.
   x2÷                      # Floor divide x by 2.
      1                     # Place a 1 on the stack.
       x4%{       }#-?      # If x%4 is 0, subtract 1 from x//2, otherwise...
           +                # Add the 1 and the x together.
            $-1             # Push -1
               x^           # To the power of x.
                 *          # Multiply x//2+1 by -1^x. (Invert if odd, do nothing if even)

Essayez-le en ligne!

Ruby, 26 23 18 octets

->n{~n/2+n%2*n|=2}

Basé sur 0

-3 octets volant l'idée -1 ^ n de Greg Martin , Dennis et peut-être quelqu'un d'autre, puis -5 octets dérivant l' idée n | 2 de xnor .

Empilés , 30 28 octets

:2%([:2/\4%2=tmo+][1+2/_])\#

Essayez-le en ligne! Retourne une fonction, comme autorisé par méta consensus. . Prend les entrées du haut de la pile.

En utilisant la même approche que la réponse RProgN 2 .

Sinon, 46 octets. Essayez-le en ligne! :

{!()1[::1+,:rev,\srev\,\2+]n*@.n 1-#n 2%tmo*_}

Celui-ci génère la plage, puis sélectionne et annule le membre selon le cas.

Python 2 ,  44  33 27 octets

lambda n:(-1)**n*~(n/2^n%2)

Merci à @GB d'avoir joué 6 octets au golf!

Essayez-le en ligne!

05AB1E, 8 octets

2‰`^±¹F(

Essayez-le en ligne

Explication

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate

Gelée , 9 à 8 octets

|2×Ḃ+H~$

Essayez-le en ligne!

-1 merci à Dennis . Duh float conversions.

Utilise l'approche Python 2 de @ xnor.

EDIT : > _>

CJam , 16 octets

{_(_1&)^2/)W@#*}

Entrée basée sur 1.

Essayez-le en ligne!

Explication

Voici une ventilation du code avec les valeurs sur la pile pour chaque entrée de 1à 4. Les premières commandes n'affectent que les deux bits les moins significatifs de n-1so after 4, ce truc ne se répète que de manière cyclique, les résultats étant incrémentés de 2, en raison de la réduction de moitié.

Cmd             Stack: [1]       [2]       [3]       [4]
_    Duplicate.        [1 1]     [2 2]     [3 3]     [4 4]
(    Decrement.        [1 0]     [2 1]     [3 2]     [4 3]
_    Duplicate.        [1 0 0]   [2 1 1]   [3 2 2]   [4 3 3]
1&   AND 1.            [1 0 0]   [2 1 1]   [3 2 0]   [4 3 1]
)    Increment.        [1 0 1]   [2 1 2]   [3 2 1]   [4 3 2]
^    XOR.              [1 1]     [2 3]     [3 3]     [4 1]
2/   Halve.            [1 0]     [2 1]     [3 1]     [4 0]
)    Increment.        [1 1]     [2 2]     [3 2]     [4 1]
W    Push -1.          [1 1 -1]  [2 2 -1]  [3 2 -1]  [4 1 -1]
@    Rotate.           [1 -1 1]  [2 -1 2]  [2 -1 3]  [1 -1 4]
#    -1^n.             [1 -1]    [2 1]     [2 -1]    [1 1]
*    Multiply.         [-1]      [2]       [-2]      [1]

Perl 6 ,  55 27 24  22 octets

{(-1,2,-2,1,{|($^a,$^b,$^c,$^d Z+ -2,2,-2,2)}...*)[$_]}

(Inspiré par la zipWithréponse de Haskell )
Essayez-le

{+^($_ div 2)+$_%2*($_+|2)}

(Inspiré par plusieurs réponses)
Essayez-le

{+^($_+>1)+$_%2*($_+|2)}

L'essayer

{+^$_+>1+$_%2*($_+|2)}

L'essayer

Étendu:

{  # bare block lambda with implicit parameter ｢$_｣

    +^          # numeric binary invert the following
      $_ +> 1   # numeric bit shift right by one
  +
      $_ % 2    # the input modulo 2
    *
      ($_ +| 2) # numeric binary inclusive or 2
}

(Tous sont basés sur 0)

Haskell , 37 36 octets

(([1,3..]>>= \x->[-x,x+1,-x-1,x])!!)

Essayez-le en ligne! Il s'agit d'une fonction anonyme qui prend un nombre nen argument et renvoie 0 le index nth de la séquence.

Haskell, 56 octets

f n=concat(iterate(zipWith(+)[-2,2,-2,2])[-1,2,-2,1])!!n

0 indexé

Perl 5 47 + 1 (pour drapeau) = 48 octets

print(((sin$_%4>.5)+1+2*int$_/4)*($_%4&1?1:-1))

Ancienne soumission 82 octets

@f=(sub{-$_[0]},sub{$_[0]+1},sub{-$_[0]-1},sub{$_[0]});print$f[$_%4](1+2*int$_/4)

Courez comme si:

perl -n <name of file storing script>  <<<  n

JavaScript (ES7), 28 octets

n=>(n+2>>2)*2*(-1)**n-!(n&2)

1 indexé. Je n'ai pas encore étudié d'autres réponses, donc je ne sais pas s'il s'agit du meilleur algorithme, mais je suppose que non.

JavaScript, 28 22 octets

Merci @ETHproductions pour le golf 6 octets

x=>x%2?~x>>1:x%4+x/2-1

Essayez-le en ligne!

dc , 98 octets

?sa0sb1sq[lq1+dsqla!<i3Q]sf[lb1-lfx]su[lblfx]sx[lb1+dsblfx]sj[lqdd4%d0=u1=j2%1=xljxlfx]dsix_1la^*p

Mon Dieu, c'est la réponse la plus longue ici, principalement parce que j'ai choisi de générer la valeur absolue de chaque élément de la séquence un par un en utilisant la formule récursive suivante:

puis la sortie (-1)^n * a_n, plutôt que de calculer directement lan ième élément. Quoi qu'il en soit, c'est 1-indexed.

Essayez-le en ligne!

R, 38 octets

function(n)floor(n/2+1-2*!n%%4)*(-1)^n

Explication

floor(n/2+1)                ->  1 2  2 3  3 4  4 5...
floor(n/2+1-2*!n%%4)        ->  1 2  2 1  3 4  4 3... (subtract 2 where n%%4 == 0)
floor(n/2+1-2*!n%%4)*(-1)^n -> -1 2 -2 1 -3 4 -4 3... (multiply odd n by -1)

TI-Basic (TI-84 Plus CE), 31 octets

.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))i^(2Ans

TI-Basic est un langage à jetons et chaque jeton utilisé ici est un octet, sauf remainder(deux.

Ceci utilise la version 1-indexée.

Explication:

Il existe un modèle qui se répète tous les quatre chiffres. Dans la version 1-indexée, il s'agit de: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 pour la valeur d'entrée x. Ceci peut être représenté comme une fonction définie par morceaux.

f (x) = - (x + 1) / 2 si x ≡ 1 mod 4; (x + 1) / 2 si x 2 mod 4; - (x + 1) / 2 si x 3 mod 4; (x-1) / 2 si x 0 mod 4

Les parties "x ≡ 1 mod 4" et "x 3 mod 4" étant identiques, nous pouvons les combiner en "x 1 mod 2".

Maintenant, la fonction par morceaux est:

f (x) = - (x + 1) / 2 si x ≡ 1 mod 2; (x + 2) / 2 si x 2 mod 4; (x-2) / 2 si x 0 mod 4

C'est là que je commence à le diviser en commandes réelles. Puisque la valeur est positive pour les indices pairs et négative pour les impairs, nous pouvons utiliser (-1) ^ x. Cependant, dans TI-Basic i^(2X(5 octets), sa longueur est inférieure à(-1)^Ans (6 octets). Notez que les parenthèses sont obligatoires en raison de l'ordre des opérations.

Maintenant que nous avons le moyen de supprimer les entrées impaires, nous passons aux mods (ajout de la négation plus tard). J'ai fait le cas d'une entrée impaire la valeur par défaut, nous allons donc commencer par.5(Ans+1) .

Pour résoudre le cas d'une entrée paire, ajoutez simplement un au nombre entre parenthèses, mais uniquement lorsque x 0 mod 2. Cela peut être représenté par .5(Ans+1+remainder(Ans+1,2))ou.5(Ans+1+not(remainder(Ans,2))) , mais ils ont le même nombre d'octets, donc peu importe lequel.

Pour résoudre le cas d'une entrée multiple de 4, nous devons soustraire 3 du nombre entre parenthèses, mais également un autre 1 car tous les multiples de 4 sont pairs, ce qui en ajouterait un de notre étape précédente, nous avons donc maintenant .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))) .

Maintenant, il suffit de clouer sur la partie déterminant la signalisation pour obtenir le programme complet.

Befunge 93, 25 octets

Indexé à zéro

&4/2*1+&4%3%!!+&2%2*1-*.@

Essayez-le en ligne!

Le numéro est donné par ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

QBIC , 53 octets

b=1:{[b,b+3|~b=a|_x(-(b%2)*2+1)*(q+(b%4>1)*-1)]]q=q+2

Explication:

b=1     Set b to a starting value of 1
        QBIC would usually use the pre-initialised variable q, but that is already in use
:       Get an input number from the cmd-line, our term to find
{       Start an infinite loop
[b,b+3| FOR-loop: this runs in groups of 4, incrementing its own bounds between runs
~b=a|   If we've reached the term requested
_x      QUIT the program and print:

(-(b%2)*2+1)   The b%2 gives a 1 or a 0, times 2 (2,0), negged (-2,0) and plus one (-1,1)
*              That gives us the sign of our term. Now the value:
(q+(b%4>1)*-1) This is q + 1 if the inner loop counter MOD 4 (1,2,3,0...) is 2 or 3.
]       Close the IF that checks the term
]       Close the FOR-loop
q=q+2   And raise q by 2 for the next iteration of the DO-loop.

Sage , 19 octets

::>!:><^^~![!-!-~]|

Essayez-le en ligne!

Ceci est juste un portage de @Dennis 'Jelly answer to Wise.

Q, 52 octets

{(1 rotate(,/){x,(-)x}each 1_((_)x%4)+til 3)x mod 4}

0 solution indexée.

1. Obtient le numéro de bloc c'est-à-dire. lequel bloc [-x x + 1 - (x + 1) x] de la séquence contient l'index.
2. Obtient l'index de la valeur dans le bloc en fonction de l'index de la valeur dans la séquence entière.
3. Crée le bloc.
4. Indexe par l’index dérivé de l’étape 2.