Diberikan N, menampilkan istilah ke-N dari urutan tak terbatas ini:

-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 dapat diindeks 0 atau 1 diindeks sesuai keinginan Anda.

Misalnya, jika 0-diindeks kemudian masukan 0, 1, 2, 3, 4harus menghasilkan output masing-masing -1, 2, -2, 1, -3.

Jika 1-diindeks maka input 1, 2, 3, 4, 5harus menghasilkan output masing-masing -1, 2, -2, 1, -3.

Agar jelas, urutan ini dihasilkan dengan mengambil urutan bilangan bulat positif yang diulang dua kali

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

dan mengatur ulang setiap pasangan angka ganjil untuk mengelilingi angka genap tepat di atasnya

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

dan akhirnya meniadakan setiap istilah lainnya, dimulai dengan yang pertama

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

Kode terpendek dalam byte menang.

Python 2 , 23 byte

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

Masukan ganjil memberi secara kasar n/2, bahkan yang kasar -n/2. Jadi, saya mulai dengan -n/2+n%2*ndan tweak dari sana.

Cobalah online!

Mathematica, 29 byte

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

Fungsi murni mengambil input 1-diindeks. Selain tanda-tanda bolak-balik (-1)^#, dua kali urutannya dekat dengan input, perbedaannya adalah 1, 2, 1, -2 secara siklis. Sangat menyenangkan bahwa #~GCD~4, pembagi input terbesar dan 4, adalah 1, 2, 1, 4 secara siklis; jadi kami hanya mengganti secara manual 4->-2dan menyebutnya sehari. Saya suka pendekatan ini karena ia menghindari sebagian besar perintah Mathematica banyak karakter.

Pip , 24 22 byte

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

Mengambil input, 1-diindeks, sebagai argumen baris perintah. Cobalah online atau verifikasi 1-20 .

Penjelasan

Amati bahwa urutan dapat diperoleh dengan menggabungkan tiga urutan lainnya, satu diindeks nol dan yang lain diindeks:

• Mulai dengan 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(0-diindeks);
• Tambah 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, di mana BAbitwise AND, dan |logis OR (1-diindeks);
• Lipat gandakan jumlah dengan -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(1-diindeks).

Jika kita mulai dengan a1-diindeks, kita dapat menghitung bagian-bagian yang diindeks terlebih dahulu (membaca ekspresi dari kiri ke kanan) dan kemudian mengurangi auntuk bagian yang diindeks 0. Menggunakan variabel builtin v=-1, kita dapatkan

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

Untuk mencukur dua byte lagi, kita harus menggunakan beberapa trik presedensi-manipulasi. Kami dapat menghilangkan tanda kurung bagian dalam dengan mengganti +dengan +:(setara dengan +=dalam banyak bahasa). Operator komputasi dan penugasan apa pun memiliki prioritas yang sangat rendah, sehingga aBA2|1+:--a//4*2setara dengan(aBA2|1)+:(--a//4*2) . Pip akan memancarkan peringatan tentang menetapkan sesuatu yang bukan variabel, tetapi hanya jika kita mengaktifkan peringatan.

Satu-satunya hal yang lebih diutamakan daripada :adalah Y, operator menyentak. * Ini menetapkan nilai operan ke yvariabel dan melewati itu tidak berubah; sehingga kita bisa menghilangkan tanda kurung luar juga oleh menghentak nilai daripada parenthesizing itu: YaBA2|1+:--a//4*2.

_{* Print dan Output memiliki prioritas yang sama dengan Yank, tetapi tidak berguna di sini.}

Jelly , 8 7 byte

H^Ḃ~N⁸¡

Ini menggunakan algoritma dari jawaban Python saya , yang ditingkatkan secara signifikan oleh @GB .

Cobalah online!

Bagaimana itu bekerja

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 byte

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

Java 7, 47 37 byte

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

Java pertama kali (8) benar-benar bersaing dan lebih pendek dari beberapa jawaban lainnya. Tetap tidak bisa mengalahkan bahasa golf yang sebenarnya seperti Jelly dan sejenisnya, (duhuh .. sungguh mengejutkan ..>.>; P)

Port 0-diindeks dari jawaban Python 2 @Xnor .
-10 byte berkat @GB

Coba di sini.

Jelly , 15 12 11 byte

Ḷ^1‘ż@N€Fị@

Cobalah online!

Bagaimana itu bekerja

Ḷ^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 byte

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

Dijelaskan

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)

Cobalah online!

Ruby, 26 23 18 byte

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

Berbasis 0

-3 byte mencuri ide -1 ^ n dari Greg Martin , Dennis dan mungkin orang lain, kemudian -5 byte mencuri ide n | 2 dari xnor .

Ditumpuk , 30 28 byte

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

Cobalah online! Mengembalikan fungsi, yang diizinkan per konsensus meta. . Mengambil input dari atas tumpukan.

Menggunakan pendekatan yang sama dengan jawaban RProgN 2 .

Atau, 46 byte. Cobalah online! :

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

Yang ini menghasilkan kisaran kemudian memilih dan meniadakan anggota yang sesuai.

Python 2 ,  44  33 27 byte

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

Berkat @GB untuk bermain golf 6 byte!

Cobalah online!

05AB1E, 8 byte

