Dada a entrada de um único número inteiro positivo, imprima a "soma alternada cruzada" que corresponde a esse número inteiro.

Veja o exemplo da entrada n=5. Para encontrar a soma alternada cruzada, primeiro crie uma grade quadrada de largura e altura nque, lendo da esquerda para a direita e de cima para baixo, inicie 1e aumente em uma cada posição:

 1  2  3  4  5
 6  7  8  9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25

Em seguida, pegue as somas da grade que formam uma "cruz" (ou seja, as duas diagonais combinadas):

 1           5
    7     9
      13
   17    19
21          25

1 5 7 9 13 17 19 21 25

Por fim, pegue a soma alternada desta sequência:

1+5-7+9-13+17-19+21-25

-11

Outro exemplo, para n=6(apenas para mostrar como é a cruz para números pares n):

 1  2  3  4  5  6
 7  8  9 10 11 12
13 14 15 16 17 18
19 20 21 22 23 24
25 26 27 28 29 30
31 32 33 34 35 36

 1              6
    8       11
      15 16
      21 22
   26       29
31             36

1+6-8+11-15+16-21+22-26+29-31+36

20

Como esse é o código-golfe , o código mais curto em bytes será vencedor.

Aqui estão as saídas corretas para n=1to n=100, que você pode usar como casos de teste:

1
4
-3
10
-11
20
-23
34
-39
52
-59
74
-83
100
-111
130
-143
164
-179
202
-219
244
-263
290
-311
340
-363
394
-419
452
-479
514
-543
580
-611
650
-683
724
-759
802
-839
884
-923
970
-1011
1060
-1103
1154
-1199
1252
-1299
1354
-1403
1460
-1511
1570
-1623
1684
-1739
1802
-1859
1924
-1983
2050
-2111
2180
-2243
2314
-2379
2452
-2519
2594
-2663
2740
-2811
2890
-2963
3044
-3119
3202
-3279
3364
-3443
3530
-3611
3700
-3783
3874
-3959
4052
-4139
4234
-4323
4420
-4511
4610
-4703
4804
-4899
5002

Geléia, 21 19 11 10 7 bytes

²~³¡H+2

Experimente online!

Idéia

Suponha por um segundo que o primeiro termo da soma final seja subtraído em vez de adicionado.

Seja n um número inteiro positivo.

Caso uniforme

 1              6
    8       11
      15 16
      21 22
   26       29
31             36

As diferenças entre os elementos diagonais na metade inferior das linhas são os primeiros n ÷ 2 números naturais ímpares. Como 1 + 3 + 5 +… + (2k + 1) = k ² , eles somam (n ÷ 2) ² = n ² ÷ 4 .

Neste exemplo

- 1 + 6 - 8 + 11 - 15 + 16 - 21 + 22 - 26 + 29 - 31 + 36  =
-(1 - 6)-(8 - 11)-(15 - 16)-(21 - 22)-(26 - 29)-(31 - 36) =
(    5   +   3    +    1  )+(   1    +    3    +    5   ) =
             9             +              9               = 18

Assim, a soma é 2 × n ² ÷ 4 = n ² ÷ 2 .

Caso estranho

 1           5
    7     9
      13
   17    19
21          25

As diferenças entre os elementos diagonais nas linhas correspondentes de cima e de baixo ( 1e 5, e 21e 25; 7e 9, e 17e 19) são as mesmas, portanto, elas serão canceladas na soma alternada.

Neste exemplo

- 1 + 5 - 7 + 9 - 13 + 17 - 19 + 21 - 25  =
-(1 - 5)-(7 - 9)- 13 +(17 - 19)+(21 - 25) =
    4   +   2   - 13 -    2    -    4     = -13

Tudo o que resta é o negativo do elemento central, que é a média aritmética do primeiro e do último número, para que possa ser calculado como - (n ² + 1) ÷ 2 .

Caso Geral

Como ~ x = - (x + 1) para números inteiros de complemento de dois ( ~ denota NOT bit a bit), a fórmula do caso ímpar pode ser reescrita como ~ n ² ÷ 2 .

