Seu desafio hoje é produzir um determinado termo de uma sequência enumerando todos os números inteiros. A sequência é a seguinte: Se temos uma função indexada em 0 gerando a sequência f(n)e ceil(x)é a função de teto, então f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))é positivo quando ne ceil(n/2)são pares ou ímpares.

Para ajudar a entender essa sequência, os primeiros termos são os seguintes: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

Sua tarefa é escrever um programa que use um número inteiro ne produza o ntermo th da sequência. A entrada pode ser indexada apenas em 0 ou 1.

Casos de teste (indexados 0):

0  =>  0
1  =>  1
2  => -1
3  => -2
4  =>  2
5  =>  3

Isso é código-golfe , o menor número de bytes vence!

SOGL V0.12 , 8 6 bytes

I».»⌡±

Experimente aqui! ou tente os primeiros números (alterados um pouco para que funcionem)
indexados em 0.

Explicação:

I       increment the input
 »      floor divide by 2
  .     push the original input
   »    floor divide by 2
    ⌡   that many times
     ±    negate

Ou mais simples:

(input + 1) // 2 negated input // 2 times
        I     »     ±      .     »    ⌡

Python 2 , 26 24 bytes

lambda x:-~x/2/(1-(x&2))

Experimente online!

JavaScript (ES6), 18 bytes

1 indexado.

n=>n/(++n&2||-2)|0

Demo

let f =

n=>n/(++n&2||-2)|0

for(n = 1; n < 20; n++) {
  console.log(n + ' --> ' + f(n))
}

C, 25 bytes

f(n){return~n/2*~-(n&2);}

Haskell , 26 bytes

f x=div(x+1)2*(-1)^div x 2

Experimente online!

As outras respostas de Haskell parecem complicar demais as coisas… ^^

Pyke , 6 bytes

heQeV_

Experimente aqui!

Usa a abordagem de dzaima ... Beats Ties Jelly!

Explicação

h      - Increment the input, which is implicit at the beginning.
 e     - Floor halve.
  Q    - Push the input.
   e   - Floor halve.
    V_ - Apply repeatedly (V), ^ times, using negation (_).
       - Output implicitly.

Os bytes codificado-hex equivalentes seria: 68 65 51 65 56 5F.

Gelatina , 6 bytes

HµĊN⁸¡

Experimente online!

Usa o algoritmo do dzaima.

-1 graças a Jonathan Allan .

Python 2 , 21 bytes

lambda x:-x/2*~-(x&2)

Experimente online!

Mathematica, 24 bytes

