Thử thách:

Cho đầu vào số nguyên dương n , tạo một vectơ theo mẫu này:

0  1  0 -1 -2 -1  0  1  2  3  2  1  0 -1 -2 -3 -4 -3 -2 -1 ... ±(n-1) ±n

Hoặc, được giải thích bằng các từ: Vectơ bắt đầu 0và tăng dần 1cho đến khi nó đạt đến số nguyên dương lẻ nhỏ nhất không phải là một phần của chuỗi, sau đó nó sẽ giảm cho đến khi nó đạt đến số nguyên âm nhỏ nhất (về độ lớn) 't một phần của trình tự. Nó tiếp tục theo cách này cho đến khi nđạt được. Chuỗi sẽ kết thúc trên dương nnếu nlà số lẻ và âm nnếu nlà số chẵn.

Các định dạng đầu ra là linh hoạt.

Các trường hợp thử nghiệm:

n = 1
0  1
-----------
n = 2
0  1  0 -1 -2
-----------
n = 3
0  1  0 -1 -2 -1  0  1  2  3
-----------
n = 4
0  1  0 -1 -2 -1  0  1  2  3  2  1  0 -1 -2 -3 -4
-----------
n = 5
0  1  0 -1 -2 -1  0  1  2  3  2  1  0 -1 -2 -3 -4 -3 -2 -1  0  1  2  3  4  5

Bạn có thể chọn lấy n zero-indexed. n = 1sau đó sẽ cung cấp cho 0 1 0 -1 -2.

Đây là môn đánh gôn , vì vậy mã ngắn nhất trong mỗi ngôn ngữ sẽ thắng! Giải thích được khuyến khích như mọi khi!

R , 58 54 50 48 43 byte

-2 byte nhờ MickyT

function(n)diffinv(rep(1:n%%2*2-1,1:n*2-1))

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

function(n)
 diffinv(                           # take cumulative sum, starting at 0 of
             1:n%%2*2-1,            # a vector of alternating 1,-1
         rep(                       # repeated
                        1:n*2-1))   # 1, 3, 5, etc. times

Perl 6 ,  60  26 byte

{flat {((1,-*...*)ZX*(-$++...0...$++)xx$_)}(),$_*($_%2||-1)}

Thử nó

{[...] (-1,-*...*)Z*0..$_}

Thử nó

Mở rộng:

{  # bare block lambda with implicit parameter $_

  [...]  # reduce using &infix:«...» (sequence generator)

          ( -1, -* ... * ) # (-1, 1, -1, 1 ... *)

      Z*                   # zip multiplied with

          0 .. $_          # range up to and including input
}

(-1,-*...*)Z*0..$_ tạo ra chuỗi 0 1 -2 3 -4 5

Python 2 , 69 57 56 byte

f=lambda n:[0][n:]or f(n-1)+range(-n,n+1)[::n%2*2-1][2:]

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

Đối với mỗi n thiết lập của inputcác range(-n,n)(bao gồm) được tính toán, đảo ngược khi nlà một số chẵn, có nắm tay hai con số (sau khi đảo ngược) loại bỏ, và sau đó nối vào đầu ra.

05AB1E , 9 7 byte

Đã lưu 2 byte nhờ @Emigna

Ýā®sm*Ÿ

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

Câu trả lời 05AB1E đầu tiên của tôi (tôi nghĩ), vì vậy tôi có thể thiếu một số thủ thuật ...

Giải trình

Ý         # push range [0 ... n]   stack: [[0 ... n]]
 ā        # push range [1 ... len(prev)]  [[0 ... n], [1 ... n+1]]
  ®       # push value of register        [[0 ... n], [1 ... n+1], -1]
   s      # swap top two values           [[0 ... n], -1, [1 ... n+1]]
    m     # power                         [[0 ... n], [-1, 1, -1, 1, ...]]
     *    # multiply                      [[0, 1, -2, 3, -4, 5, ...]]
      Ÿ   # range interpolation           [[0, 1, 0, -1, -2, -1, ...]]

