Đầu vào:

Số nguyên nlà >=0hoặc >=1( f(0)là tùy chọn)

Đầu ra:

Số nthứ 'trong dãy bên dưới, HOẶC dãy lên đến và bao gồm nsố thứ.

Sự nối tiếp:

(0),1,-1,-3,0,5,-1,-7,0,9,-1,-11,0,13,-1,-15,0,17,-1,-19,0,21,-1,-23,0,25,-1,-27,0,29,-1,-31,0,33,-1,-35,0,37,-1,-39,0,41,-1,-43,0,45,-1,-47,0,49,-1,-51,0,53,-1,-55,0,57,-1,-59,0,61,-1,-63,0,65,-1,-67,0,69,-1,-71,0,73,-1,-75,0,77,-1,-79,0,81,-1,-83,0,85,-1,-87,0,89,-1,-91,0,93,-1,-95,0,97,-1,-99

Trình tự này được xây dựng như thế nào?

f(n=0) = 0(tùy chọn)
f(n=1) = f(0) + nhoặc f(n=1) = 1
f(n=2) = f(1) - n
f(n=3) = f(2) * n
f(n=4) = f(3) / n
f(n=5) = f(4) + n
vv

Hoặc trong mã giả:

function f(integer n){
  Integer result = 0
  Integer i = 1
  Loop as long as i is smaller than or equal to n
  {
    if i modulo-4 is 1:
      result = result plus i
    if i modulo-4 is 2 instead:
      result = result minus i
    if i modulo-4 is 3 instead:
      result = result multiplied with i
    if i modulo-4 is 0 instead:
      result = result integer/floor-divided with i
    i = i plus 1
  }
  return result
}

Nhưng như bạn có thể đã lưu ý, có hai mẫu trong chuỗi:

0, ,-1,  ,0, ,-1,  ,0, ,-1,   ,0,  ,-1,   ,0,  ,-1,   ,...
 ,1,  ,-3, ,5,  ,-7, ,9,  ,-11, ,13,  ,-15, ,17,  ,-19,...

Vì vậy, bất kỳ cách tiếp cận khác dẫn đến trình tự tương tự tất nhiên là hoàn toàn tốt.

Quy tắc thử thách:

• Đầu vào 0 chỉ mục và 1 chỉ mục sẽ dẫn đến cùng một kết quả (đó là lý do tại sao f(0)tùy chọn cho đầu vào 0 chỉ mục nếu bạn muốn bao gồm nó).
• Bạn được phép xuất nsố thứ tự của chuỗi này. Hoặc toàn bộ chuỗi lên và bao gồm nsố thứ. (Vì vậy, f(5)có thể dẫn đến một trong hai 5hoặc 0,1,-1,-3,0,5.)
  • Nếu bạn chọn xuất chuỗi lên đến và bao gồm số n', định dạng đầu ra là linh hoạt. Có thể là một chuỗi phân cách danh sách / mảng, dấu phẩy / dấu cách / dòng mới hoặc được in thành STDOUT, v.v.
• Phép chia ( /) là phép chia số nguyên / sàn, làm tròn về 0 (không phải là vô cực âm như trường hợp trong một số ngôn ngữ).

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Các trường hợp kiểm tra bổ sung ở trên n=100:

Input     Output

1000      0
100000    0
123       -123
1234      -1
12345     12345
123456    0

JavaScript (ES6), 19 byte

n=>[0,n,-1,-n][n&3]

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

Bằng chứng

Giả sử rằng chúng ta có các mối quan hệ sau cho một số n bội số 4. Các mối quan hệ này được xác minh một cách tầm thường cho các điều khoản đầu tiên của chuỗi.

f(n)   = 0
f(n+1) = n+1
f(n+2) = -1
f(n+3) = -(n+3)

Và đặt N = n + 4 . Sau đó, theo định nghĩa:

f(N)   = f(n+4) = f(n+3) // (n+4) = -(n+3) // (n+4) = 0
f(N+1) = f(n+5) = f(n+4) + (n+5)  = 0 + (n+5)       = N+1
f(N+2) = f(n+6) = f(n+5) - (n+6)  = (n+5) - (n+6)   = -1
f(N+3) = f(n+7) = f(n+6) * (n+7)  = -1 * (n+7)      = -(N+3)

Trong đó, bằng cảm ứng toán học, chứng minh rằng các mối quan hệ giữ cho bất kỳ N bội số nào của 4 .

05AB1E , 8 byte

Xuất nthsố

ÎD(®s)sè

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

05AB1E , 14 byte

Xuất ra một danh sách các số lên đến N bằng cách sử dụng các mẫu trong chuỗi

ÅÉāÉ·<*āÉ<‚øí˜

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

Giải trình

Ví dụ sử dụng N = 7

