Wyzwanie:

Biorąc pod uwagę dodatnią liczbę całkowitą n , utwórz wektor zgodny z tym wzorem:

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

Lub wyjaśnione słowami: wektor zaczyna się od 0i dokonuje przyrostów, 1aż osiągnie najmniejszą nieparzystą liczbę całkowitą dodatnią, która nie jest częścią sekwencji, a następnie dokonuje dekrecji, aż osiągnie najmniejszą (pod względem wielkości) parzystą liczbę całkowitą ujemną, która nie jest To część sekwencji. Kontynuuje w ten sposób, aż nzostanie osiągnięty. Sekwencja zakończy się na wartości dodatniej, njeśli njest nieparzysta, a ujemnej, njeśli njest nieparzysta .

Format wyjściowy jest elastyczny.

Przypadki testowe:

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

Możesz wybrać n -zindeksowane. n = 1dałby wtedy 0 1 0 -1 -2.

To jest golf golfowy , więc wygrywa najkrótszy kod w każdym języku! Objaśnienia zachęcamy jak zawsze!

R , 58 54 50 48 43 bajtów

-2 bajty dzięki MickyT

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

Wypróbuj online!

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 bajtów

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

Spróbuj

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

Spróbuj

Rozszerzony:

{  # 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..$_ generuje sekwencję 0 1 -2 3 -4 5

Python 2 , 69 57 56 bajtów

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

Wypróbuj online!

Dla każdego n odpowiednie rozwiązanie dla (włącznie), obliczana jest odwrócony, kiedy jest to liczba parzysta, ma pięści dwóch cyfr (po odwróceniu) usuwa się, a następnie dołączana do wyjścia.inputrange(-n,n)n

05AB1E , 9 7 bajtów

Zaoszczędź 2 bajty dzięki @Emigna

Ýā®sm*Ÿ

Wypróbuj online!

Moja pierwsza odpowiedź 05AB1E (tak myślę), więc może brakuje mi trików ...

Wyjaśnienie

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

Muszę podziękować @Dennis do pierwotnego użytkowaniaŸ , w przeciwnym razie może nie prawdopodobnie nigdy nie wiadomo o tym ...

05AB1E , 15 14 bajtów

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

Wypróbuj online!

Wyjaśnienie

Ý                # 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 bajtów

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

Wypróbuj online!

Skomentował

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 bajty

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

Wypróbuj online!

Oblicza zanegowane skumulowane sumy listy [(-1)^k|k<-[1..n],_<-[2..2*k]], która jest pierwszymi nwierszami

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

Galaretka , 11 9 bajtów

²Ḷƽ-*0;Ä

Wypróbuj online!

Jak to działa

²Ḷƽ-*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 bajtów

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

Wypróbuj online!

Dzięki Οurous za -1 bajt

Nawet jeśli jest to raczej oczywiste z perspektywy czasu, zajęło mi trochę czasu, aby dojść (-1)^i*xco jest x, gdy ijeszcze jest i -xkiedy ijest nieparzysta. Poprzednie iteracje, w których:

(-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 bajtów

Nigdy wcześniej tego nie robiłem, ale ten wydawał się zabawny. Rozumiem, dlaczego ludzie używają tych „golfowych” języków, ponieważ 167 wydaje się znacznie wyższa niż niektóre inne odpowiedzi. Ale musisz iść z tym, co wiesz.

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

Wypróbuj online!

// 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 bajtów

-5 bajtów dzięki FrownyFrog!

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

Wypróbuj online!

J , 30 bajtów

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

Wyjaśnienie:

i.,] tworzy listę 0..n

&.> dla każdej liczby na liście wykonaj czasownik w (...) i wstaw wynik (potrzebuję boksu, ponieważ wyniki mają inną długość)

[:( _1&^)znajdź -1 do ipotęgi (-1 lub 1)

i:@* stwórz listę -n..n lub n ..- n, w zależności od znaku powyższego

;@ rozpakuj

>:@*: znajdź n ^ 2 + 1

}. i wziąć tyle liczb z listy

Wypróbuj online!

Python 2 , 65 56 bajtów

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

Format wyjściowy jest nieco brzydki. : /

Wypróbuj online!

Java 8, 85 83 79 bajtów

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

-6 bajtów dzięki @ OlivierGrégoire .

Wypróbuj online.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Port odpowiedzi Ruby autorstwa Kirill L. - i zaoszczędził 6 bajtów dzięki temu samemu Kirill L.! Teraz krótszy niż rozwiązanie Giuseppe ;)

Część tej odpowiedzi Octave autorstwa Luisa Mendo approxjest mniej golfowa. n=n^2+1można zastąpić przez ,,n^2+1; lub przez 0:n^2+1 (argument pozycyjny xout) dla tej samej liczby bajtów:

R , 56 bajtów

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

Wypróbuj online!

APL (Dyalog Unicode) , 17 bajtów

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

Wypróbuj online!

Grał w golfa 2 bajty dzięki @FrownyFrog, przechodząc na pociąg. Zobacz starszą odpowiedź i jej wyjaśnienie poniżej.

APL (Dyalog Unicode) , 19 bajtów

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

Wypróbuj online!

(Wykorzystuje ⎕IO←0 )

