Bei einer Eingabe einer einzelnen positiven Ganzzahl wird die dieser Ganzzahl entsprechende "alternierende Quersumme" ausgegeben.

Nehmen Sie das Beispiel der Eingabe n=5. Um die alternierende Quersumme zu finden, erstellen Sie zunächst ein quadratisches Gitter mit Breite und Höhe n, das von links nach rechts und von oben nach unten beginnt 1und sich an jeder Position um eins erhöht:

 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

Nehmen Sie dann die Summen aus dem Raster, die ein "Kreuz" bilden (dh beide Diagonalen kombiniert):

 1           5
    7     9
      13
   17    19
21          25

1 5 7 9 13 17 19 21 25

Schließlich nehmen Sie die alternierende Summe dieser Sequenz:

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

-11

Ein weiteres Beispiel für n=6(um nur zu zeigen, wie das Kreuz für gerade Zahlen aussieht 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

Da es sich um Code-Golf , wird der kürzeste Code in Bytes gewinnen.

Hier sind die richtigen Ausgaben für n=1to n=100, die Sie als Testfälle verwenden können:

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

Jelly, 21 19 11 10 7 Bytes

²~³¡H+2

Probieren Sie es online!

Idee

Nehmen Sie für eine Sekunde an, dass der erste Term der Endsumme nicht addiert, sondern subtrahiert wird.

Sei n eine positive ganze Zahl.

Auch Fall

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

Die Unterschiede zwischen den diagonalen Elementen in der unteren Hälfte der Reihen sind die ersten n od 2 ungeraden natürlichen Zahlen. Da 1 + 3 + 5 +… + (2k + 1) = k ² , summieren sie sich zu (n ≤ 2) ² = n ² ≤ 4 .

In diesem Beispiel

- 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

Somit ist die Summe 2 × n ² ≤ 4 = n ² ≤ 2 .

Seltsamer Fall

 1           5
    7     9
      13
   17    19
21          25

Die Unterschiede zwischen den diagonalen Elementen in den entsprechenden Zeilen von oben und unten ( 1und 5und 21und 25; 7und 9und 17und 19) sind gleich, sodass sie sich in der alternierenden Summe ausgleichen.

In diesem Beispiel

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

Alles, was übrig bleibt, ist das Negativ des zentralen Elements, das das arithmetische Mittel der ersten und letzten Zahl ist, sodass es berechnet werden kann als - (n ² + 1) ÷ 2 .

Allgemeiner Fall

Da ~ x = - (x + 1) für Zweierkomplement-Ganzzahlen ( ~ bedeutet bitweise NICHT), kann die Formel für den ungeraden Fall als ~ n ² ÷ 2 umgeschrieben werden .

Da der erste Term ( 1 ) der ursprünglichen Summe addiert statt subtrahiert wird, hinterlassen die obigen Formeln einen Fehler von 2 , der korrigiert werden muss.

Daher ist die n- ^te alternierende Quersumme n ² ≤ 2 + 2, wenn n gerade ist, und ~ n ² ≤ 2 + 2, wenn sie ungerade ist.

Schließlich ist bitweises NICHT eine Involution, dh ~~ x = x für alle x . Auf diese Weise ist ~~~ x = ~ x , ~~~~ x = x , und im Allgemeinen ist ~ ⁿ x (was bedeutet, dass ~ n- mal angewendet wird) x, wenn n gerade ist, und ~ x, wenn es ungerade ist.

Daher können wir unsere allgemeine Formel für alle positiven ganzen Zahlen n als ~ ⁿ n ² ÷ 2 + 2 umschreiben .

Code

²~³¡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

Die Verwendung dieser neuen, ausgefallenen Lösung in geschlossener Form ist der letzte Schrei!

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

Dank ThomasKwa kann ich meine teure rekursive Funktion eliminieren.

Gelee, 12 Bytes

RṖµ²+‘×-*$SC

Probieren Sie es hier aus .

CJam, 13 15 Bytes

ri2#_{~}*2/2+

Zwei Bytes weniger dank Dennis.

Probieren Sie es online!

Minkolang 0.15 , 26 15 13 Bytes

Ich benutze Dennis 'verrückten Algorithmus und habe dank ihm zwei weitere Bytes abgespielt. Dieser Typ ist für die Halbierung der Byteanzahl verantwortlich!

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

Probieren Sie es hier aus!

Erläuterung

@VoteToClose n^ 2, bitweise NICHT nmal anwenden , vier addieren, halbieren. - Thomas Kwa vor 7 Minuten

Siehe Dennis 'Antwort für die Erklärung, warum das funktioniert. In einem Kommentar zu dieser Antwort schlug er eine weitere Verbesserung vor, die funktioniert, weil :es sich um eine Ganzzahldivision handelt, sodass ich die Spitze des Stapels negieren und mir keine Sorgen um die +1 machen kann, wenn ich das binäre Komplement mache. Außerdem haben n und n ^ 2 die gleiche Parität, so dass kein Swap erforderlich ist.

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+

Dies verwendet den Algorithmus aus meiner Gelee-Antwort . Probieren Sie es online!

Wie es funktioniert

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

Einfacher Port von @ Dennis's Python 2 Antwort.

Während ich diese Antwort schrieb, schaffte ich es auch, meinen ES6-Port auf 17 Bytes zu golfen!

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

MATL , 13 27 Bytes

Mit Dennis 'tollen Formeln:

2^t2\?Q_]2/2+