ÅÉ               # List of odd numbers upto N
                 # STACK: [1,3,5,7]
  ā              # Enumerate 1-based
   É             # is odd?
                 # STACK: [1,3,5,7],[1,0,1,0]
    ·<           # double and decrement
                 # STACK: [1,3,5,7],[1,-1,1,-1]
      *          # multiply
                 # STACK: [1,-3,5,-7]
       āÉ<       # enumerate, isOdd, decrement
                 # STACK: [1,-3,5,-7],[0,-1,0,-1]
          ‚ø     # zip
                 # STACK: [[1, 0], [-3, -1], [5, 0], [-7, -1]]
            í    # reverse each
             ˜   # flatten
                 # RESULT: [0, 1, -1, -3, 0, 5, -1, -7]

Python 2 , 25 byte

Câu trả lời của cảng Arnauld:

lambda n:[0,n,-1,-n][n%4]

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

Giải pháp ngây thơ:

Python 3 , 50 49 byte

lambda n:n and eval('int(f(n-1)%sn)'%'/+-*'[n%4])

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

Python 2 , 78 77 76 58 57 53 52 byte

lambda n:n and eval('int(1.*f(n-1)%sn)'%'/+-*'[n%4])

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

Đã sử dụng một loạt các byte trên int, bởi vì sàn python phân chia, và không hướng tới 0, như trong câu hỏi.

J , 12 byte

Câu trả lời của cảng Arnauld:

4&|{0,],_1,-

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

J , 28 byte

Giải pháp ngây thơ:

{(0 _1$~]),@,.(_1^i.)*1+2*i.

Xuất ra số thứ n

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

TIS -n 2 1 , 123 byte

Xuất ra nsố thứ cho 0 <= n <= 999. (Giới hạn trên là do giới hạn ngôn ngữ).

@0
MOV UP ACC
MOV ACC ANY
L:SUB 4
JGZ L
JEZ L
ADD 5
JRO -5
@1
MOV UP ACC
JRO UP
SUB ACC
JRO 3
MOV 1 ACC
NEG
MOV ACC ANY
HCF

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

TIS -n 2 1 , 124 byte

Xuất ra nsố thứ cho 0 <= n <= 999. (Giới hạn trên là do giới hạn ngôn ngữ). Nhiều ncó thể được cung cấp, phân tách bằng khoảng trắng.

@0
MOV UP ACC
MOV ACC ANY
L:SUB 4
JGZ L
JEZ L
ADD 5
MOV ACC ANY
@1
MOV UP ACC
JRO UP
SUB ACC
JRO 3
MOV 1 ACC
NEG
MOV ACC ANY

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

TIS -n 3 1 , 192 byte

Xuất ra các giá trị 0..ncho 0 <= n <= 999. (Giới hạn trên là do giới hạn ngôn ngữ).

@0
MOV UP ACC
ADD 1
MOV ACC ANY
JRO -1
@1
SUB UP
JLZ C
HCF
C:ADD UP
MOV ACC ANY
ADD 1
SWP
ADD 1
MOV ACC ANY
SUB 4
JEZ W
ADD 4
W:SWP
@2
MOV UP ACC
JRO UP
SUB ACC
JRO 3
MOV 1 ACC
NEG
MOV ACC ANY

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

Tất cả sử dụng I / O số ( -ncờ). Hai giải pháp đầu tiên sử dụng hai nút tính toán, một nút được đặt ở trên nút kia. Thứ ba có một chồng ba nút.

Đối với hai giải pháp đầu tiên, nút trên đọc đầu vào, gửi số gốc vào, sau đó liên tục trừ 4 cho đến khi chúng tôi âm, sau đó thêm 5 vào chỉ mục cho bảng nhảy của chúng tôi. Điều này tương đương với (n % 4) + 1.

Giải pháp thứ ba phân chia nhiệm vụ này qua hai nút; nút trên cùng chỉ lặp lại giới hạn cho đến hết thời gian và nút giữa đếm song song với chỉ số (so với giới hạn đó) và modulo như trên.

Nút dưới của cả ba giải pháp là như nhau; Nó có một bàn nhảy, và đây là nơi phép màu xảy ra. Chúng tôi lưu trữ số lượng ban đầu trong ACC, sau đó JRO(có thể là J UMP R elative O ffset) về phía trước bởi 1, 2, 3, hoặc 4, tùy thuộc vào những gì các nút ở trên nói.

Làm việc lạc hậu:

• 4sẽ a ) NEGăn ACCvà b ) di chuyển ACCxuống cho đầu ra.
• 3sẽ đưa 1vào ACC, sau đó thực hiện các bước 4a và 4b .
• 2sẽ nhảy trực tiếp đến bước 4b .
• 1sẽ SUBđường ACCtắt bản thân (zeroing có hiệu quả ACC), sau đó làm bước 2, mà nhảy đến 4b .

C (gcc) , 62 byte

f(n,k){k=~-n;n=n?n%4?k%4?n-2&3?f(k)*n:f(k)-n:f(k)+n:f(k)/n:0;}

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