Moje pierwsze podejście polegało na konstruowaniu wielu zakresów i łączeniu ich ze sobą, co z łatwością przekroczyło 30 bajtów. Potem zacząłem analizować sekwencję

      +\⍣¯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 oznacza odwrotną sumę skumulowaną}

Istnieje powtarzający się wzór 1s i ¯1s, gdzie długość każdej kolejnej sekwencji 1s lub ¯1s wynosi 1 + 2 × n. I każda podsekwencja występuje naprzemiennie między 1 a ¯1. Teraz mogę utworzyć listę 1 i 1, a następnie skanować według +

      ⍳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 bajtów

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

Wypróbuj online!

Java (JDK 10) , 98 bajtów

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

Wypróbuj online!

MATL , 17 15 bajtów

-2 bajty dzięki Luisowi Mendo!

0i:oEqG:EqY"Ysh

Wypróbuj online!

Wyjaśnienie dla 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

Oktawa , 44 42 41 bajtów

2 bajty usunięte dzięki @StewieGriffin , a 1 bajt dalej usunięty dzięki @Giuseppe!

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

Wypróbuj online!

Rubin , 52 47 bajtów

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

Wypróbuj online!

Poniżej znajduje się oryginalna 52-bajtowa wersja z wyjaśnieniem:

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

Wypróbuj online!

Przewodnik

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 bajtów

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.

Wypróbuj online!

Python 3, 83 bajty

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

łuska , 18 17 bajtów

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

Wypróbuj online!

Węgiel drzewny , 19 bajtów

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

Wypróbuj online!Link jest do pełnej wersji kodu. Wyjaśnienie:

  Ｎ                 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

Alternatywne wyjaśnienie:

Ｆ⊕Ｎ

Pętla nad liczbami całkowitymi od 0 do wejścia włącznie.

Ｉ

Rzuć wyniki na ciąg przed drukowaniem.

×∨﹪ι²±¹

Neguj alternatywne zestawy wyników.

…·∧ι⁻²ιι

Utwórz listę od poprzedniego indeksu do bieżącego indeksu, z wyłączeniem poprzedniego indeksu.

Galaretka ,  11  12 bajtów

^{Bah, myślałem, że mam 11 wih _2+ỊrN)N;¥/}

_2+ỊrN×-*$)Ẏ

Wypróbuj online!

W jaki sposób?

_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 bajtów

╗)SΘ█☼₧ΘP(

Uruchom i debuguj

Scala, 119 bajtów

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}

Nie golfowany:

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
}

Prawdopodobnie można to grać w golfa znacznie lepiej, ale chciałem rozwiązania wykorzystującego leniwe strumienie.

APL (Dyalog Unicode) , 34 32 bajty

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

Wypróbuj online!

Wymaga ⎕IO←0

-2 bajty dzięki @FrownyFrog

Skumulowane , 44 bajty

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

Wypróbuj online!Minęło trochę czasu, odkąd programowałem w Stacked, ale myślę, że nadal go mam.

Alternatywy

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

Jest to zgodne z podejściem „zakresy od wygenerowanych indeksów” zastosowanym w mojej odpowiedzi Attache. Okazało się to dość długie, ponieważ Stacked nie ma wbudowanego odwróconego zakresu ani zwijania. (To właśnie :...|>\rev...|>rev#,$#'sortby 1#beheadrobi.)

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

... więc postanowiłem pójść na podejściu, które zamiast znajdzie skumulowaną sumę ( inits$summap) nad 1i -1powtarzane przez nieparzystych liczb całkowitych, jak w odpowiedzi R .

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

... ale zdałem sobie sprawę, że ujemne liczby całkowite i nieparzyste liczby całkowite można wykonać za jednym razem, mnożąc obie wygenerowane tablice (wartości mod 2 zakresu i samego zakresu), 2a następnie odejmując 1. Daje to naprzemiennie 1s i-1 dla pierwszego zakresu i nieparzyste liczby całkowite dla drugiego!

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

... a potem przypomniałem sobie, że mam wbudowane prefiksy mapowania. ^ - ^

Julia 0.6 , 44 bajty

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

Wypróbuj online!

Ponieważ OP wspomina o „formacie wyjściowym jest elastyczny”, drukuje tablicę podtablic, np. U (3) =>[[0, 1], [0, -1, -2, -1], [0, 1, 2, 3]] .

i%2*2-1 decyduje o znaku bieżącej podtablicy - ujemna dla liczb parzystych, dodatnia dla nieparzystych.

[0:i;(n>i)*~-i:-1:1]jest w dwóch częściach. 0: i jest proste, zakres wartości od 0 do bieżącego i. W następnej części ~ -i: -1: 1 to malejący zakres od i-1 do 1. Ale chcemy dołączyć to tylko wtedy, gdy nie jesteśmy jeszcze w końcowej wartości, więc pomnóż górną granicę zakresu przez (n> i), więc gdy n == i, zakres wyniesie 0: -1: 1, co kończy się pustą (więc tablica zatrzymuje się na n poprawnie).

A oto wersja, która może obsługiwać dostęp losowy - wewnętrzna lambda zwraca tutaj i-ty termin sekwencji bez konieczności zapisywania któregokolwiek z terminów przed nim. Ten daje również wyjście jako pojedynczą, czystą tablicę.

49 47 bajtów

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

Wypróbuj online!