Bei N wird der N-te Term dieser unendlichen Folge ausgegeben:

-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 kann 0-indiziert oder 1-indiziert sein, wie Sie es wünschen.

Wenn beispielsweise 0-indexiert dann Eingänge 0, 1, 2, 3, 4sollte jeweilige Ausgänge erzeugen -1, 2, -2, 1, -3.

Wenn dann die Eingänge 1-indexieren 1, 2, 3, 4, 5sollte jeweilige Ausgänge erzeugen -1, 2, -2, 1, -3.

Um klar zu sein, wird diese Sequenz erzeugt, indem die Sequenz positiver Ganzzahlen zweimal wiederholt wird

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

und jedes Paar von ungeraden Zahlen neu anzuordnen, um die geraden Zahlen direkt darüber zu umgeben

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

und schließlich jeden anderen Ausdruck zu negieren, beginnend mit dem ersten

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

Der kürzeste Code in Bytes gewinnt.

Python 2 , 23 Bytes

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

Ungerade Eingaben ergeben ungefähr n/2gerade Eingaben -n/2. Also habe ich angefangen -n/2+n%2*nund von dort aus gezwickt.

Probieren Sie es online!

Mathematica, 29 Bytes

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

Reine Funktion, die einen 1-indizierten Eingang verwendet. Abgesehen von den Wechselzeichen (-1)^#liegt die doppelte Sequenz nahe am Eingang, die Differenzen betragen zyklisch 1, 2, 1, -2. Es ist schön, dass #~GCD~4, der größte gemeinsame Teiler der Eingabe 4, zyklisch 1, 2, 1, 4 ist; also ersetzen wir es einfach manuell 4->-2und nennen es einen Tag. Ich mag diesen Ansatz, weil er die meisten Mathematica-Befehle mit vielen Zeichen vermeidet.

Pip , 24 22 Bytes

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

Nimmt 1-indizierte Eingaben als Befehlszeilenargument. Versuchen Sie es online oder bestätigen Sie 1-20 .

Erläuterung

Beachten Sie, dass die Sequenz erhalten werden kann, indem drei andere Sequenzen kombiniert werden, eine mit Nullindex und die anderen mit einem Index:

• Beginnen Sie mit 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(0-indiziert);
• Add 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, wobei BAbitweises UND und |logisches ODER (1-indiziert) ist;
• Multiplizieren Sie die Summe mit -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(1-indiziert).

Wenn wir mit a1-indiziert beginnen, können wir zuerst die 1-indizierten Teile berechnen (den Ausdruck von links nach rechts lesen) und dann afür den 0-indizierten Teil dekrementieren . Mit der eingebauten Variablen erhalten v=-1wir

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

Um zwei weitere Bytes zu rasieren, müssen wir einige Tricks zur Vorrangmanipulation anwenden. Wir können die inneren Klammern durch Ersetzen +durch +:(entspricht +=in vielen Sprachen) beseitigen . Jeder Compute-and-Assign-Operator hat eine sehr niedrige Priorität und aBA2|1+:--a//4*2ist daher äquivalent zu (aBA2|1)+:(--a//4*2). Pip gibt eine Warnung zum Zuweisen zu etwas aus, das keine Variable ist, aber nur, wenn Warnungen aktiviert sind.

Das einzige , was niedrigere Priorität ist als :heißt Y, die yank Operator * Es seines Operanden den Wert auf dem zuweist. yVariable und leitet sie durch unverändert; so können wir die äußeren Klammern als auch durch den Wert zerren , anstatt das einklammern es beseitigen: YaBA2|1+:--a//4*2.

_{* Print und Output haben die gleiche Priorität wie Yank, sind aber hier nicht nützlich.}

Gelee , 8 7 Bytes

H^Ḃ~N⁸¡

Hierfür wird der Algorithmus aus meiner Python-Antwort verwendet , der durch @GB erheblich verbessert wurde .

Probieren Sie es online!

Wie es funktioniert

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);}

Zum ersten Mal konkurriert Java (8) tatsächlich und ist kürzer als einige andere Antworten. Trotzdem sind die aktuellen Golfsprachen wie Jelly und andere nicht zu übertreffen (duhuh .. was für eine Überraschung ..>.>; P)

0-indizierter
Port aus @Xnors Python 2-Antwort .
-10 Bytes dank @GB

Probieren Sie es hier aus.

Jelly , 15 12 11 Bytes

Ḷ^1‘ż@N€Fị@

Probieren Sie es online!

Wie es funktioniert

Ḷ^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^*}#-?

Erklärt

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)

Probieren Sie es online!

Ruby, 26 23 18 Bytes

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

0-basiert

-3 Bytes, die Greg Martin , Dennis und vielleicht jemand anderem die Idee -1 ^ n stehlen , dann -5 Bytes, die xnor die Idee n | 2 stehlen .

Gestapelt , 30 28 Bytes

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

Probieren Sie es online! Gibt eine Funktion zurück, die gemäß Metakonsens zulässig ist . . Nimmt die Eingabe vom oberen Rand des Stapels auf.

Verwenden Sie den gleichen Ansatz wie die Antwort von RProgN 2 .

Alternativ 46 Bytes. Probieren Sie es online! :

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

Dieser generiert den Bereich und wählt dann das entsprechende Mitglied aus und negiert es.

Python 2 ,  44  33 27 Bytes

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

Vielen Dank an @GB für das Abwerfen von 6 Bytes!

Probieren Sie es online!

05AB1E, 8 Bytes