Tôi phải cảm ơn @Dennis vì cách sử dụng ban đầuŸ , nếu không tôi có lẽ sẽ không bao giờ biết về nó ...

05AB1E , 15 14 byte

ÝDÉ·<*Ý€û˜ÔsF¨

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

Giải trình

Ý                # push range [0 ... n]
 D               # duplicate
  É·<            # (x % 2 == 1)*2-1 for each
     *           # multiply
      Ý          # range [0 ... a] for each
       €û        # palendromize each
         ˜       # flatten
          Ô      # connected uniqueified
           sF¨   # remove the last n elements

JavaScript (ES6), 56 byte

f=(n,b=d=1,k=0)=>[k,...k-d*n?f(n,k-b?b:(d=-d)-b,k+d):[]]

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

Đã bình luận

f = (               // f = recursive function taking:
  n,                //   n = input
  b =               //   b = boundary value, initialized to 1
  d = 1,            //   d = current direction, initialized to 1
  k = 0             //   k = current sequence value, initialized to 0
) =>                //
  [                 // update the sequence:
    k,              //   append the current value
    ...k - d * n ?  //   if |k| is not equal to |n|:
      f(            //     append the (spread) result of a recursive call:
        n,          //       use the original input
        k - b ?     //       if k has not reached the boundary value:
          b         //         leave b unchanged
        :           //       else:
          (d = -d)  //         reverse the direction
          - b,      //         and use a boundary of higher amplitude and opposite sign
        k + d       //       update k
      )             //     end of recursive call
    :               //   else:
      []            //     stop recursion and append nothing
  ]                 // end of sequence update

Haskell , 43 byte

f n=scanl(-)0[(-1)^k|k<-[1..n],_<-[2..2*k]]

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

Tính tổng các khoản tích lũy phủ định của danh sách [(-1)^k|k<-[1..n],_<-[2..2*k]], là nhàng đầu tiên của

[-1,
 +1, +1, +1,
 -1, -1, -1, -1, -1,
 +1, +1, +1, +1, +1, +1, +1…

Thạch , 11 9 byte

²Ḷƽ-*0;Ä

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

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

²Ḷƽ-*0;Ä  Main link. Argument: n

²          Square; yield n².
 Ḷ         Unlength; yield [0, ..., n²-1].
  ƽ       Take the integer square root of each k in the range.
    -*     Compute (-1)**r for each integer square root r.
      0;   Prepend a zero.
        Ä  Accumulate; take the sums of all prefixes.

Haskell , 48 42 byte

f n=0:[(-1)^i*x|i<-[0..n-1],x<-[1-i..i+1]]

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

Cảm ơn urous cho -1 byte

Mặc dù nó là loại rõ ràng trong nhận thức muộn màng, nó đã cho tôi một thời gian để đi đến (-1)^i*xđó là xkhi ithậm chí còn và -xkhi ilà số lẻ. Lặp lại trước đó trong đó:

(-1)^i*x
x-2*mod i 2*x
(-1)^mod i 2*x
[x,-x]!!mod i 2
(1-sum[2|odd i])*x

C # (.NET Core) , 300  167 byte

Tôi chưa bao giờ thực hiện bất kỳ điều nào trong số này trước đây, nhưng điều này có vẻ vui. Tôi thấy lý do tại sao mọi người sử dụng các ngôn ngữ "chơi gôn" như 167 dường như cao hơn so với một số câu trả lời khác. Nhưng, bạn phải đi với những gì bạn biết.

static int[] f(int n){if (n==1) return new int[]{0,1};var a=f(n-1);return a.Concat(a.Skip(a.Length-(n-1)*2).Select(x=>-x)).Concat(new int[]{(n%2)!=0?n:-n}).ToArray();}

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

// Recursive Worker Function
static public int[] f( int n )
{
    // Start with the simple case
    if ( n == 1 ) return new int[]{0,1};

    // Recusively build off of that
    var a = f(n-1);

    // To be added at the end
    int[] b = { (n%2) !=0 ? n : -n };

    // Skip some based on length
    int s = a.Length - (n-1)*2;

    // With the rest, multiply by -1 and then append to the end
    // And append the part
    return a.Concat( a.Skip(s).Select( x => -x ) ).Concat( b ).ToArray();
}

J , 25 byte

-5 byte nhờ FrownyFrog!

>:@*:$i.;@(<@i:@*_1&^)@,]

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