Além disso, como o primeiro termo ( 1 ) da soma original é adicionado em vez de subtraído, as fórmulas acima deixam um erro 2 , que deve ser corrigido.

Portanto, a ^nésima soma de cruzada alternativa é n ² ÷ 2 + 2 se n for par e ~ n ² ÷ 2 + 2 se for ímpar.

Finalmente, NOT bit a bit é uma involução, ou seja, ~~ x = x para todos os x . Dessa forma, ~~~ x = ~ x , ~~~~ x = x e, em geral, ~ ⁿ x (significando que ~ é aplicado n vezes) é x se n for par e ~ x se for ímpar.

Assim, podemos reescrever nossa fórmula geral como ~ ⁿ n ² ÷ 2 + 2 para todos os números inteiros positivos n .

Código

²~³¡H+2    Main link. Input: n

²          Yield n².
 ~         Apply bitwise NOT to n²...
  ³¡           n times.
    H      Halve the result.
     +2    Add 2.

JavaScript, 40 38 22 bytes

Usar essa solução sofisticada e cheia de estilo, cheia de fanfarras, é toda a raiva!

n=>(n%2?3-n*n:4+n*n)/2

Graças à ThomasKwa, posso eliminar minha função recursiva dispendiosa.

Gelatina, 12 bytes

RṖµ²+‘×-*$SC

Experimente aqui .

CJam, 13 15 bytes

ri2#_{~}*2/2+

Dois bytes de desconto, graças a Dennis.

Experimente online!

Número 0.15 , 26 15 13 bytes

Usando o algoritmo insano de Dennis, jogou mais dois bytes graças a ele. Esse cara é responsável pela metade da contagem de bytes!

n2;d[~]4+2:N.

Experimente aqui!

Explicação

@VoteToClose n^ 2, aplique as nvezes NÃO bit a bit , adicione quatro e reduza pela metade. - Thomas Kwa 7 mins atrás

Veja a resposta de Dennis para a explicação de por que isso funciona. Em um comentário sobre essa resposta, ele sugeriu outra melhoria que funciona porque :é a divisão inteira, para que eu possa negar o topo da pilha e não me preocupar com o +1 de fazer o complemento binário. Além disso, n e n ^ 2 têm a mesma paridade, o que elimina a necessidade de uma troca.

n                Take number from input - n
 2;              n**2
   d             Duplicates top of stack
    [~]          For loop that negates the top of stack n times
       4+        Add 4
         2:      Divide by 2
           N.    Output as number and stop.

GolfScript, 12 bytes

~2?.{~}*2/2+

Isso usa o algoritmo da minha resposta Jelly . Experimente online!

Como funciona

~            # Evaluate the input.
 2?          # Square it.
   .         # Push a copy of the square.
    {~}      # Push a code block that applies bitwise NOT.
       *     # Execute it n² times. Since n² and n have the same parity,
             # this is equivalent to executing in only n times.
        2/   # Halve the result.
          2+ # Add 2.

ES7, 17 bytes

n=>-1**n*n*n+4>>1

Porta simples da resposta Python 2 de @ Dennis.

Enquanto escrevia esta resposta, também consegui rodar minha porta ES6 com 17 bytes!

n=>(n*n^-n%2)/2+2

MATL , 13 27 bytes

Usando as incríveis fórmulas de Dennis:

2^t2\?Q_]2/2+

Experimente online!

Abordagem direta ( 27 bytes ):

2^:GtetXdwPXdhutn:-1w^!*s2+

Pure Bash, 28

Bem, agora que o @Dennis nos mostrou tudo como fazer isso, isso precisa ser atualizado:

echo $[-1**$1*($1*$1+1)/2+2]

Resposta anterior:

Utilitários Bash + GNU, 77

Aqui está um começo:

a=$1
(seq 1 $[a+1] $[a*a]
seq $1 $[a>1?a-1:1] $[a*a])|sort -un|paste -sd+-|bc

N é passado como um parâmetro de linha de comando.

pasteé realmente útil aqui para produzir a soma alternada. A -dopção permite uma lista de caracteres separadores, que são usados ​​ciclicamente.

Julia, 41 40 25 19 16 bytes

n->-n%2$n^2÷2+2

