Herausforderung:

Erstellen Sie bei einer positiven Ganzzahleingabe n einen Vektor, der diesem Muster folgt:

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

Oder mit Worten erklärt: Der Vektor beginnt bei 0und führt Inkremente aus, 1bis er die kleinste ungerade positive Ganzzahl erreicht, die nicht Teil der Sequenz ist, und dekrementiert, bis er die kleinste (in der Größe) gerade negative Ganzzahl erreicht, die nicht vorhanden ist ist nicht Teil der Sequenz. Es geht so weiter bis nerreicht ist. Die Sequenz endet mit positiv, nwenn nungerade, und negativ, nwenn ngerade.

Das Ausgabeformat ist flexibel.

Testfälle:

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

Sie können sich dafür entscheiden, n mit Nullindex zu verwenden. n = 1würde dann geben 0 1 0 -1 -2.

Das ist Code-Golf , also gewinnt der kürzeste Code in jeder Sprache! Erklärungen sind wie immer erwünscht!

R , 58 54 50 48 43 Bytes

-2 Bytes dank MickyT

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

Probieren Sie es 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 Bytes

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

Versuch es

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

Versuch es

Erweitert:

{  # 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..$_ generiert die Sequenz 0 1 -2 3 -4 5

Python 2 , 69 57 56 Bytes

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

Probieren Sie es online!

Für jedes n bis wird inputdas range(-n,n)(inklusive) berechnet, invertiert, wenn nes eine gerade Zahl ist, die ersten zwei Zahlen (nach der Inversion) entfernt und dann an die Ausgabe angehängt.

05AB1E , 9 7 Bytes

2 Bytes dank @Emigna gespeichert

Ýā®sm*Ÿ

Probieren Sie es online!

Meine erste 05AB1E-Antwort (glaube ich), daher fehlen mir möglicherweise einige Tricks ...

Erläuterung

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

Ich muss mich bei @Dennis für die ursprüngliche Verwendung vonŸ bedanken , sonst hätte ich es wahrscheinlich nie gewusst ...

05AB1E , 15 14 Bytes

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

Probieren Sie es online!

Erläuterung

Ý                # 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):[]]

Probieren Sie es online!

Kommentiert

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 Bytes

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

Probieren Sie es online!

Berechnet die negierten kumulativen Summen der Liste [(-1)^k|k<-[1..n],_<-[2..2*k]], bei der es sich um die ersten nZeilen von handelt

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

Jelly , 11 9 Bytes

²Ḷƽ-*0;Ä

Probieren Sie es online!

Wie es funktioniert

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

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

Probieren Sie es online!

Danke an Οurous für -1 Byte

Auch wenn es ziemlich offensichtlich im Nachhinein ist, dauerte es eine Weile , um das erreichen (-1)^i*xdie , xwenn igerade ist , und -xwenn iungerade ist . Frühere Iterationen, bei denen:

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

Ich habe noch nie etwas davon gemacht, aber das hier schien Spaß zu machen. Ich verstehe, warum die Leute diese "Golf" -Sprachen verwenden, da sie weit über den anderen Antworten zu liegen scheinen. Aber du musst mit dem gehen, was du weiß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();}

Probieren Sie es 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 Bytes

-5 Bytes dank FrownyFrog!

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

Probieren Sie es online!

J , 30 Bytes

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

Erläuterung:

i.,] Erstellt Liste 0..n

&.> für jede Zahl in der Liste das Verb in (...) ausführen und das Ergebnis boxen

[:( _1&^)finde -1 ihoch (-1 oder 1)

i:@* Machen Sie eine Liste -n..n oder n ..- n, je nach dem Vorzeichen der oben genannten

;@ Unbox

>:@*: finde n ^ 2 + 1

}. und nimm so viele Zahlen aus der Liste

Probieren Sie es online!

Python 2 , 65 56 Bytes

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

Das Ausgabeformat ist etwas hässlich. : /

Probieren Sie es online!

Java 8, 85 83 79 Bytes

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

-6 Bytes dank @ OlivierGrégoire .

Probieren Sie es online aus.

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Ein Port der Ruby-Antwort von Kirill L. - und dank des gleichen Kirill L. 6 Bytes gespart! Jetzt kürzer als Giuseppes Lösung ;)

Ein Port, den Luis Mendo für dieseapprox Oktavantwort verwendet, ist weniger golfen. n=n^2+1kann ersetzt werden durch ,,n^2+1; oder by 0:n^2+1(Positionsargument xout) für die gleiche Byteanzahl:

R , 56 Bytes

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

Probieren Sie es online!

APL (Dyalog Unicode) , 17 Byte

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

Probieren Sie es online!

Golf 2 Bytes dank @FrownyFrog durch die Umwandlung in einen Zug. Siehe die ältere Antwort und ihre Erklärung unten.

APL (Dyalog Unicode) , 19 Byte

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

Probieren Sie es online!

(Verwendet ⎕IO←0)

Mein erster Ansatz war, mehrere Bereiche zu konstruieren und diese zusammenzufügen. Das ging leicht über 30 Bytes. Dann begann ich die Sequenz zu analysieren

      +\⍣¯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 bezeichnet die inverse kumulative Summe}