Probieren Sie es online!

Direkter Ansatz ( 27 Bytes ):

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

Pure Bash, 28

Nun, da @Dennis uns alle gezeigt hat, wie das geht, muss Folgendes aktualisiert werden:

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

Vorherige Antwort:

Bash + GNU-Dienstprogramme, 77

Hier ist ein Anfang:

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

N wird als Befehlszeilenparameter übergeben.

pasteist hier wirklich praktisch, um die Wechselsumme zu erzeugen. Die -dOption erlaubt eine Liste von Trennzeichen, die zyklisch verwendet werden.

Julia, 41 40 25 19 16 Bytes

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

Dies ist eine anonyme Funktion, die eine Ganzzahl akzeptiert und eine Ganzzahl zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Der Ansatz, den Dennis hier entwickelt hat, ist folgender. Zuerst erhalten wir die Parität von n , dh n (mod 2) und negieren sie. Dies ergibt 0 für gerade Eingaben und -1 für ungerade. Wir haben dann bitweise XOR mit n ² . Wenn n gerade ist, ist dies nur n ^2, da XOR mit 0 nur die Zahl ist. Wenn n ungerade ist, entspricht XOR mit -1 der bitweisen Negation. An diesem Punkt haben wir entweder n ² oder das bitweise NICHT von n ² . Wir teilen dies durch 2 und addieren 2, um das Ergebnis zu erhalten.

Dank Sp3000 in einer früheren Version ein Byte und dank Dennis in dieser Version 9 Byte gespart!

Jolf, 13 Bytes

Probieren Sie es hier aus!

½?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

Dies verwendet den Algorithmus von meiner Gelee-Antwort mit einer geringfügigen Änderung:

Anstatt ~ n- mal anzuwenden, wenden wir - n- mal an (durch Multiplizieren mit (-1) ⁿ ). Dies ist äquivalent, da in Python ~ x = -x - 1 und Ganzzahlunterteilung sind, also ~ x / 2 = (-x - 1) / 2 = -x / 2 .

Pyth, 11 Bytes

+2/u_GQ*QQ2

Probieren Sie es online in der Pyth-Compiler .

Wie es funktioniert

Dies verwendet den Algorithmus aus meiner Gelee-Antwort mit einer geringfügigen Änderung:

Anstatt ~ n- mal anzuwenden, wenden wir - n- mal an (durch Multiplizieren mit (-1) ⁿ ). Dies ist äquivalent, da in Pyth ~ x = -x - 1 und Ganzzahlunterteilung sind, also ~ 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

Mit der gleichen bewährten Formel von Dennis:

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

Probieren Sie es online aus _{Oh, warum enthält die Ideone-Bash-Sandbox nicht dc?}

Befehlszeilentest:

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

GS2, 9 Bytes

V,@!α2+''

Dies verwendet den Algorithmus aus meiner Gelee-Antwort . Probieren Sie es online!

V,@e 7+''

ist ebenfalls kurz, enthält jedoch keine Nicht-ASCII-Zeichen.

Wie es funktioniert

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

Dies verwendet den gleichen Algorithmus wie meine Gelee-Antwort. Testen Sie es mit J.js .

Lua, 33 Bytes ( Online testen )

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

Wie es funktioniert:

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*⊢

Dies verwendet den gleichen Algorithmus wie meine Gelee-Antwort. Testen Sie es auf TryAPL .