Вызов:

Учитывая положительное целое число 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 с нулевым индексом. n = 1тогда бы дал 0 1 0 -1 -2.

Это код-гольф , поэтому выигрывает самый короткий код на каждом языке! Пояснения приветствуются как всегда!

R , 58 54 50 48 43 байта

-2 байта благодаря MickyT

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

Perl 6 ,  60  26 байт

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

Попытайся

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

Попытайся

Expanded:

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

Python 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 байт

Сохранено 2 байта благодаря @Emigna

Ýā®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

JavaScript (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

Haskell , 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.

Haskell , 48 42 байта

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

Попробуйте онлайн!

Спасибо Οurous за -1 байт

Несмотря на то, что это вроде очевидно, задним числом, мне потребовалось некоторое время , чтобы прибыть в (-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 Core) , 300  167 байт

Я никогда не делал ничего из этого раньше, но этот показался забавным. Я понимаю, почему люди используют эти языки «игры в гольф», поскольку 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 байт

-5 байт благодаря FrownyFrog!

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

Попробуйте онлайн!

J , 30 байт

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

Объяснение:

i.,] создает список 0..n

&.> для каждого числа в списке выполните глагол в (...) и укажите результат (мне нужен бокс, потому что результаты имеют разную длину)

[:( _1&^)найти -1 iстепень (-1 или 1)

i:@* составить список -n..n или n ..- n, в зависимости от знака выше

;@ распаковывать

>:@*: найти п ^ 2 + 1

}. и взять столько номеров из списка

Попробуйте онлайн!

Python 2 , 65 56 байт

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

Формат вывода немного некрасивый. : /

Попробуйте онлайн!

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

-6 байт благодаря @ OlivierGrégoire .

Попробуйте онлайн.

Объяснение:

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

Попробуйте онлайн!

Порт рубинового ответа Кирилла Л. - и сэкономил 6 байтов благодаря тому же Кириллу Л.! Теперь короче решение Джузеппе ;)

Порт этого октавского ответа Луиса Мендо использует 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×⍳

Попробуйте онлайн!

Гольф 2 байта благодаря @FrownyFrog путем преобразования в поезд. Смотрите старый ответ и его объяснение ниже.

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 обозначает обратную кумулятивную сумму}

Существует повторяющаяся последовательность 1s и ¯1s, где длина каждой последовательной последовательности 1s или ¯1s равна 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

Haskell , 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 байт

-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 байт

2 байта удалены благодаря @StewieGriffin , а 1 байт был удален благодаря @Giuseppe!

@(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.

Попробуйте онлайн!

Python 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 с _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}

Ungolfed:

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

-2 байта благодаря @FrownyFrog

Stacked , 44 байта

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

Попробуйте онлайн! Прошло много времени с тех пор, как я программировал в Stacked, но я думаю, что все еще получил его.

альтернативы

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

Это соответствует подходу «диапазоны из сгенерированных индексов», который используется в моем ответе Атташе. Это оказалось довольно долго, так как 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 диапазона и самого диапазона), 2затем вычитая 1. Это дает чередование1 и-1 s для первого диапазона и нечетные целые числа для второго!

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: я прост, диапазон значений от 0 до текущего я. В следующей части ~ -i: -1: 1 - нисходящий диапазон от i-1 до 1. Но мы хотим добавить это, только если мы еще не достигли конечного значения, поэтому умножьте верхний конец диапазона на (n> i), так что когда 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)

Попробуйте онлайн!