도전:

양의 정수 입력 n이 주어지면 이 패턴을 따르는 벡터를 만듭니다.

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

또는 단어로 설명 : 벡터는에서 시작 하여 시퀀스의 일부가 아닌 가장 작은 홀수 양의 정수에 도달 할 때까지 0증가 1한 다음 가장 작은 음의 정수에 도달 할 때까지 감소합니다. 시퀀스의 일부가 아닙니다. n도달 할 때까지이 방법을 계속합니다 . 순서는 양극에 끝날 n경우 n홀수 및 네거티브 n경우 n에도있다.

출력 형식은 유연합니다.

테스트 사례 :

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

당신은 n 인덱스 0 을 취할 수 있습니다 . n = 1그런 다음 줄 것이다 0 1 0 -1 -2.

이것은 code-golf 이므로 각 언어에서 가장 짧은 코드가 승리합니다! 언제나처럼 설명이 권장됩니다!

R , 58 54 50 48 43 바이트

MickyT 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

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

펄 6 ,  60  26 바이트

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

시도 해봐

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

시도 해봐

넓히는:

{  # 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..$_ 시퀀스를 생성 0 1 -2 3 -4 5

파이썬 2 , 69 57 56 바이트

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

온라인으로 사용해보십시오!

각 n 까지 (포함)시 반전 산출 제거하고 출력 부가, 짝수 (역변환 후) 주먹 개의 번호를 갖는다.inputrange(-n,n)n

05AB1E , 9 7 바이트

@Emigna 덕분에 2 바이트 절약

Ýā®sm*Ÿ

온라인으로 사용해보십시오!

내 첫 05AB1E 답변 (제 생각에), 일부 트릭이 누락되었을 수 있습니다 ...

설명

Ý         # 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, ...]]

나는에 대한 @Dennis 감사가 의 원래 사용Ÿ , 그렇지 않으면 내가 하지 않을 수 있습니다 아마도 그것에 대해 알려져 있지 않았을 것입니다 ...

05AB1E , 15 14 바이트

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

온라인으로 사용해보십시오!

설명

Ý                # 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

자바 스크립트 (ES6), 56 바이트

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

온라인으로 사용해보십시오!

댓글

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

하스켈 , 43 바이트

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

온라인으로 사용해보십시오!

리스트의 부정 누적 합을 계산 [(-1)^k|k<-[1..n],_<-[2..2*k]]제 인 n행

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

젤리 , 11 9 바이트

²Ḷƽ-*0;Ä

온라인으로 사용해보십시오!

작동 원리

²Ḷƽ-*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.

하스켈 , 48 42 바이트

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

온라인으로 사용해보십시오!

-1 바이트의 Οurous 덕분에

이 가늠자에 어떤 분명한의 비록, 그것은에 도착 걸 렸어요 (-1)^i*x이는 x경우 i에도 그리고 -x경우 i홀수입니다. 이전 반복 :

(-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 코어) , 300  (167) 바이트

나는 이것들 중 어느 것도 한 번도 해 본 적이 없지만 이것은 재미있게 보였습니다. 나는 사람들이 왜 그 "골프"언어를 사용 하는가를 알고있다. 그러나, 당신은 당신이 알고있는 것과 함께 가야합니다.

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

온라인으로 사용해보십시오!

// 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 바이트

FrownyFrog 덕분에 -5 바이트!

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

온라인으로 사용해보십시오!

J , 30 바이트

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

설명:

i.,] 목록 0을 생성합니다 ..n

&.> 목록의 각 숫자에 대해 동사 (...)를 실행하고 결과를 상자에 넣습니다 (결과의 길이가 다르기 때문에 권투가 필요합니다)

[:( _1&^)1의 i거듭 제곱에 -1을 구합니다 (-1 또는 1)

i:@* 위의 부호에 따라 -n..n 또는 n ..- n 목록을 작성하십시오.

;@ 개봉하다

>:@*: n ^ 2 + 1 찾기

}. 목록에서 너무 많은 숫자를 가져옵니다

온라인으로 사용해보십시오!

파이썬 2 , 65 56 바이트

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

출력 형식이 약간 추합니다. : /

온라인으로 사용해보십시오!

자바 8, 85 83 79 바이트

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

@ OlivierGrégoire 덕분에 -6 바이트 .

온라인으로 사용해보십시오.

설명:

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 바이트

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

온라인으로 사용해보십시오!

Kirill L. 의 Ruby 응답 포트 -동일한 Kirill L. 덕분에 6 바이트를 절약했습니다! 이제 Giuseppe의 솔루션 보다 짧습니다 .)

Luis Mendo가 사용한 Octave 답변 의 포트 approx는 덜 골프합니다. n=n^2+1로 대체 될 수 있습니다 ,,n^2+1; 또는 동일한 바이트 수에 대해 0:n^2+1(위치 인수 xout) :

R , 56 바이트

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

온라인으로 사용해보십시오!

APL (Dyalog Unicode) , 17 바이트

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

온라인으로 사용해보십시오!

@FrownyFrog 덕분에 기차로 변환하여 2 바이트를 기록했습니다. 아래의 이전 답변과 설명을 참조하십시오.

APL (Dyalog Unicode) , 19 바이트

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

온라인으로 사용해보십시오!

(사용 ⎕IO←0)