Es gibt ein sich wiederholendes Muster von 1s und 1s, wobei die Länge jeder aufeinanderfolgenden Sequenz von 1s oder 1s 1 + 2 × n ist. Und jede Untersequenz wechselt zwischen 1 und ¯1. Was ich jetzt tun kann, ist, die Liste 1s und 1s zu erstellen und dann mit + zu scannen

      ⍳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 Bytes

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

Probieren Sie es online!

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

Probieren Sie es online!

MATL , 17 15 Bytes

-2 Bytes dank Luis Mendo!

0i:oEqG:EqY"Ysh

Probieren Sie es online!

Erklärung für 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

Oktave , 44 42 41 Bytes

2 Bytes entfernt dank @StewieGriffin und 1 Byte weiter entfernt dank @Giuseppe!

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

Probieren Sie es online!

Ruby , 52 47 Bytes

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

Probieren Sie es online!

Unten ist die ursprüngliche 52-Byte-Version mit einer Erklärung:

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

Probieren Sie es online!

Komplettlösung

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 Bytes

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.

Probieren Sie es online!

Python 3, 83 Bytes

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

Schale , 18 17 Bytes

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

Probieren Sie es online!

Holzkohle , 19 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

  Ｎ                 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

Alternative Erklärung:

Ｆ⊕Ｎ

Schleife über die ganzen Zahlen von 0bis einschließlich der Eingabe.

Ｉ

Konvertieren Sie die Ergebnisse vor dem Drucken in eine Zeichenfolge.

×∨﹪ι²±¹

Negieren Sie alternative Ergebnismengen.

…·∧ι⁻²ιι

Bilden Sie eine Liste vom vorherigen Index zum aktuellen Index, ohne den vorherigen Index.

Jelly ,  11  12 Bytes

^{Bah, ich dachte ich hätte 11 mit _2+ỊrN)N;¥/}

_2+ỊrN×-*$)Ẏ

Probieren Sie es online!

Wie?

_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 Bytes

╗)SΘ█☼₧ΘP(

Führen Sie es aus und debuggen Sie es

Scala, 119 Bytes

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
}

Dies kann wahrscheinlich viel besser golfen werden, aber ich wollte eine Lösung mit Lazy Streams.

APL (Dyalog Unicode) , 34 32 Bytes

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

Probieren Sie es online!

Benötigt ⎕IO←0

-2 Bytes dank @FrownyFrog

Gestapelt , 44 Bytes

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

Probieren Sie es online! Es ist schon eine Weile her, dass ich in Stacked programmiert habe, aber ich glaube, ich habe es immer noch.

Alternativen

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

Dies geht mit dem in meiner Attache-Antwort verwendeten Ansatz "Bereiche aus generierten Indizes" einher.Dies erwies sich als ziemlich lang, da Stacked weder für umgekehrte Bereiche noch für das Zusammenfallen geeignet ist. (Das ist was :...|>\rev...|>rev#,$#'sortby 1#beheadtut.)

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

... also habe ich mich für einen Ansatz entschieden, bei dem stattdessen die kumulative Summe ( inits$summap) über den ungeraden ganzen Zahlen liegt 1und von diesen -1wiederholt wird, wie in der R-Antwort .

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

... aber ich erkannte, dass die negativen und die ungeraden Ganzzahlen in einem Zug gebildet werden konnten, indem beide generierten Arrays (die mod 2-Werte des Bereichs und des Bereichs selbst) multipliziert und 2dann subtrahiert wurden 1. Dies ergibt abwechselnd 1s und-1 s für den ersten Bereich und die ungeraden ganzen Zahlen für den zweiten!

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

... und dann fiel mir ein, dass ich ein eingebautes Präfix für die Zuordnung hatte. ^ - ^

Julia 0,6 , 44 Bytes

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

Probieren Sie es online!

Da OP "das Ausgabeformat ist flexibel" erwähnt, wird ein Array von Sub-Arrays gedruckt, z. U (3) => [[0, 1], [0, -1, -2, -1], [0, 1, 2, 3]].

i%2*2-1 entscheidet über das Vorzeichen des aktuellen Subarrays - negativ für gerade Zahlen, positiv für ungerade.

[0:i;(n>i)*~-i:-1:1]besteht aus zwei Teilen. 0: i ist einfach, der Wertebereich von 0 bis zum aktuellen i. Im nächsten Teil ist ~ -i: -1: 1 der absteigende Bereich von i-1 bis 1. Wir möchten dies jedoch nur anhängen, wenn wir noch nicht den endgültigen Wert erreicht haben. Multiplizieren Sie also das obere Ende des Bereichs durch (n> i), so dass, wenn n == i ist, der Bereich 0: -1: 1 ist, was leer endet (so stoppt das Array bei n korrekt).

Und hier ist eine Version, die den wahlfreien Zugriff unterstützt - das innere Lambda gibt hier den i-ten Term der Sequenz zurück, ohne dass zuvor ein Term gespeichert werden muss. Dieser gibt die Ausgabe auch als einzelnes ordentliches Array aus.

49 47 Bytes

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

Probieren Sie es online!