2‰`^±¹F(

Probieren Sie es online aus

Erläuterung

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

Gelee , 9 8 Bytes

|2×Ḃ+H~$

Probieren Sie es online!

-1 danke an Dennis . Duh float umbauten.

Verwendet den Python 2-Ansatz von @ xnor.

BEARBEITEN : > _>

CJam , 16 Bytes

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

1-basierte Eingabe.

Probieren Sie es online!

Erläuterung

Hier ist eine Aufschlüsselung des Codes mit den Werten auf dem Stapel für jede Eingabe von 1bis 4. Die ersten paar Befehle wirken sich nur auf die zwei niedrigstwertigen Bits aus, n-1also 4wird dieses Zeug nur zyklisch wiederholt, wobei die Ergebnisse aufgrund der Halbierung um 2 erhöht werden.

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)}...*)[$_]}

(Inspiriert von der Haskell- zipWithAntwort)
Probieren Sie es aus

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

(Inspiriert von mehreren Antworten)
Probieren Sie es aus

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

Versuch es

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

Versuch es

Erweitert:

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

(Alle basieren auf 0)

Haskell , 37 36 Bytes

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

Probieren Sie es online! Dies ist eine anonyme Funktion, die eine Zahl nals Argument verwendet und das 0-indizierte nElement der Sequenz zurückgibt .

Haskell, 56 Bytes

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

0-indiziert

Perl 5 47 + 1 (für Flag) = 48 Bytes

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

Alte Vorlage 82 Bytes

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

Laufen Sie wie folgt:

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

JavaScript (ES7), 28 Byte

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

1-indiziert. Ich habe mir noch keine anderen Antworten angesehen, daher weiß ich nicht, ob dies der beste Algorithmus ist, aber ich vermute nicht.

JavaScript, 28 22 Bytes

Vielen Dank an @ETHproductions für das Golfen mit 6 Bytes

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

Probieren Sie es online!

Gleichstrom , 98 Bytes

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

Meine Güte, dies ist die längste Antwort hier, hauptsächlich, weil ich den Weg gegangen bin, den Absolutwert jedes Elements der Sequenz nacheinander auf der Grundlage der folgenden rekursiven Formel zu generieren:

dann Ausgeben (-1)^n * a_n, anstatt das n'te Element direkt zu berechnen . Wie auch immer, dies ist 1indiziert.

Probieren Sie es online!

R, 38 Bytes

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

Erläuterung

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 Byte

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

TI-Basic ist eine tokenisierte Sprache und jedes hier verwendete Token ist ein Byte, außer remainder(zwei.

Dies verwendet die 1-indizierte Version.

Erläuterung:

Es gibt ein Muster, das alle vier Zahlen wiederholt. In der 1-indizierten Version ist dies: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 für den Eingabewert x. Dies kann als stückweise definierte Funktion dargestellt werden.

f (x) = - (x + 1) / 2, wenn x ≤ 1 mod 4 ist; (x + 1) / 2, wenn x ≤ 2 mod 4 ist; - (x + 1) / 2, wenn x ≤ 3 mod 4 ist; (x-1) / 2, wenn x ≤ 0 mod 4 ist

Da die Teile "x ≡ 1 mod 4" und "x ≡ 3 mod 4" gleich sind, können wir sie zu "x ≡ 1 mod 2" kombinieren.

Nun sind stückweise folgende Funktionen möglich:

f (x) = - (x + 1) / 2, wenn x ≤ 1 mod 2 ist; (x + 2) / 2, wenn x ≤ 2 mod 4 ist; (x-2) / 2, wenn x ≤ 0 mod 4 ist

Hier beginne ich, es in tatsächliche Befehle aufzuteilen. Da der Wert für gerade Indizes positiv und für ungerade Indizes negativ ist, können wir (-1) ^ x verwenden. In TI-Basic ist i^(2X(5 Bytes) jedoch kürzer als (-1)^Ans(6 Bytes). Beachten Sie, dass Klammern aufgrund der Reihenfolge der Operationen erforderlich sind.

Nachdem wir nun die Möglichkeit haben, die ungeraden Eingänge aus dem Weg zu räumen, gehen wir zu den Mods über (und fügen die Negierung später wieder hinzu). Ich habe den Fall einer ungeraden Eingabe zur Standardeinstellung gemacht, also fangen wir mit an .5(Ans+1).

Um den Fall einer geraden Eingabe zu beheben, fügen Sie einfach eine zur Zahl in Klammern hinzu, jedoch nur, wenn x ≡ 0 mod 2 ist. Dies könnte als .5(Ans+1+remainder(Ans+1,2))oder dargestellt werden .5(Ans+1+not(remainder(Ans,2))), aber sie haben die gleiche Byteanzahl, sodass es keine Rolle spielt, welche.

Um den Fall der Eingabe eines Vielfachen von 4 zu beheben, müssen wir 3 von der Zahl in Klammern subtrahieren, aber auch eine weitere 1, da alle Vielfachen von 4 gerade sind, was eine aus unserem vorherigen Schritt hinzufügen würde .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))).

Wenden Sie sich nun bis zum Ende an den vorzeichenbestimmenden Teil, um das vollständige Programm zu erhalten.

Befunge 93, 25 Bytes

Null indexiert

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

Probieren Sie es online!

Die Nummer ist gegeben durch ((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

Erläuterung:

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.

Wise , 19 Bytes

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

Probieren Sie es online!

Dies ist nur eine Antwort von @Dennis 'Jelly an Wise.

Q, 52 Bytes

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

0 indizierte Lösung.

1. Ruft die Blocknummer ab, dh. welcher [-x x + 1 - (x + 1) x] Block innerhalb der Sequenz den Index enthält.
2. Ruft den Index des Werts innerhalb des Blocks basierend auf dem Index des Werts innerhalb der gesamten Sequenz ab.
3. Erzeugt den Block.
4. Indexiert über den in Schritt 2 abgeleiteten Index hinein.