J , 30 byte

>:@*:{.;@([:(i:@*_1&^)&.>i.,])

Giải trình:

i.,] tạo danh sách 0..n

&.> cho mỗi số trong danh sách thực hiện động từ trong (...) và đóng hộp kết quả (tôi cần quyền anh vì kết quả có độ dài khác nhau)

[:( _1&^)tìm -1 cho isức mạnh thứ (-1 hoặc 1)

i:@* lập danh sách -n..n hoặc n ..- n, tùy thuộc vào dấu hiệu ở trên

;@ bỏ hộp

>:@*: tìm n ^ 2 + 1

}. và lấy rất nhiều số từ danh sách

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

Python 2 , 65 56 byte

r=k=0;exec'print r;r+=1-k**.5//1%2*2;k+=1;'*-~input()**2

Các định dạng đầu ra là một chút xấu xí. : /

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

Java 8, 85 83 79 byte

n->{for(int p=0,i=0;i<=n*n;p+=1-(int)Math.sqrt(i++)%2*2)System.out.println(p);}

-6 byte nhờ @ OlivierGrégoire .

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

Giải trình:

n->{                            // Method with integer parameter and no return-type
  for(int p=0,                  //  Set both `p` to 0
      i=0;i<=n*n;               //  Loop `i` in the range [0, `n*n`]
      p+=                       //    After every iteration, increase `p` by:
         1-                     //     1, minus:
           (int)Math.sqrt(i++)  //     The square-root of `i`, truncated to its integer
           %2*2)                //     Modulo 2, and multiplied by 2
     System.out.println(p);}    //   Print integer `p` with a trailing new-line

R , 48 46 42 byte

for(i in 1:scan())F=c(F,-(-1)^i*(2-i):i);F

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

Một cảng của câu trả lời Ruby của Kirill L. - và đã lưu 6 byte nhờ cùng Kirill L.! Bây giờ ngắn hơn giải pháp của Giuseppe ;)

Một cổng của câu trả lời Octave này do Luis Mendo sử dụng approxlà ít chơi gôn hơn.n=n^2+1có thể được thay thế bởi ,,n^2+1; hoặc bởi 0:n^2+1(đối số vị trí xout) cho cùng một số byte:

R , 56 byte

f=function(n)approx((0:n)^2+1,-(-1)^(0:n)*0:n,n=n^2+1)$y

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

APL (Dyalog Unicode) , 17 byte

+\0,¯1*⍳(/⍨)1+2×⍳

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

Chơi gôn 2 byte nhờ @FrownyFrog bằng cách chuyển đổi thành tàu. Xem câu trả lời cũ hơn và giải thích của nó dưới đây.

APL (Dyalog Unicode) , 19 byte

+\0,∊⊢∘-\⍴∘1¨1+2×⍳⎕

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

(Công dụng ⎕IO←0 )

Cách tiếp cận đầu tiên của tôi là xây dựng nhiều phạm vi và ghép chúng lại với nhau, điều này dễ dàng vượt quá 30 byte. Sau đó tôi bắt đầu phân tích trình tự

      +\⍣¯1⊢0  1  0 ¯1 ¯2 ¯1  0  1  2  3  2  1  0 ¯1 ¯2 ¯3 ¯4