Thạch , 8 byte

,-;N;0⁸ị

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

-1 cảm ơn Lynn .

Những gì người khác đang làm (cổng giải pháp của Arnauld), hỗ trợ 0.

Thạch , 17 byte

A:A}××Ṡ¥
R_×ç+4ƭ/

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

0 không được hỗ trợ.

Java (JDK 10) , 25 byte

n->n%2>0?n*(2-n%4):n%4/-2

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

Ngắn hơn thuật toán đối thủ trong các ngôn ngữ khác với 28 byte

n->new int[]{0,n,-1,-n}[n%4]

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

Võng mạc , 46 byte

.+
*
r`(____)*$
_$.=
____
-
___.*
-1
__

_.*
0

Hãy thử trực tuyến! Giải trình:

.+
*

Chuyển đổi sang unary.

r`(____)*$
_$.=

Chuyển đổi trở lại thập phân, nhưng để lại n%4+1gạch chân.

____
-

Trong trường hợp đó là 4, thì kết quả là -n.

___.*
-1

Trường hợp 3: -1

__

Trường hợp 2: n

_.*
0

Trường hợp 1: 0

Haskell , 50 byte

f 0=0
f n=([(+),(-),(*),quot]!!mod(n-1)4)(f(n-1))n

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

Giải pháp của Arnauld, được chuyển đến Haskell là 23 byte:

z n=cycle[0,n,-1,-n]!!n

APL (Dyalog Classic) , 22 12 byte

10 byte khổng lồ được lưu do nhận xét của Erik the Outgolfer. Cảm ơn bạn!

4∘|⊃0,⊢,¯1,-

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

Xuất ra số thứ n

Tôi không biết APL, tôi chỉ cố gắng làm cho cổng J của giải pháp Arnauld của tôi hoạt động trong Dyalog APL.

Khối , 20 19 byte

Iun:^>s1ns:u@Ota3s0

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

Cổng cách tiếp cận tương tự với cubix.

Trên một khối lập phương:

    I u
    n :
^ > s 1 n s : u
@ O t a 3 s 0 .
    . .
    . .

Bit đầu tiên ^Iu:n>s1ns:u0sxây dựng ngăn xếp và sau đó 3atsao chép mục thích hợp vào TOS, sau đó Oxuất ra và @kết thúc chương trình.

Khoảng trắng, 84 83 byte

[S S S N
_Push_0][S N
S _Duplicate_0][T   T   S _Store][S S S T   S N
_Push_2][S S T  T   N
_Push_-1][T T   S _Store][S S S T   N
_Push_1][S N
S _Duplicate_1][T   N
T   T   _Read_STDIN_as_integer][S S S T T   N
_Push_3][S S S T    N
_Push_1][T  T   T   ][S S T T   N
_Push_-1][T S S N
_Multiply][T    T   S _Store][T T   T   _Retrieve_input][S S S T    S S N
_Push_4][T  S T T   _Modulo][T  T   T   _Retrieve_result][T N
S T _Print_as_integer]

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.
[..._some_action]chỉ thêm vào giải thích.

Dùng thử trực tuyến (chỉ có không gian thô, tab và dòng mới).

Cổng trả lời JavaScript của @Arnauld .

Giải thích (ví dụ đầu vào n=7):

Command   Explanation         Stack        Heap                  STDIN   STDOUT   STDERR

SSSN      Push 0              [0]
SNS       Duplicate top (0)   [0,0]
TTS       Store               []           {0:0}
SSSTSN    Push 2              [2]          {0:0}
SSTTN     Push -1             [2,-1]       {0:0}
TTS       Store               []           {0:0,2:-1}
SSSTN     Push 1              [1]          {0:0,2:-1}
SNS       Duplicate top (1)   [1,1]        {0:0,2:-1}
TNTT      Read STDIN as nr    [1]          {0:0,1:7,2:-1}        7
SSSTTN    Push 3              [1,3]        {0:0,1:7,2:-1}
SSSTN     Push 1              [1,3,1]      {0:0,1:7,2:-1}
TTT       Retrieve input      [1,3,7]      {0:0,1:7,2:-1}
SSTTN     Push -1             [1,3,7,-1]   {0:0,1:7,2:-1}
TSSN      Multiply (-1*7)     [1,3,-7]     {0:0,1:7,2:-1}
TTS       Store               [1]          {0:0,1:7,2:-1,3:-7}
TTT       Retrieve input      [7]          {0:0,1:7,2:-1,3:-7}
SSSTSSN   Push 4              [7,4]        {0:0,1:7,2:-1,3:-7}
TSST      Modulo (7%4)        [3]          {0:0,1:7,2:-1,3:-7}
TTT       Retrieve            [-7]         {0:0,1:7,2:-1,3:-7}
TNST      Print as integer    []           {0:0,1:7,2:-1,3:-7}           -7
                                                                                  error

Dừng với lỗi: Thoát không được xác định.