Dado N, imprima o termo enésimo desta sequência infinita:

-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 pode ser indexado em 0 ou 1 como desejar.

Por exemplo, se 0-indexados então entradas 0, 1, 2, 3, 4deve produzir saídas respectivas -1, 2, -2, 1, -3.

Se um indexados então entradas 1, 2, 3, 4, 5deve produzir saídas respectivas -1, 2, -2, 1, -3.

Para ficar claro, essa sequência é gerada tomando a sequência de números inteiros positivos repetida duas vezes

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

e reorganizando cada par de números ímpares para cercar os números pares logo acima

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

e, finalmente, negando todos os outros termos, começando com o primeiro

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

O código mais curto em bytes vence.

Python 2 , 23 bytes

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

Entradas ímpares fornecem aproximadamente n/2, mesmo as aproximadamente -n/2. Então, comecei -n/2+n%2*ne aprimorei a partir daí.

Experimente online!

Mathematica, 29 bytes

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

Função pura recebendo uma entrada indexada em 1. Além dos sinais alternados (-1)^#, duas vezes a sequência está próxima da entrada, as diferenças sendo 1, 2, 1, -2 ciclicamente. É bom que #~GCD~4, o maior divisor comum da entrada e 4, seja 1, 2, 1, 4 ciclicamente; então substituímos manualmente 4->-2e chamamos de dia. Eu gosto dessa abordagem porque evita a maioria dos comandos do Mathematica com muitos caracteres.

Pip , 24 22 bytes

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

Recebe entrada, indexada em 1, como um argumento de linha de comando. Experimente online ou verifique 1-20 .

Explicação

Observe que a sequência pode ser obtida combinando três outras seqüências, uma indexada a zero e as outras indexadas:

• Comece com 0 0 0 0 2 2 2 2 4 4 4 4=a//4*2 (indexado 0);
• Adicione 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, onde BAé AND bit a bit e| é OR lógico (indexado a 1);
• Multiplique a soma por -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(indexado a 1).

Se começarmos com o aíndice 1, podemos calcular primeiro as partes indexadas em 1 (lendo a expressão da esquerda para a direita) e depois diminuir apara a parte indexada em 0. Usando a variável embutida v=-1, obtemos

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

Para raspar mais dois bytes, precisamos usar alguns truques de manipulação de precedência. Podemos eliminar os parênteses internos substituindo +por +:(equivalente a +=muitos idiomas). Qualquer operador de computação e atribuição tem uma precedência muito baixa, portanto aBA2|1+:--a//4*2é equivalente a(aBA2|1)+:(--a//4*2) . O Pip emitirá um aviso sobre a atribuição a algo que não é uma variável, mas apenas se tivermos avisos ativados.

A única coisa que tem precedência mais baixa do que :é Y, o operador yank. * Atribui o valor do seu operando à yvariável e o passa inalterado; para que também possamos eliminar os parênteses externos, puxando o valor em vez de parênteses:YaBA2|1+:--a//4*2 .

_{* rint Pe Output têm a mesma precedência que Yank, mas não são úteis aqui.}

Geléia , 8 7 bytes

H^Ḃ~N⁸¡

Isso usa o algoritmo da minha resposta Python , que foi melhorada significativamente pelo @GB .

Experimente online!

Como funciona

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 bytes

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

Java 7, 47 37 bytes

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

O Java pela primeira vez (8) realmente compete e é mais curto do que algumas outras respostas. Ainda não consegue vencer as línguas de golfe reais, como Jelly e similares (duhuh .. que surpresa ..>.>; P)

Porta indexada a 0 da resposta Python 2 do @Xnor .
-10 bytes graças a @GB

Experimente aqui.

Geléia , 15 12 11 bytes

Ḷ^1‘ż@N€Fị@

Experimente online!

Como funciona

Ḷ^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 bytes

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

Explicado

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)

Experimente online!

Ruby, 26 23 18 bytes

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

Baseado em 0

-3 bytes roubando a idéia -1 ^ n de Greg Martin , Dennis e talvez outra pessoa; depois, -5 bytes roubando a idéia n | 2 do xnor .

Empilhados , 30 28 bytes

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

Experimente online! Retorna uma função, conforme permitido por meta consenso. . Recebe entrada do topo da pilha.

Usando a mesma abordagem que a resposta do RProgN 2 .

Como alternativa, 46 bytes. Experimente online! :

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

Este gera o intervalo, seleciona e nega o membro, conforme apropriado.