0 1 ¯1 ¯1 ¯1 1 1 1 1 1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1

^{+\⍣¯1 biểu thị tổng tích lũy nghịch đảo}

Có một mẫu lặp lại là 1s và ¯1s, trong đó độ dài của mỗi chuỗi liên tiếp 1s hoặc ¯1s là 1 + 2 × n. Và mỗi lần sau xen kẽ giữa 1 và ¯1. Những gì tôi có thể làm bây giờ là tạo danh sách 1 và 1, sau đó quét theo +

      ⍳4 ⍝ creates range 0..4
0 1 2 3
      2×⍳4
0 2 4 6
      1+2×⍳4
1 3 5 7
      ⍴∘1¨1+2×⍳4 ⍝ for-each create that many 1s
┌─┬─────┬─────────┬─────────────┐
│1│1 1 1│1 1 1 1 1│1 1 1 1 1 1 1│
└─┴─────┴─────────┴─────────────┘
      ⊢∘-\⍴∘1¨1+2×⍳4 ⍝ alternate signs
┌─┬────────┬─────────┬────────────────────┐
│1│¯1 ¯1 ¯1│1 1 1 1 1│¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1│
└─┴────────┴─────────┴────────────────────┘
      ∊⊢∘-\⍴∘1¨1+2×⍳4 ⍝ flatten
1 ¯1 ¯1 ¯1 1 1 1 1 1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1
      0,∊⊢∘-\⍴∘1¨1+2×⍳4
0 1 ¯1 ¯1 ¯1 1 1 1 1 1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1
      +\0,∊⊢∘-\⍴∘1¨1+2×⍳4 ⍝ cumulative sum
0 1 0 ¯1 ¯2 ¯1 0 1 2 3 2 1 0 ¯1 ¯2 ¯3 ¯4

Haskell , 47 byte

