Cho N, xuất ra số hạng thứ N của chuỗi vô hạn này:

-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 có thể là 0 chỉ mục hoặc 1 chỉ mục như bạn muốn.

Ví dụ, nếu 0-lập chỉ mục sau đó đầu vào 0, 1, 2, 3, 4nên sản xuất đầu ra tương ứng -1, 2, -2, 1, -3.

Nếu 1-lập chỉ mục sau đó đầu vào 1, 2, 3, 4, 5nên sản xuất đầu ra tương ứng -1, 2, -2, 1, -3.

Để rõ ràng, chuỗi này được tạo bằng cách lấy chuỗi các số nguyên dương được lặp lại hai lần

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

và sắp xếp lại từng cặp số lẻ để bao quanh các số chẵn ngay phía trên nó

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

và cuối cùng phủ nhận mọi thuật ngữ khác, bắt đầu với từ đầu tiên

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

Mã ngắn nhất tính bằng byte thắng.

Python 2 , 23 byte

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

Đầu vào lẻ ​​cho khoảng n/2, thậm chí những đầu vào đại khái -n/2. Vì vậy, tôi bắt đầu với -n/2+n%2*nvà điều chỉnh từ đó.

Hãy thử trực tuyến!

Toán học, 29 byte

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

Hàm thuần túy lấy đầu vào 1 chỉ mục. Khác với các dấu hiệu xen kẽ (-1)^#, hai lần chuỗi gần với đầu vào, sự khác biệt là 1, 2, 1, -2 theo chu kỳ. Thật tuyệt khi #~GCD~4, ước số chung lớn nhất của đầu vào và 4, là 1, 2, 1, 4 theo chu kỳ; Vì vậy, chúng tôi chỉ cần thay thế bằng tay 4->-2và gọi nó là một ngày. Tôi thích cách tiếp cận này vì nó tránh được hầu hết các lệnh Mathicala nhiều ký tự.

Pip , 24 22 byte

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

Lấy đầu vào, 1 chỉ mục, làm đối số dòng lệnh. Hãy thử trực tuyến hoặc xác minh 1-20 .

Giải trình

Quan sát rằng chuỗi có thể thu được bằng cách kết hợp ba chuỗi khác, một chuỗi không được lập chỉ mục và các chuỗi khác được lập chỉ mục:

• Bắt đầu bằng 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(0 chỉ mục);
• Thêm 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, trong đó BAbitwise AND và |logic OR (được lập chỉ mục 1);
• Nhân tổng số với -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(1 chỉ mục).

Nếu chúng ta bắt đầu với a1 chỉ mục, chúng ta có thể tính toán các phần được lập chỉ mục 1 trước (đọc biểu thức từ trái sang phải) và sau đó giảm acho phần 0 được lập chỉ mục. Sử dụng biến dựng sẵn v=-1, chúng tôi nhận được

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

Để cạo thêm hai byte, chúng ta phải sử dụng một số thủ thuật thao tác ưu tiên. Chúng ta có thể loại bỏ các dấu ngoặc đơn bên trong bằng cách thay thế +bằng +:(tương đương với +=rất nhiều ngôn ngữ). Bất kỳ toán tử tính toán và gán nào đều có độ ưu tiên rất thấp, do đó aBA2|1+:--a//4*2tương đương với (aBA2|1)+:(--a//4*2). Pip sẽ phát ra một cảnh báo về việc gán cho thứ gì đó không phải là biến, nhưng chỉ khi chúng tôi bật cảnh báo.

Điều duy nhất có độ ưu tiên thấp hơn :là Ytoán tử yank. * Nó gán giá trị toán hạng của nó cho ybiến và chuyển nó qua không thay đổi; vì vậy chúng ta có thể loại bỏ các dấu ngoặc đơn bên ngoài bằng cách kéo theo giá trị thay vì dấu ngoặc đơn : YaBA2|1+:--a//4*2.

_{* Print và Output có cùng mức độ ưu tiên như mắt cá chân Y, nhưng không hữu ích ở đây.}

Thạch , 8 7 byte

H^Ḃ~N⁸¡

Điều này sử dụng thuật toán từ câu trả lời Python của tôi , được cải thiện đáng kể bởi @GB .

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Lần đầu tiên Java (8) thực sự cạnh tranh và ngắn hơn một số câu trả lời khác. Tuy nhiên, vẫn không thể đánh bại các ngôn ngữ chơi gôn thực tế như Jelly và như nhau (duhuh .. thật là bất ngờ ..>.>; P)

Cổng 0 chỉ mục từ câu trả lời Python 2 của @Xnor .
-10 byte nhờ @GB

Hãy thử nó ở đây.

Thạch , 15 12 11 byte

Ḷ^1‘ż@N€Fị@

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Giải thích

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)

Hãy thử trực tuyến!

Ruby, 26 23 18 byte

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

Dựa trên 0

-3 byte đánh cắp ý tưởng -1 ^ n từ Greg Martin , Dennis và có thể là ai đó, sau đó -5 byte đánh cắp ý tưởng n | 2 từ xnor .

Xếp chồng lên nhau , 30 28 byte

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

Hãy thử trực tuyến! Trả về một hàm, được cho phép theo sự đồng thuận meta. . Lấy đầu vào từ đầu ngăn xếp.

Sử dụng phương pháp tương tự như câu trả lời RProgN 2 .

Ngoài ra, 46 byte. Hãy thử trực tuyến! :

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

Điều này tạo ra phạm vi sau đó chọn và phủ nhận thành viên khi thích hợp.

Python 2 ,  44  33 27 byte

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

Cảm ơn @GB vì đã chơi golf 6 byte!

Hãy thử trực tuyến!

05AB1E, 8 byte