Python 2 ,  44  33 27 bytes

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

Graças a @GB por jogar fora 6 bytes!

Experimente online!

05AB1E, 8 bytes

2‰`^±¹F(

Experimente online

Explicação

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

Geléia , 9 8 bytes

|2×Ḃ+H~$

Experimente online!

-1 graças a Dennis . Duh conversões flutuantes.

Usa a abordagem Python 2 do @ xnor.

EDIT : > _>

CJam , 16 bytes

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

Entrada baseada em 1.

Experimente online!

Explicação

Aqui está um detalhamento do código com os valores na pilha para cada entrada de 1até 4. Os primeiros comandos afetam apenas os dois bits menos significativos, n-1portanto 4, esse material se repete ciclicamente, com os resultados incrementados em 2, devido à metade.

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 bytes

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

(Inspirado na zipWithresposta de Haskell )
Experimente

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

(Inspirado em várias respostas)
Experimente

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

Tente

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

Tente

Expandido:

{  # 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
}

(Todos são baseados em 0)

Haskell , 37 36 bytes

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

Experimente online! Esta é uma função anônima que pega um número ncomo argumento e retorna 0-indexado o nelemento th da sequência.

Haskell, 56 bytes

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

Indexado a 0

Perl 5 47 + 1 (para sinalizador) = 48 bytes

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

Envio antigo 82 bytes

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

Execute assim:

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

JavaScript (ES7), 28 bytes

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

1 indexado. Ainda não procurei outras respostas, então não sei se esse é o melhor algoritmo, mas suspeito que não.

JavaScript, 28 22 bytes

Obrigado @ETHproductions por jogar fora 6 bytes

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

Experimente online!

dc , 98 bytes

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

Nossa, essa é a resposta mais longa aqui, principalmente porque eu segui o caminho de gerar o valor absoluto de cada elemento da sequência, um por um, com base na seguinte fórmula recursiva:

então produzindo (-1)^n * a_n , , em vez de computar diretamente o n'ésimo elemento. De qualquer forma, isso é1 indexado.

Experimente online!

R, 38 bytes

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

Explicação

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 bytes

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

O TI-Basic é um idioma tokenizado e cada token usado aqui tem um byte, exceto remainder(dois.

Isso usa a versão indexada em 1.

Explicação:

Há um padrão que se repete a cada quatro números. Na versão indexada em 1, é: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 para o valor de entrada x. Isso pode ser representado como uma função definida por partes.

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

Como as partes "x ≡ 1 mod 4" e "x ≡ 3 mod 4" são as mesmas, podemos combiná-las em "x ≡ 1 mod 2".

Agora, a função por partes é:

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

É aqui que começo a dividi-lo em comandos reais. Como o valor é positivo para índices pares e negativo para índices ímpares, podemos usar (-1) ^ x. No entanto, no TI-Basic i^(2X(5 bytes) é menor que(-1)^Ans (6 bytes). Observe que parênteses são necessários devido à ordem das operações.

Agora que temos o caminho de negar as entradas ímpares do caminho, passamos aos mods (adicionando a negação novamente mais tarde). Eu fiz o caso de uma entrada ímpar o padrão, então começamos com.5(Ans+1) .

Para corrigir o caso da entrada par, basta adicionar um ao número entre parênteses, mas apenas quando x ≡ 0 mod 2. Isso pode ser representado como .5(Ans+1+remainder(Ans+1,2))ou .5(Ans+1+not(remainder(Ans,2))), mas eles têm a mesma contagem de bytes, portanto, não importa qual.

Para consertar o caso da entrada múltipla de 4, precisamos subtrair 3 do número entre parênteses, mas também outra 1 porque todos os múltiplos de 4 são pares, o que adicionaria um da etapa anterior, portanto, agora temos .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))) .

Agora, basta seguir a parte que determina os sinais até o final para obter o programa completo.

Entre 93, 25 bytes

Indexado a zero

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

Experimente Online!

O número é dado por ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

QBIC , 53 bytes

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

Explicação:

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.

Sábio , 19 bytes

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

Experimente Online!

Este é apenas um porto da resposta do @Dennis 'Jelly para o Wise.

Q, 52 bytes

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

0 solução indexada.

1. Obtém o número do bloco, ie. qual bloco [-x x + 1 - (x + 1) x] dentro da sequência contém o índice.
2. Obtém o índice do valor dentro do bloco com base no índice do valor em toda a sequência.
3. Cria o bloco.
4. Indexa nele por meio do índice derivado na etapa 2.