(#0)
m#n|m>n=[-n..n]++map(0-)(m#(n+1))|1>0=[-m]

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

Java (JDK 10) , 98 byte

n->{var s="0";for(int i=0,r=0,d=1;i++<n;s+=" "+r,d=-d)for(r+=d;r!=i&r!=-i;r+=d)s+=" "+r;return s;}

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

MATL , 17 15 byte

-2 byte nhờ Luis Mendo!

0i:oEqG:EqY"Ysh

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

Giải thích cho n=3:

0		% push 0
 i:		% read input as integer, push range
		% stack: [0, [1 2 3]]
   o		% modulo 2, stack: [0, [1 0 1]]
    Eq		% double and decrement, stack: [0, [1 -1 1]]
      G:	% push input and range again
		% stack: [0, [1 -1 1], [1 2 3]]
        Eq	% double and decrement,
		% stack: [0, [1 -1 1], [1 3 5]]
	  Y"	% run-length decoding
		% stack: [0, [1 -1 -1 -1 1 1 1 1 1]]
	    Ys	% cumulative sum
		% stack: [0, [1  0 -1 -2 -1  0  1  2  3]]
	      h	% horizontally concatenate
		% end of program, automatically print the stack

Octave , 44 42 41 byte

2 byte bị xóa nhờ @StewieGriffin và 1 byte bị xóa thêm nhờ @Giuseppe!

@(n)interp1((t=0:n).^2,-t.*(-1).^t,0:n^2)

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

Ruby , 52 47 byte

f=->n{n<1?[0]:f[n-1]+(2-n..n).map{|x|-~0**n*x}}

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

Dưới đây là phiên bản 52 byte gốc với lời giải thích:

f=->n{n<1?[0]:f[n-1]+[(r=*2-n..n).map(&:-@),r][n%2]}

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

Hướng dẫn

f=->n{           #Recursive approach
 n<1?[0]         #Init with 0 if n=0
 :f[n-1]         #else make a recursive call
 +               #and append an array of numbers
 [(r=*2-n..n)    #Init r as splatted range from 2-n to n
 .map(&:-@)      #"-@" is unary minus, so this a fancy way to do map{|x|-x} for -1 byte
                 #For even n use this negated r, e.g. for n=4: [2, 1, 0, -1, -2, -3, -4]
 ,r]             #For odd n use r directly, e.g. for n=3: [-1, 0, 1, 2, 3]
 [n%2]           #Odd/even selector
}

Prolog (SWI) , 113 byte

0-I-[0|I].
N-[H|T]-R:-N is -H*(-1)^N,A is N-1,A-[H|T]-R;I is H-(-1)^N,N-[I|[H|T]]-R.
N-O:-X is -N*(-1)^N,N-[X]-O.

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

Python 3, 83 byte

def c(n):print([(-1)**j*(abs(j-i)-j)for j in range(n+1)for i in range(2*j)][:-n+1])

Trấu , 18 17 byte

:ṁoṡ₁ŀ⁰_₁⁰
*^⁰_1⁰

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

Than , 19 byte

Ｆ⊕ＮＩ×∨﹪ι²±¹…·∧ι⁻²ιι

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

  Ｎ                 Input as a number
 ⊕                  Increment
Ｆ                   Loop over implicit range
                ²   Literal 2
                 ι  Current index
               ⁻    Subtract
              ι     Current index
             ∧      Logical And
                  ι Current index
           …·       Inclusive range
       ι            Current index
        ²           Literal 2
      ﹪             Modulo
          ¹         Literal 1
         ±          Negate
     ∨              Logical Or
    ×               Multiply
   Ｉ                Cast to string and implicitly print

Giải thích thay thế:

Ｆ⊕Ｎ

Lặp lại các số nguyên từ 0bao gồm đầu vào.

Ｉ

Truyền kết quả vào chuỗi trước khi in.

×∨﹪ι²±¹

Phủ định thay thế các bộ kết quả.

…·∧ι⁻²ιι

Tạo một danh sách từ chỉ mục trước đến chỉ mục hiện tại, ngoại trừ chỉ mục trước đó.

Thạch ,  11  12 byte

^{Bah, tôi nghĩ rằng tôi có 11 wih _2+ỊrN)N;¥/}

_2+ỊrN×-*$)Ẏ

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

Làm sao?

_2+ỊrN×-*$)Ẏ - Main Link: n           e.g. 4
          )  - for x in [1...n]:           1       2          3               4
_2           -   subtract 2 from x        -1       0          1               2
   Ị         -   is x insignificant?       1       0          0               0
  +          -   add                       0       0          1               2
     N       -   negate x                 -1      -2         -3              -4
    r        -   inclusive range          [0,-1]  [0,-1,-2]  [1,0,-1,-2,-3]  [2,1,0,-1,-2,-3,-4]
         $   -   last two links as a monad:
       -     -     minus one              -1      -1         -1              -1
        *    -     raised to the power x  -1       1         -1               1
      ×      -   multiply                 [0,1]   [0,-1,-2]  [-1,0,1,2,3]    [2,1,0,-1,-2,-3,-4]
           Ẏ - tighten                    [0,1,0,-1,-2,-1,0,1,2,3,2,1,0,-1,-2,-3,-4]

Stax , 10 byte

