Biorąc pod uwagę N, wypisz N-ty składnik tej nieskończonej sekwencji:

-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 może być 0-indeksowany lub 1-indeksowany, jak chcesz.

Na przykład, jeśli 0 indeksowane następnie wejść 0, 1, 2, 3, 4powinien wywoływać odpowiednie wyjścia -1, 2, -2, 1, -3.

Jeśli jeden indeksowane następnie wejść 1, 2, 3, 4, 5powinien wywoływać odpowiednie wyjścia -1, 2, -2, 1, -3.

Aby być jasnym, sekwencję tę generuje się, biorąc sekwencję dodatnich liczb całkowitych powtórzonych dwukrotnie

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

i przestawienie każdej pary liczb nieparzystych tak, aby otaczały liczby parzyste tuż nad nią

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

i wreszcie negując każdy inny termin, zaczynając od pierwszego

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

Najkrótszy kod w bajtach wygrywa.

Python 2 , 23 bajty

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

Dziwne dane wejściowe dają z grubsza n/2, nawet te z grubsza -n/2. Zacząłem więc od tego -n/2+n%2*ni poprawiałem.

Wypróbuj online!

Mathematica, 29 bajtów

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

Czysta funkcja pobierająca 1-indeksowany sygnał wejściowy. Oprócz znaków naprzemiennych podwójna (-1)^#sekwencja jest zbliżona do wejścia, przy czym różnice wynoszą 1, 2, 1, -2 cyklicznie. Fajnie, że #~GCD~4największy wspólny dzielnik wejścia i 4wynosi 1, 2, 1, 4 cyklicznie; więc po prostu ręcznie zastępujemy 4->-2i nazywamy to dniem. Podoba mi się to podejście, ponieważ pozwala uniknąć większości wieloznakowych poleceń Mathematica.

Pip , 24 22 bajty

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

Pobiera dane wejściowe, indeksowane 1, jako argument wiersza polecenia. Wypróbuj online lub sprawdź 1-20 .

Wyjaśnienie

Zauważ, że sekwencję można uzyskać, łącząc trzy inne sekwencje, jedną indeksowaną zerowo, a drugą indeksowaną:

• Zacznij od 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(indeksowane 0);
• Dodaj 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, gdzie BAjest bitowe ORAZ i |jest logiczne LUB (indeksowane 1);
• Pomnóż sumę przez -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(indeksowane 1).

Jeśli zaczniemy od a1-indeksowanego, możemy najpierw obliczyć 1-indeksowane części (czytając wyrażenie od lewej do prawej), a następnie zmniejszyć adla części 0-indeksowanej. Używając wbudowanej zmiennej v=-1, otrzymujemy

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

Aby ogolić jeszcze dwa bajty, musimy zastosować pewne sztuczki polegające na manipulowaniu priorytetami. Możemy wyeliminować wewnętrzne nawiasy, zastępując +je +:(odpowiednik +=w wielu językach). Każdy operator obliczania i przypisywania ma bardzo niski priorytet, więc aBA2|1+:--a//4*2jest równoważny z (aBA2|1)+:(--a//4*2). Pip wyśle ​​ostrzeżenie o przypisaniu do czegoś, co nie jest zmienną, ale tylko jeśli mamy włączone ostrzeżenia.

Jedyną rzeczą, która jest niższy priorytet niż :aktualnie się znajduje Y, operator Yank * Przypisuje wartość jego operand jest do. yZmiennej i przekazuje ją poprzez niezmienione; więc możemy wyeliminować zewnętrzne nawiasy, jak również przez szarpiąc wartość aniżeli parenthesizing go: YaBA2|1+:--a//4*2.

_{* Print i Output mają taki sam priorytet jak Yank, ale tutaj nie są przydatne.}

Galaretka , 8 7 bajtów

H^Ḃ~N⁸¡

Wykorzystuje algorytm z mojej odpowiedzi w Pythonie , który został znacznie ulepszony przez @GB .

Wypróbuj online!

Jak to działa

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 bajtów

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

Java 7, 47 37 bajtów

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

Pierwszy raz Java (8) faktycznie konkuruje i jest krótsza niż niektóre inne odpowiedzi. Nadal nie mogę pokonać prawdziwych języków golfowych, takich jak Jelly i podobne (duhuh .. co za niespodzianka ..>.>; P)

0-indeksowany
port z odpowiedzi @Xnor na Python 2 .
-10 bajtów dzięki @GB

Wypróbuj tutaj.

Galaretka , 15 12 11 bajtów

Ḷ^1‘ż@N€Fị@

Wypróbuj online!

Jak to działa

Ḷ^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 bajtów

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

Wyjaśnił

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)

Wypróbuj online!

Rubin, 26 23 18 bajtów

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

W oparciu o 0

-3 bajty kradnące pomysł -1 ^ n od Grega Martina , Dennisa i może kogoś innego, a następnie -5 bajty kradnące pomysł n | 2 od xnor .

Skumulowane , 30 28 bajtów

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

Wypróbuj online! Zwraca funkcję, która zgodnie z meta consensus. . Pobiera dane wejściowe z góry stosu.

Stosując to samo podejście, co odpowiedź RProgN 2 .

Alternatywnie 46 bajtów. Wypróbuj online! :

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

Ten generuje zakres, a następnie odpowiednio wybiera i neguje element członkowski.

Python 2 ,  44  33 27 bajtów

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

Dzięki @GB za grę w golfa z 6 bajtów!

Wypróbuj online!

05AB1E, 8 bajtów