Esta é uma função anônima que aceita um número inteiro e retorna um número inteiro. Para chamá-lo, atribua-o a uma variável.

A abordagem aqui, elaborada por Dennis, é a seguinte. Primeiro obtemos a paridade de n , ou seja, n (mod 2) e a negamos. Isso nos dá 0 para entradas pares e -1 para ímpares. Em seguida, bit a bit XOR com n ² . Quando n é par, isso é apenas n ² porque XOR com 0 é apenas o número. Quando n é ímpar, XOR com -1 é igual à negação bit a bit. Então, neste ponto, ou temos n ² ou NÃO bit a bit de n ² . Nós inteiro dividimos isso por 2 e adicionamos 2 para obter o resultado.

Salvou um byte graças ao Sp3000 em uma versão anterior e salvou 9 graças ao Dennis nesta versão!

Jolf, 13 bytes

Experimente aqui!

½?mρj-3Qj+4Qj
 ?mρj         if parity of j
     -3Qj     return 3 - j*j
         +4Qj else return 4 + j*j
½             (and halve the result)

Python 2, 24 bytes

lambda n:(-1)**n*n*n/2+2

Isso usa o algoritmo da minha resposta Jelly , com uma pequena modificação:

Em vez de aplicar ~ n vezes, aplicamos - n vezes (multiplicando por (-1) ⁿ ). Isso é equivalente porque ~ x = -x - 1 e pisos de divisão inteira em Python, então ~ x / 2 = (-x - 1) / 2 = -x / 2 .

Pitão, 11 bytes

+2/u_GQ*QQ2

Experimente online no Pyth Compiler .

Como funciona

Isso usa o algoritmo da minha resposta Jelly , com uma pequena modificação:

Em vez de aplicar ~ n vezes, aplicamos - n vezes (multiplicando por (-1) ⁿ ). Isso é equivalente porque ~ x = -x - 1 e pisos de divisão inteira em Pyth, então ~ x / 2 = (-x - 1) / 2 = -x / 2 .

+2/u_GQ*QQ2  Evaluated input: Q

       *QQ   Yield Q².
   u  Q      Set G = Q². For each non-negative integer below Q:
    _G         Set G = -G.
             Return G.
  /       2  Halve the result.
+2           Add 2.

dc, 17

Usando a mesma fórmula testada e comprovada de Dennis:

?dd*1+r_1r^*2/2+p

Experimente online _{Oh, por que a sandbox Ideone bash não inclui dc?}

Teste de linha de comando:

for i in {1..100}; do echo $i | dc -e '?dd*1+r_1r^*2/2+p'; done 

GS2, 9 bytes

V,@!α2+''

Isso usa o algoritmo da minha resposta Jelly . Experimente online!

V,@e 7+''

é igualmente curto, mas notavelmente não contém caracteres não ASCII.

Como funciona

V          Parse the input as an integer n.
 ,         Compute n².
  @        Push a copy of n².
   !       Bitwise NOT.
    α      Make a block of the previous instruction.
     2     Execute the block n² times. Since n² and n have the same parity,
           this is equivalent to executing in only n times.
      +    Halve the result.
       ''  Increment twice.

J, 16 bytes

[:<.2%~4+*:*_1^]

Isso usa o mesmo algoritmo da minha resposta Jelly. Testá-lo com J.js .

Lua, 33 bytes ( Experimente online )

i=(...)print((-1)^i*i*i/2-.5*i%2)

Como funciona:

i=(...)print((-1)^i*i*i/2-.5*i%2)
i=(...)                           Take input and store to i
       print(
             (-1)^i               Raise (-1) to the i-th power: -1 if odd, 1 if even
                   *i*i/2         Multiply by i squared and halved.
                         -.5*i%2  i%2 is the remainder when i is divided by 2
                                  if i is odd, then i%2 will be 1, and this expression
                                  will evaluate to -0.5
                                  but if i is even, then i%2 will be 0, which makes
                                  this expression evaluate to 0
                                )

Dyalog APL, 13 bytes

⌊2+.5××⍨ׯ1*⊢

Isso usa o mesmo algoritmo da minha resposta Jelly. Teste-o no TryAPL .