Rauf und runter, rauf und runter

34

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 , also gewinnt der kürzeste Code in jeder Sprache! Erklärungen sind wie immer erwünscht!

Stewie Griffin
quelle
2
Relevant: OEIS A196199 .
Mr. Xcoder

Antworten:

10

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

Giuseppe
quelle
8

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

Brad Gilbert b2gills
quelle
7

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.

Stange
quelle
7

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

ETHproductions
quelle
Nett :)! Ich habe ÝεDÈi®*}}Ÿohne zu überprüfen, ā®smist verrückt schlau haha.
Magic Octopus Urn
6

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
Emigna
quelle
6

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
Arnauld
quelle
6

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
Lynn
quelle
6

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.
Dennis
quelle
6

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
Laikoni
quelle
1
Sie können durch die Verwendung eines Byte speichern , 1-ianstatt -i+1im ..Ausdruck.
Οurous
4

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();
}
Darrin Cullop
quelle
1
Sie können dies viel kürzer machen, wenn Sie nur die usingAnweisungen und die Funktion zählen. Dies ist standardmäßig zulässig, es sei denn, die Abfrage gibt an, dass es sich um ein vollständiges Programm handeln muss (auch wenn dies der Fall ist, können Sie den enthaltenen Klassennamen verkürzen).
ousurous
Vielen Dank! Dank Ihres Vorschlags habe ich die Bedeutung der Abschnitte "Header" und "Footer" der TIO-Site herausgefunden. Das hat meine Einreichungsgröße halbiert!
Darrin Cullop
2
Willkommen bei PPCG! (Dies sieht aus wie dein erster Beitrag.) Mach dir keine Sorgen um die anderen Sprachen, versuche einfach, so gut wie möglich in deiner Sprache zu sein. / Tipps: Entfernen Sie unnötige Leerzeichen. In C # können Sie alle Leerzeichen entfernen, die Symbole ( [](){};.) (n-1)*2gerade umgeben 2*n-2und mit etwas Umstellung können Sie die Klammern dort entfernen.
user202729
Außerdem !=hat Vorrang weniger als %so können Sie ein Paar von Eltern entfernen. Und Sie können >0anstelle von `! = 0 verwenden, um ein Byte zu speichern.
user202729
1
Auch von mir: Willkommen bei PPCG! Tipps zum Golfen in C # und Tipps zum Golfen in allen Sprachen sind möglicherweise interessant zu lesen. :) Wie für einige Golf - Tipps: static int[] f(int n)kann sich f=n=>ein (rekursiv) Lambda durch die Verwendung und (n-1)*2werden kann , ~-n*2auf der Klammer zu speichern. Ich habe es auf 155 (137 + 18) Bytes reduziert: Probieren Sie es online aus . Die 18 Bytes sind für using System.Linq;, weil die erforderlichen Importe für die Byteanzahl obligatorisch sind. Genieße deinen Aufenthalt!
Kevin Cruijssen
4

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!

Galen Ivanov
quelle
1
Würden Sie erwägen, den gleichen Code wie eine nullbasierte nVersion zu schreiben ? zB *:{.;@([:(i:@*_1&^)&.>i.).. die spezifikation erlaubt das
jayprich
"n = 1 würde dann 0 1 0 -1 -2" ergeben
FrownyFrog
@FrownyFrog - Hmm, ich habe es nicht überprüft. Ich kehrte zu meiner ersten Lösung zurück. Danke für die Beobachtung!
Galen Ivanov
1
25 Verwendung $für den Cut-Off, keine Notwendigkeit, &.>da *Rang 0 ist.
FrownyFrog
3

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!

Dennis
quelle
3

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
Kevin Cruijssen
quelle
Netter Ansatz. Ich habe gerade an einem solchen Ansatz gearbeitet, um meine Antwort zu verbessern, aber du hast mich (trotz deines Treffens) geschlagen, gut gemacht! ;-)
Olivier Grégoire
1
83 Bytes (ich habe gerade entfernt j).
Olivier Grégoire
1
79 Bytes : Ich habe ieinen Auf- statt Ab-Befehl ausgeführt, um einen überflüssigen zu entfernen n*n.
Olivier Grégoire
Hallo. Schreiben Sie dies, um mich darüber zu informieren, dass ich Ihre Antwort im Grunde genommen verfälscht habe . (Portierung auf JavaScript). Hoffe, es ist in Ordnung
Muhammad Salman
@ Muhammad Salman Sicher, np. Ich portiere auch ziemlich oft Antworten von anderen. :) Solange die ursprüngliche Antwort erwähnt wird, wie du es getan hast, ist alles in Ordnung für mich.
Kevin Cruijssen
3

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!

JayCe
quelle
Ich denke approx, hier wird ähnlich wie in Luis Mendos Octave-Lösung gearbeitet.
Giuseppe
@ Giuseppe Danke! Es funktioniert, obwohl es länger ist. Ich habe gelernt diffinvund approxaus dieser Frage ...
JayCe
Ich kenne zwar auch keinen besseren Weg, um -1 zu machen (in R ~funktioniert das nicht als Komplement-Operator :(), aber Sie können noch 2 Bytes sparen, indem Sie zu einem vollständigen Programm wechseln.
Kirill L.
... und da es sich um ein vollständiges Programm handelt, können wir auch ein vordefiniertes eingebautes verwenden und verwöhnen: 42 Bytes - endlich kürzer als das von Giuseppe!
Kirill L.
3

APL (Dyalog Unicode) , 17 Byte

+\01*⍳(/⍨)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

      +\⍣¯10  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
┌─┬─────┬─────────┬─────────────┐
11 1 11 1 1 1 11 1 1 1 1 1 1
└─┴─────┴─────────┴─────────────┘
      ⊢∘-\⍴1¨1+2×⍳4  alternate signs
┌─┬────────┬─────────┬────────────────────┐
1│¯1 ¯1 ¯11 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
Kritixi Lithos
quelle
Wenn ich jetzt andere Antworten überprüfe, sehe ich, dass viele auch die + \ -Methode verwenden, aber die Folge von 1s und ¯1s mit ¯1 * ⌊.5 * ⍨ × ⍨⍳ erzeugen, was zufällig mindestens 3 Bytes kürzer ist.
Kritixi Lithos
+\0,¯1*⍳(/⍨)1+2×⍳ist 17
FrownyFrog
Ich wusste, dass sich meine Lösung lange
anfühlte
2

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!

Olivier Grégoire
quelle
Ah, während ich in meiner Besprechung war, hast du eine Antwort vor mir eingeschlichen.;) Werde meine auch durchlassen, weil wir einen ganz anderen Ansatz verwenden. +1 so oder so.
Kevin Cruijssen
2

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
Giuseppe
quelle
2

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
}
Kirill L.
quelle
Ich kenne Ruby nicht - kannst du erklären, was das macht, besonders die map(&:-@)Portion?
JayCe
@ JayCe Hinzugefügt eine Erklärung. Im Grunde ist dies nur Negation, was in R einfach wäre -r.
Kirill L.
Danke für die Erklärung - es hat mir geholfen, das auf R.
JayCe
1

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])
Bobrobbob
quelle
1

Holzkohle , 19 Bytes

F⊕NI×∨﹪ι²±¹…·∧ι⁻²ιι

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

  N                 Input as a number
 ⊕                  Increment
F                   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
   I                Cast to string and implicitly print

Alternative Erklärung:

F⊕N

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.

Neil
quelle
1

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]
Jonathan Allan
quelle
1

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.

Ethan
quelle
1

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. ^ - ^

Conor O'Brien
quelle
1

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!

Sundar - Setzen Sie Monica wieder ein
quelle