2‰`^±¹F(

Cobalah online

Penjelasan

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

Jelly , 9 8 byte

|2×Ḃ+H~$

Cobalah online!

-1 terima kasih kepada Dennis . Duh konversi mengambang.

Menggunakan pendekatan xnor's Python 2.

EDIT : > _>

CJam , 16 byte

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

Input berbasis 1.

Cobalah online!

Penjelasan

Berikut ini adalah rincian kode dengan nilai pada tumpukan untuk setiap input dari 1hingga 4. Beberapa perintah pertama hanya mempengaruhi dua bit paling tidak signifikan , n-1setelah itu 4, hal ini hanya berulang secara siklis, dengan hasil bertambah 2, karena separuh.

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 byte

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

(Terinspirasi oleh zipWithjawaban Haskell )
Cobalah

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

(Terinspirasi oleh beberapa jawaban)
Cobalah

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

Cobalah

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

Cobalah

Diperluas:

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

(Semua berbasis 0)

Haskell , 37 36 byte

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

Cobalah online! Ini adalah fungsi anonim yang mengambil satu angka nsebagai argumen dan mengembalikan 0-diindeks nelemen th urutan.

Haskell, 56 byte

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

Diindeks 0

Perl 5 47 + 1 (untuk bendera) = 48 Bytes

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

Pengiriman Lama 82 Bytes

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

Jalankan seperti itu:

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

JavaScript (ES7), 28 byte

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

1-diindeks. Saya belum melihat jawaban lain jadi saya tidak tahu apakah ini adalah algoritma terbaik, tapi saya kira tidak.

JavaScript, 28 22 byte

Terima kasih @ETHproduk untuk bermain golf 6 byte

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

Cobalah online!

dc , 98 byte

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

Astaga, ini adalah jawaban terlama di sini, terutama karena saya menempuh jalur untuk menghasilkan nilai absolut dari setiap elemen dari urutan satu per satu berdasarkan pada rumus rekursif berikut:

kemudian menghasilkan (-1)^n * a_n, daripada langsung menghitung nelemen 'th. Bagaimanapun, ini 1-indeks.

Cobalah online!

R, 38 byte

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

Penjelasan

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 adalah bahasa tokenized dan masing-masing token yang digunakan di sini adalah satu byte, kecuali remainder(, yang dua.

Ini menggunakan versi 1-diindeks.

Penjelasan:

Ada pola yang berulang setiap empat angka. Dalam versi 1-diindeks, itu adalah: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 untuk nilai input x. Ini dapat direpresentasikan sebagai fungsi yang didefinisikan secara terpisah.

f (x) = - (x + 1) / 2 jika x ≡ 1 mod 4; (x + 1) / 2 jika x ≡ 2 mod 4; - (x + 1) / 2 jika x ≡ 3 mod 4; (x-1) / 2 jika x ≡ 0 mod 4

Karena bagian "x ≡ 1 mod 4" dan "x ≡ 3 mod 4" sama, kita dapat menggabungkannya menjadi "x ≡ 1 mod 2".

Sekarang fungsi piecewise adalah:

f (x) = - (x + 1) / 2 jika x ≡ 1 mod 2; (x + 2) / 2 jika x ≡ 2 mod 4; (x-2) / 2 jika x ≡ 0 mod 4

Di sinilah saya mulai memecahnya menjadi perintah yang sebenarnya. Karena nilainya positif untuk indeks genap dan negatif untuk indeks ganjil, kita dapat menggunakan (-1) ^ x. Namun, dalam TI-Basic i^(2X(5 byte) lebih pendek dari(-1)^Ans (6 byte). Perhatikan bahwa tanda kurung diperlukan karena urutan operasi.

Sekarang kita memiliki cara untuk meniadakan input aneh keluar dari jalan, kita beralih ke mod (menambahkan negating kembali nanti). Saya membuat case dari input aneh sebagai default, jadi kita mulai dengan .5(Ans+1).

Untuk memperbaiki kasus input genap, cukup tambahkan satu ke nomor di dalam tanda kurung, tetapi hanya ketika x ≡ 0 mod 2. Ini dapat direpresentasikan sebagai .5(Ans+1+remainder(Ans+1,2))atau .5(Ans+1+not(remainder(Ans,2))), tetapi mereka memiliki jumlah byte yang sama, sehingga tidak masalah yang mana.

Untuk memperbaiki kasus multiple-of-4 input, kita perlu mengurangi 3 dari angka di dalam tanda kurung, tetapi juga 1 karena semua kelipatan dari 4 genap, yang akan menambah satu dari langkah kita sebelumnya, jadi sekarang kita miliki .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))).

Sekarang, cukup tempelkan pada bagian penentu tanda sampai akhir untuk mendapatkan program lengkap.

Melewati 93, 25 byte

Diindeks nol

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

Cobalah secara Online!

Nomornya diberikan oleh ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

QBIC , 53 byte

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

Penjelasan:

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.

Bijaksana , 19 byte

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

Cobalah secara Online!

Ini hanyalah port jawaban Jelly @Dennis untuk Wise.

Q, 52 byte

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

0 solusi terindeks.

1. Mendapat nomor blok yaitu. yang [-x x + 1 - (x + 1) x] blok dalam urutan berisi indeks.
2. Mendapat indeks nilai di dalam blok berdasarkan indeks nilai dalam seluruh urutan.
3. Membuat blok.
4. Indeks ke dalamnya melalui indeks yang diperoleh pada langkah 2.