2‰`^±¹F(

Dùng thử trực tuyến

Giải trình

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

Thạch , 9 8 byte

|2×Ḃ+H~$

Hãy thử trực tuyến!

-1 cảm ơn Dennis . Duh chuyển đổi phao.

Sử dụng phương pháp tiếp cận Python 2 của @ xnor.

CHỈNH SỬA : > _>

CJam , 16 byte

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

Đầu vào 1 dựa.

Hãy thử trực tuyến!

Giải trình

Dưới đây là bảng phân tích mã với các giá trị trên ngăn xếp cho mỗi đầu vào từ 1đến 4. Một vài lệnh đầu tiên chỉ ảnh hưởng đến hai bit có ý nghĩa nhỏ nhất n-1sau đó 4, công cụ này chỉ lặp lại theo chu kỳ, với kết quả tăng thêm 2, do giảm một nửa.

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

(Lấy cảm hứng từ zipWithcâu trả lời của Haskell )
Hãy thử nó

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

(Lấy cảm hứng từ một số câu trả lời)
Hãy thử nó

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

Thử nó

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

Thử nó

Mở rộng:

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

(Tất cả đều dựa trên 0)

Haskell , 37 36 byte

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

Hãy thử trực tuyến! Đây là một hàm ẩn danh lấy một số nlàm đối số và trả về 0 được lập chỉ mục cho nphần tử thứ của chuỗi.

Haskell, 56 byte

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

Chỉ số 0

Perl 5 47 + 1 (đối với cờ) = 48 byte

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

Đệ trình cũ 82 byte

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

Chạy như vậy:

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

JavaScript (ES7), 28 byte

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

1 chỉ mục. Tôi chưa xem xét bất kỳ câu trả lời nào khác vì vậy tôi không biết liệu đây có phải là thuật toán tốt nhất không, nhưng tôi nghi ngờ là không.

JavaScript, 28 22 byte

Cảm ơn @ETHproductions đã chơi golf 6 byte

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

Hãy thử trực tuyến!

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

Trời ạ, đây là câu trả lời dài nhất ở đây, chủ yếu là vì tôi đã đi theo con đường tạo ra giá trị tuyệt đối của từng phần tử của từng phần một dựa trên công thức đệ quy sau:

sau đó xuất ra (-1)^n * a_n, thay vì trực tiếp tính toán nphần tử thứ. Dù sao, điều này là 1-exexed.

Hãy thử trực tuyến!

R, 38 byte

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

Giải trình

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 là ngôn ngữ được mã hóa và mỗi mã thông báo được sử dụng ở đây là một byte, ngoại trừ remainder(, là hai.

Điều này sử dụng phiên bản 1 chỉ mục.

Giải trình:

Có một mô hình lặp lại cứ sau bốn số. Trong phiên bản 1 chỉ mục, đó là: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 cho giá trị đầu vào x. Điều này có thể được biểu diễn dưới dạng hàm xác định từng phần.

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

Vì các phần "x ≡ 1 mod 4" và "x ≡ 3 mod 4" giống nhau, chúng ta có thể kết hợp chúng thành "x ≡ 1 mod 2".

Bây giờ chức năng piecewise là:

f (x) = - (x + 1) / 2 nếu x ≡ 1 mod 2; (x + 2) / 2 nếu x ≡ 2 mod 4; (x-2) / 2 nếu x ≡ 0 mod 4

Đây là nơi tôi bắt đầu chia nó thành các lệnh thực tế. Vì giá trị là dương đối với các chỉ số chẵn và âm đối với các số lẻ, nên chúng ta có thể sử dụng (-1) ^ x. Tuy nhiên, trong TI-Basic i^(2X(5 byte) ngắn hơn(-1)^Ans (6 byte). Lưu ý rằng dấu ngoặc đơn là bắt buộc do thứ tự của các hoạt động.

Bây giờ chúng ta có cách để loại bỏ các đầu vào lẻ ​​ra khỏi đường đi, chúng ta chuyển sang các mod (thêm phần phủ định trở lại sau). Tôi đã làm cho trường hợp của một đầu vào lẻ ​​là mặc định, vì vậy chúng tôi bắt đầu với .5(Ans+1).

Để khắc phục trường hợp nhập chẵn, chỉ cần thêm một vào số trong ngoặc đơn, nhưng chỉ khi x ≡ 0 mod 2. Điều này có thể được biểu diễn dưới dạng .5(Ans+1+remainder(Ans+1,2))hoặc .5(Ans+1+not(remainder(Ans,2))), nhưng chúng có cùng số byte, vì vậy nó không thành vấn đề.

Để khắc phục trường hợp đầu vào nhiều 4, chúng ta cần trừ 3 từ số trong ngoặc đơn, nhưng cũng là 1 vì tất cả bội số của 4 đều chẵn, sẽ thêm một từ bước trước, vì vậy chúng ta hiện có .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))).

Bây giờ, chỉ cần giải quyết phần xác định dấu hiệu cho đến hết để có được chương trình đầy đủ.

Befunge 93, 25 byte

Không có chỉ mục

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

Hãy thử trực tuyến!

Số được đưa ra bởi ((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

Giải trình:

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.

Khôn ngoan , 19 byte

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

Hãy thử trực tuyến!

Đây chỉ là một cổng của câu trả lời @Dennis 'Jelly cho Wise.

Q, 52 byte

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

Giải pháp lập chỉ mục 0.

1. Lấy số khối tức là. khối [-x x + 1 - (x + 1) x] trong chuỗi chứa chỉ mục.
2. Lấy chỉ số của giá trị trong khối dựa trên chỉ số của giá trị trong toàn bộ chuỗi.
3. Tạo khối.
4. Lập chỉ mục vào nó thông qua chỉ mục xuất phát ở bước 2.