╗)SΘ█☼₧ΘP(

Chạy và gỡ lỗi nó

Scala, 119 byte

def a(n: Int)={lazy val s:Stream[Int]=0#::Stream.from(0).map{x=>s(x)+1 -2*(Math.sqrt(x).toInt%2)}
s.take(n*n+1).toList}

Ung dung:

def a(n: Int)={
  lazy val s:Stream[Int]= 0#::Stream.from(0).map //Give the starting point and indexing scheme
  {
    x=>
    {
      val sign = 1-2*(Math.sqrt(x).toInt%2) //Determine whether we are adding or subtracting at the current index
      s(x)+sign
    }
  }
  s.take(n*n+1).toList //Take the desired values
}

Điều này có thể có thể được chơi golf tốt hơn nhiều, nhưng tôi muốn một giải pháp sử dụng Stream lười biếng.

APL (Dyalog Unicode) , 34 32 byte

⎕CY'dfns'⋄-0,∘∊1↓¨2to/Sׯ1*S←⍳,⊢

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

Đòi hỏi ⎕IO←0

-2 byte nhờ @FrownyFrog

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

[~>0\:2%\#,2*1-tr[...rep]flatmap,$sumonpref]

Hãy thử trực tuyến! Đã được một thời gian kể từ khi tôi lập trình trong Stacked, nhưng tôi nghĩ rằng tôi vẫn nhận được nó.

Lựa chọn thay thế

73 byte: [0\|>:2%tmo*2 infixes[:...|>\rev...|>rev#,$#'sortby 1#behead]flatmap 0\,]

Điều này đi với cách tiếp cận "phạm vi từ các chỉ số được tạo" được sử dụng trong câu trả lời Attache của tôi . Điều này đã được chứng minh là khá dài, vì Stacked không có nội dung cho phạm vi đảo ngược cũng như sụp đổ. (Đó là những gì :...|>\rev...|>rev#,$#'sortby 1#behead.)

53 byte: [0\|>:2%tmo _\tpo#,tr[...rep]flatmap 0\,inits$summap]

... vì vậy tôi đã quyết định để đi cho một cách tiếp cận mà thay vào đó phát hiện số tiền tích lũy ( inits$summap) trên 1và -1lặp đi lặp lại bởi các số nguyên lẻ, như trong câu trả lời R .

46 byte: [~>0\:2%\#,2*1-tr[...rep]flatmap,inits$summap]

... nhưng tôi nhận ra rằng các số nguyên âm và số nguyên lẻ có thể được thực hiện trong một lần, bằng cách nhân cả hai mảng được tạo (giá trị mod 2 của phạm vi và chính phạm vi) bằng cách 2trừ đi 1. Điều này cho phép xen kẽ 1s và-1 s cho phạm vi đầu tiên và các số nguyên lẻ cho lần thứ hai!

44 byte: [~>0\:2%\#,2*1-tr[...rep]flatmap,$sumonpref]

... và sau đó tôi nhớ rằng tôi đã tích hợp sẵn để ánh xạ tiền tố. ^ - ^

Julia 0,6 , 44 byte

n->[(i%2*2-1)*[0:i;(n>i)*~-i:-1:1]for i=1:n]

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

Vì OP đề cập "định dạng đầu ra là linh hoạt", điều này sẽ in ra một mảng các mảng phụ, vd. U (3) =>[[0, 1], [0, -1, -2, -1], [0, 1, 2, 3]] .

i%2*2-1 quyết định dấu hiệu của phân đoạn hiện tại - âm cho số chẵn, dương cho số lẻ.

[0:i;(n>i)*~-i:-1:1]là hai phần. 0: i là đơn giản, phạm vi của các giá trị từ 0 đến i hiện tại. Trong phần tiếp theo, ~ -i: -1: 1 là phạm vi giảm dần từ i-1 đến 1. Nhưng chúng tôi chỉ muốn nối thêm phần này nếu chúng ta chưa ở giá trị cuối cùng, vì vậy nhân bội số trên của phạm vi bởi (n> i) để khi n == i, phạm vi sẽ là 0: -1: 1 kết thúc trống (vì vậy mảng dừng ở n chính xác).

Và đây là một phiên bản có thể hỗ trợ truy cập ngẫu nhiên - lambda bên trong ở đây trả về thuật ngữ thứ i của chuỗi mà không phải lưu trữ bất kỳ điều khoản nào trước nó. Điều này cũng cho đầu ra là một mảng gọn gàng duy nhất.

49 47 byte

n->map(i->((m=isqrt(i))%2*2-1)*(m-i+m^2),0:n^2)

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