2‰`^±¹F(

Wypróbuj online

Wyjaśnienie

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

Galaretka , 9 8 bajtów

|2×Ḃ+H~$

Wypróbuj online!

-1 dzięki Dennisowi . Konwersje typu float.

Wykorzystuje podejście Python 2 @ xnor.

EDYCJA : > _>

CJam , 16 bajtów

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

1 wejście.

Wypróbuj online!

Wyjaśnienie

Oto podział kodu z wartościami na stosie dla każdego wejścia od 1do 4. Kilka pierwszych poleceń wpływa tylko na dwa najmniej znaczące bity, n-1więc po 4prostu powtarzają się cyklicznie, a wyniki są zwiększane o 2, ze względu na połowę.

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 bajtów

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

(Zainspirowany zipWithodpowiedzią Haskell )
Spróbuj

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

(Zainspirowany kilkoma odpowiedziami)
Spróbuj

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

Spróbuj

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

Spróbuj

Rozszerzony:

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

(Wszystkie są oparte na 0)

Haskell , 37 36 bajtów

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

Wypróbuj online! Jest to anonimowa funkcja, która przyjmuje jedną liczbę njako argument i zwraca indeksowany jako 0 nelement th sekwencji.

Haskell, 56 bajtów

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

0-indeksowane

Perl 5 47 + 1 (dla flagi) = 48 bajtów

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

Stare zgłoszenie 82 bajtów

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

Uruchom tak:

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

JavaScript (ES7), 28 bajtów

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

1-indeksowany. Nie szukałem jeszcze żadnych odpowiedzi, więc nie wiem, czy to najlepszy algorytm, ale podejrzewam, że nie.

JavaScript, 28 22 bajtów

Dzięki @ETHproductions za grę w golfa przy 6 bajtach

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

Wypróbuj online!

dc , 98 bajtów

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

Ojej, tutaj jest najdłuższa odpowiedź, głównie dlatego, że poszedłem ścieżką generowania wartości bezwzględnej każdego elementu sekwencji jeden po drugim w oparciu o następującą rekurencyjną formułę:

następnie generowanie (-1)^n * a_n, zamiast bezpośredniego obliczanian tego elementu. W każdym razie jest to 1indeksowane.

Wypróbuj online!

R, 38 bajtów

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

Wyjaśnienie

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 bajtów

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

TI-Basic jest tokenizowanym językiem, a każdy token tutaj użyty ma jeden bajt, z wyjątkiem remainder( dwóch.

To używa wersji z 1 indeksowaniem.

Wyjaśnienie:

Istnieje wzorzec, który powtarza się co cztery cyfry. W wersji 1-indeksowanej jest to: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 dla wartości wejściowej x. Można to przedstawić jako funkcję zdefiniowaną w części.

f (x) = - (x + 1) / 2, jeżeli x ≡ 1 mod 4; (x + 1) / 2, jeśli x ≡ 2 mod 4; - (x + 1) / 2, jeżeli x ≡ 3 mod 4; (x-1) / 2, jeśli x ≡ 0 mod 4

Ponieważ części „x ≡ 1 mod 4” i „x ≡ 3 mod 4” są takie same, możemy połączyć je w „x ≡ 1 mod 2”.

Teraz są podzielone na funkcje:

f (x) = - (x + 1) / 2, jeżeli x ≡ 1 mod 2; (x + 2) / 2, jeśli x ≡ 2 mod 4; (x-2) / 2, jeśli x ≡ 0 mod 4

W tym miejscu zaczynam dzielić je na rzeczywiste polecenia. Ponieważ wartość jest dodatnia dla indeksów parzystych i ujemna dla indeksów nieparzystych, możemy użyć (-1) ^ x. Jednak w TI-Basici^(2X (5 bajtów) jest krótszy niż (-1)^Ans(6 bajtów). Pamiętaj, że nawiasy są wymagane ze względu na kolejność operacji.

Teraz, gdy mamy sposób na zanegowanie nieparzystych danych wejściowych, przechodzimy do modów (dodając negację później). Ustawiłem przypadek nieparzystego wejścia jako domyślny, więc zaczynamy od.5(Ans+1) .

Aby naprawić przypadek parzystego wprowadzania, po prostu dodaj jeden do liczby w nawiasach, ale tylko wtedy, gdy x ≡ 0 mod 2. Może to być reprezentowane jako .5(Ans+1+remainder(Ans+1,2))lub.5(Ans+1+not(remainder(Ans,2))) , ale mają taką samą liczbę bajtów, więc nie ma znaczenia, który.

Aby naprawić przypadek wejścia wielokrotnego z 4, musimy odjąć 3 od liczby w nawiasach, ale także kolejny 1, ponieważ wszystkie wielokrotności 4 są parzyste, co dodałoby jeden z naszego poprzedniego kroku, więc teraz mamy .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))) .

Teraz wystarczy przyłożyć część oznaczającą znak do końca, aby uzyskać pełny program.

Befunge 93, 25 bajtów

Zero indeksowane

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

Wypróbuj online!

Numer ten podaje ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

QBIC , 53 bajty

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

Wyjaśnienie:

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.

Mądry , 19 bajtów

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

Wypróbuj online!

To tylko część odpowiedzi Jelly @Dennis na Wise.

Q, 52 bajty

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

0 indeksowane rozwiązanie.

1. Pobiera numer bloku tj. który [-x x + 1 - (x + 1) x] blok w sekwencji zawiera indeks.
2. Pobiera indeks wartości w bloku na podstawie indeksu wartości w całej sekwencji.
3. Tworzy blok.
4. Indeksuje do niego za pomocą indeksu uzyskanego w kroku 2.