(s=⌈#/2⌉)(-1)^(#+s)&  

-14 bytes de @Misha Lavrov

Haskell , 25 43 42 bytes

((do a<-[0..];[[-a,a],[a,-a]]!!mod a 2)!!)

Experimente online! 1 indexado.

Edit: A versão anterior tinha os sinais em uma ordem errada, graças a @ Potato44 por apontar. Corrigido por 18 bytes ...

Edit 2: Graças ao BMO por -1 byte!

Python 3 , 29 bytes

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

Experimente online!

Pitão , 9 bytes

_F/hQ2/Q2

Experimente aqui!

Usa a abordagem do dzaima .

Haskell, 36 bytes

g x=x: -x:g(-x-signum x)
((0:g 1)!!)

Experimente online!

05AB1E , 6 bytes

;DîsF(

Experimente online!

Usa o algoritmo do dzaima.

Lote, 29 bytes

@cmd/cset/a"%1/2^(%1<<30>>30)

JavaScript (ES6), 18 bytes

f=
n=>n/2^(n<<30>>30)

<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0

Indexado a 0.

Javascript, 17 bytes

n=>~n/2*~-(n&2)^0

f=
n=>~n/2*~-(n&2)^0

<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0

Este é 0 indexado. É um truque inteiramente a bit.

Cubicamente , 23 bytes

(Indexado 1)

FDF'$:7+8/0_0*0-8*7/0%6

Experimente online!

A principal dificuldade ao escrever código no Cubically são:

• Existe apenas 1 variável gravável e
• Obter constantes é difícil.

Então, esta solução calcula

((((n+1)/2)%2)*2-1)*n/2

onde /denota divisão inteira. Isso precisa apenas de 1 variável temporária e as constantes 1 e 2.

Explicação:

FDF'$:7+8/0_0*0-8*7/0%6
FDF'                      Set face value of face 0 to 2, and value of memory index 8 (cube is unsolved) to 1 (true = unsolved)
    $                     Read input
     :7                                 input
       +8                                + 1
         /0                        (        ) /2
           _0                     (             ) %2
             *0                  (                  ) *2
               -8                                        -1
                 *7             (                          ) *n
                   /0                                          /2
                     %6   Print

TI-Basic (TI-84 Plus CE), 20 bytes

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2

Um programa completo chamado como 5:prgmNAME.

O TI-Basic é uma linguagem tokenizada , todos os tokens usados ​​aqui são de um byte, exceto remainder(dois. ‾representa o token regativo, digitado com a (-)chave

Exemplos:

0:prgmNAME
 => 0
1:prgmNAME
 => 1
2:prgmNAME
 => -1
#etc

Explicação:

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2
‾int(‾Ans/2)                           # -int(-X) is ciel(X), so ciel(Ans/2)
                          int(Ans/2)   # int(X) is floor(X), so floor(Ans/2)
                remainder(int(Ans/2),2 # 1 if floor(Ans/2) is odd else 0
            (1-2remainder(int(Ans/2),2 # -1 if floor(Ans/2) is odd, else 1
_int(_Ans/2)(1-2remainder(int(Ans/2),2 # -ciel(Ans/2) if floor(Ans/2) is odd, else ciel(Ans/2)

Mesma fórmula que uma função Y-var:

Y1= ‾int(‾X/2)(1-2remainder(int(X/2),2

dc , 16 bytes

1+d2~+2%2*1-r2/*

Tenho certeza de que há uma maneira de reduzir 0..1 a -1..1 em dc, mas não há ideias por enquanto.

Experimente online!

Java 8, 15 bytes

n->~n/2*~-(n&2)

EDIT: Java é realmente a menor das linguagens não-golfe ?! o.Ô

Explicação:

Experimente aqui.

Vou usar a tabela abaixo como referência do que está acontecendo.

1. ~né igual a -n-1.
2. Como a divisão inteira em Java se baseia automaticamente em números inteiros positivos e em tetos em números inteiros negativos, ~n/2resultará na sequência0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
3. n&2resultará em 0ou 2, na sequência0,0,2,2,0,0,2,2,0,0,2,...
4. ~-xé igual a (x-1), então ~-(n&2)(((n&2)-1) ) resulta na sequência-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
5. Multiplicar as duas sequências de ~n/2e ~-(n&2)dá é a sequência correta solicitada no desafio:0,1,-1,-2,2,3,-3,-4,4,5,-5,...

Tabela de visão geral:

n       ~n      ~n/2    n&2     ~-(n&2)     ~n/2*~-(n&2)
0       -1      0       0       -1          0
1       -2      -1      0       -1          1
2       -3      -1      2       1           -1
3       -4      -2      2       1           -2
4       -5      -2      0       -1          2
5       -6      -3      0       -1          3
6       -7      -3      2       1           -3
7       -8      -4      2       1           -4
8       -9      -4      0       -1          4
9       -10     -5      0       -1          5
10      -11     -5      2       1           -5

Flacidez Cerebral , 86 74 72 70 bytes

{({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}<>{}{<>([{}])(<>)}<>

Experimente online!

Explicação

Existem duas partes nesse código. A primeira parte

({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}

faz o esforço da computação. Ele determina ceil(n/2)e se deve ou não negar a saída.

Para explicar como funciona, primeiro explicarei como calcular ceil(n/2). Isso pode ser feito com o seguinte código

{({}[()]<({}([{}]()))>)}{}

Isso é decrescente de n cada vez que ele executa um not ( ([{}]())) em um contador e adiciona o contador a um resultado. Como o contador é zero na metade do tempo, apenas incrementamos todas as outras execuções, começando pela primeira.

Agora também quero calcular o sinal de nossos resultados. Para fazer isso, começamos outro contador. Este contador só muda de estado se o primeiro contador estiver desativado. Dessa forma, obtemos o padrão desejado. Colocamos esses dois contadores na pilha para facilitar a movimentação quando chegar a hora.

Agora que terminamos esse cálculo, nossa pilha fica assim

          parity(n)
ceil(n/2) sign

Então, precisamos trabalhar para obter o resultado pretendido nesta segunda parte.

<>{}{<>([{}])(<>)}<>

Perl 5 , 32 + 1 ( -p) = 33 bytes

$_='-'x(($_+++($b=0|$_/2))%2).$b

Experimente online!

Próton , 23 bytes

n=>-~n//2//(-1)**(n//2)

Experimente online!

Solução do porto de Halvard .

Próton , 23 bytes

n=>-~n//2*(-1)**(n%4>1)

Experimente online!

Solução do Porto de Leaky .

Um pouco mais protônico, 24 bytes:

n=>-~n//2*(**)(-1,n%4>1)

QBIC , 27 26 bytes

g=(:+1)'\2`~(a-g)%2|?-g\?g

Explicação

g=          set worker var 'g' to
(:+1)           our index (plus one for the ceil() bit)
'\2`            integer divided by 2 (the int div needs a code literal: '..`
~(a-g)%2    IF index - temp result is odd (index 2 minus result 1 = 1)
|?-g        THEN PRINT g negated
\?g         ELSE PRINT g

Clojure 122 bytes

Detalhado, mesmo quando jogado. Eu estou indo para o voto de simpatia aqui ... :-)

Golfe:

(defn d[n](let[x(int(Math/ceil(/ n 2)))y(cond(or(and(even? n)(even? x))(and(odd? n)(odd? x)))(Math/abs x):else(- 0 x))]y))

Ungolfed:

(defn dizzy-integer [n]
  (let [x   (int (Math/ceil (/ n 2)))
        y   (cond
                (or (and (even? n) (even? x))
                    (and (odd? n)  (odd? x))) (Math/abs x)
                :else (- 0 x)) ]
    y))

Excel VBA de 32 bits, ₃₉ 37 bytes

Função de janela imediata VBE anônima que recebe entrada da célula A1e sai para a janela imediata VBE

?[Sign((-1)^Int(A1/2))*Int((A1+1)/2)]

Restrito a 32 bits, pois A^Bnão é válido em 64 bits ( A ^Bé o mais próximo possível)

Julia 0,6 , 16 bytes

É apenas a solução java, exceto que eu preciso ÷para a divisão inteira.

n->~n÷2*~-(n&2)

Experimente online!