첫 번째 방법은 여러 범위를 구성하고 함께 연결하는 것이 었습니다. 이는 30 바이트를 넘었습니다. 그런 다음 시퀀스 분석을 시작했습니다

      +\⍣¯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 역 누적 합계를 나타냅니다}

1과 1의 반복 패턴이 있으며, 여기서 1 또는 1의 각 연속 시퀀스의 길이는 1 + 2 × n입니다. 그리고 각 하위 시퀀스는 1과 ¯1 사이에서 번갈아 나타납니다. 내가 할 수있는 일은 1과 ¯1 목록을 만든 다음 +로 스캔하는 것입니다.

      ⍳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

하스켈 , 47 바이트

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

온라인으로 사용해보십시오!

자바 (JDK 10) , 98 바이트

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

온라인으로 사용해보십시오!

MATL , 17 15 바이트

Luis Mendo 덕분에 -2 바이트!

0i:oEqG:EqY"Ysh

온라인으로 사용해보십시오!

설명 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

옥타브 , 44 42 41 바이트

@StewieGriffin 덕분에 2 바이트가 제거되었으며 @Giuseppe 덕분에 1 바이트가 더 제거되었습니다!

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

온라인으로 사용해보십시오!

루비 , 52 47 바이트

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

온라인으로 사용해보십시오!

아래는 설명이있는 원본 52 바이트 버전입니다.

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

온라인으로 사용해보십시오!

연습

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
}

프롤로그 (SWI) 113 바이트

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.

온라인으로 사용해보십시오!

파이썬 3, 83 바이트

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

껍질 , 18 17 바이트

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

온라인으로 사용해보십시오!

숯 , 19 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

  Ｎ                 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

대체 설명 :

Ｆ⊕Ｎ

정수를 0입력 포함으로 반복 합니다.

Ｉ

인쇄하기 전에 결과를 문자열로 캐스트하십시오.

×∨﹪ι²±¹

대체 결과 집합을 무효화합니다.

…·∧ι⁻²ιι

이전 색인을 제외하고 이전 색인에서 현재 색인으로 목록을 구성하십시오.

젤리 ,  11  12 바이트

^{바, 나는 11 wih가 있다고 생각 _2+ỊrN)N;¥/}

_2+ỊrN×-*$)Ẏ

온라인으로 사용해보십시오!

어떻게?

_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 바이트

╗)SΘ█☼₧ΘP(

실행 및 디버깅

스칼라, 119 바이트

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}

언 골프 드 :

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
}

이것은 아마도 훨씬 나아질 수 있지만 게으른 스트림을 활용하는 솔루션을 원했습니다.

APL (Dyalog Unicode) , 34 32 바이트

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

온라인으로 사용해보십시오!

필요 ⎕IO←0

@FrownyFrog 덕분에 -2 바이트

스택 , 44 바이트

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

온라인으로 사용해보십시오! Stacked에서 프로그래밍한지 오래되었지만 아직 가지고 있다고 생각합니다.

대안

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

이것은 내 Attache 답변에 사용 된 "생성 된 인덱스의 범위"접근 방식과 관련이 있습니다. Stacked에는 역전 된 범위 나 축소를위한 내장 기능이 없기 때문에 상당히 길었습니다. (그게 :...|>\rev...|>rev#,$#'sortby 1#behead그렇습니다.)

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

... 그래서 내가 대신 누적 합계를 (발견 접근 가기로 결정 inits$summap을 통해) 1및 -1같이 홀수 정수로 반복 R 대답 .

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

...하지만 생성 된 배열 (범위의 mod 2 값과 범위 자체)에 뺄셈 을 곱하여 음수 와 홀수를 한 번에 만들 수 있음을 깨달았습니다 . 이것은 첫 번째 범위에 대한 s와 s를 제공하고 두 번째 범위에 대한 홀수 정수를 제공합니다!211-1

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

... 그리고 접두사 매핑을위한 내장 기능이 있다는 것을 기억했습니다. ^-^

줄리아 0.6 , 44 바이트

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

온라인으로 사용해보십시오!

OP는 "출력 형식이 유연하다"고 언급하므로 하위 배열의 배열을 인쇄합니다. U (3) => [[0, 1], [0, -1, -2, -1], [0, 1, 2, 3]].

i%2*2-1 현재 하위 배열의 부호를 결정합니다. 짝수이면 음수이고 홀수이면 양수입니다.

[0:i;(n>i)*~-i:-1:1]두 부분으로되어 있습니다. 0 : i는 간단하며 0에서 현재 i까지의 값 범위입니다. 다음 부분에서 ~ -i : -1 : 1은 i-1에서 1까지의 내림차순 범위입니다. 그러나 아직 최종 값이 아닌 경우에만이 값을 더하고 싶습니다. 따라서 범위의 상단에 곱하십시오 n == i 일 때 범위는 0 : -1 : 1이되어 비워집니다 (따라서 배열은 n에서 올바르게 멈춤).

그리고 여기에 랜덤 액세스를 지원할 수있는 버전이 있습니다. 여기서 내부 람다는 시퀀스의 어떤 용어도 저장하지 않고 시퀀스의 i 번째 용어를 반환합니다. 이것도 출력을 하나의 깔끔한 배열로 제공합니다.

49 47 바이트

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

온라인으로 사용해보십시오!