Sfida:

Dato un input intero positivo n , creare un vettore che segue questo modello:

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

Oppure, spiegato con le parole: il vettore inizia da 0e fa incrementi di 1fino a raggiungere il numero intero dispari positivo più piccolo che non fa parte della sequenza, quindi diminuisce fino a raggiungere il numero intero negativo (anche in magnitudine) più piccolo che non è fa parte della sequenza. Continua così fino a quando non nviene raggiunto. La sequenza finirà in positivo nse nè dispari e in negativo nse nè pari.

Il formato di output è flessibile.

Casi test:

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

Puoi scegliere di prendere n indicizzato zero. n = 1darebbe quindi 0 1 0 -1 -2.

Questo è code-golf , quindi vince il codice più corto in ogni lingua! Le spiegazioni sono incoraggiate come sempre!

R , 58 54 50 48 43 byte

-2 byte grazie a MickyT

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

Provalo 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 byte

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

Provalo

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

Provalo

Allargato:

{  # 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..$_ genera la sequenza 0 1 -2 3 -4 5

Python 2 , 69 57 56 byte

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

Provalo online!

Per ciascuna n fino inputalla range(-n,n)(compreso) è calcolata, invertita quando nè un numero pari, ha i pugno due numeri (dopo l'inversione) rimosso, e poi aggiunto alla uscita.

05AB1E , 9 7 byte

Salvato 2 byte grazie a @Emigna

Ýā®sm*Ÿ

Provalo online!

La mia prima risposta 05AB1E (penso), quindi potrei mancare alcuni trucchi ...

Spiegazione

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

Devo ringraziare @Dennis per l'uso originale diŸ , altrimenti probabilmente non lo avrei mai saputo ...

05AB1E , 15 14 byte

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

Provalo online!

Spiegazione

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

Provalo online!

Commentate

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 byte

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

Provalo online!

Calcola le somme cumulative negate dell'elenco [(-1)^k|k<-[1..n],_<-[2..2*k]], ovvero le prime nrighe di

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

Gelatina , 11 9 byte

²Ḷƽ-*0;Ä

Provalo online!

Come funziona

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

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

Provalo online!

Grazie a ousurous per -1 byte

Anche se è abbastanza ovvio col senno di poi, mi c'è voluto un po 'per arrivare a (-1)^i*xche è xquando iè ancora e -xquando iè dispari. Iterazioni precedenti in cui:

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

Non ho mai fatto nessuno di questi prima, ma questo sembrava divertente. Vedo perché le persone usano queste lingue "da golf" poiché 167 sembra molto più alto di alcune delle altre risposte. Ma devi andare con quello che sai.

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

Provalo 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 byte

-5 byte grazie a FrownyFrog!

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

Provalo online!

J , 30 byte

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

Spiegazione:

i.,] crea la lista 0..n

&.> per ogni numero nell'elenco eseguire il verbo in (...) e racchiudere il risultato (ho bisogno di boxe perché i risultati hanno lunghezza diversa)

[:( _1&^)trova -1 alla ipotenza th (-1 o 1)

i:@* fare una lista -n..n o n ..- n, a seconda del segno di cui sopra

;@ Unbox

>:@*: trova n ^ 2 + 1

}. e prendi così tanti numeri dalla lista

Provalo online!

Python 2 , 65 56 byte

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

Il formato di output è un po 'brutto. : /

Provalo online!

Java 8, 85 83 79 byte

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

-6 byte grazie a @ OlivierGrégoire .

Provalo online.

Spiegazione:

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 byte

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

Provalo online!

Una risposta del porto del Rubino di Kirill L. - e salvato 6 byte grazie allo stesso Kirill L.! Ora più breve della soluzione di Giuseppe ;)

Una porta di questa risposta Octave di Luis Mendo approxè meno golfosa. n=n^2+1può essere sostituito da,,n^2+1 ; o da 0:n^2+1(argomento posizionale xout) per lo stesso conteggio byte:

R , 56 byte

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

Provalo online!

APL (Dyalog Unicode) , 17 byte

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

Provalo online!

Golfato 2 byte grazie a @FrownyFrog convertendolo in un treno. Vedi la risposta precedente e la sua spiegazione di seguito.

APL (Dyalog Unicode) , 19 byte

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

Provalo online!

(Usi ⎕IO←0 )

Il mio primo approccio è stato quello di costruire più intervalli e concatenarli insieme, questo ha superato facilmente i 30 byte. Quindi ho iniziato ad analizzare la sequenza

      +\⍣¯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 indica la somma cumulativa inversa}

Esiste un modello ripetitivo di 1s e ¯1s, in cui la lunghezza di ciascuna sequenza consecutiva di 1s o ¯1s è 1 + 2 × n. E ogni sottosequenza si alterna tra 1 e ¯1. Quello che posso fare ora è creare l'elenco 1s e ¯1s, quindi scansionare per +

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

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

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

Provalo online!

MATL , 17 15 byte

-2 byte grazie a Luis Mendo!

0i:oEqG:EqY"Ysh

Provalo online!

Spiegazione per 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

Ottava , 44 42 41 byte

2 byte rimossi grazie a @StewieGriffin e 1 byte ulteriormente rimossi grazie a @Giuseppe!

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

Provalo online!

Rubino , 52 47 byte

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

Provalo online!

Di seguito è riportata la versione originale a 52 byte con una spiegazione:

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

Provalo online!

Procedura dettagliata

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 byte

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.

Provalo online!

Python 3, 83 byte

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

Buccia , 18 17 byte

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

Provalo online!

Carbone , 19 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  Ｎ                 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

Spiegazione alternativa:

Ｆ⊕Ｎ

Passa sopra gli interi 0dall'input incluso.

Ｉ

Trasmetti i risultati in stringa prima della stampa.

×∨﹪ι²±¹

Annulla gruppi di risultati alternativi.

…·∧ι⁻²ιι

Formare un elenco dall'indice precedente all'indice corrente, escluso l'indice precedente.

Gelatina ,  11  12 byte

^{Bah, pensavo di averne 11 con _2+ỊrN)N;¥/}

_2+ỊrN×-*$)Ẏ

Provalo online!

Come?

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

╗)SΘ█☼₧ΘP(

Esegui ed esegui il debug

Scala, 119 byte

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
}

Probabilmente questo può essere giocato a golf molto meglio, ma volevo una soluzione utilizzando i flussi pigri.

APL (Dyalog Unicode) , 34 32 byte

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

Provalo online!

Richiede ⎕IO←0

-2 byte grazie a @FrownyFrog

Impilato , 44 byte

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

Provalo online!È passato un po 'di tempo da quando ho programmato in Stacked, ma penso di averlo ancora ottenuto.

alternative

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

Questo si accompagna all'approccio "intervalli da indici generati" utilizzato nella mia risposta di Attache. Questo si è rivelato piuttosto lungo, dal momento che Stacked non ha builtin per range inversi o collasso. (Ecco cosa :...|>\rev...|>rev#,$#'sortby 1#beheadfa.)

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

... così ho deciso di andare per un approccio che trova invece la somma cumulativa ( inits$summap) sopra 1e -1ripetuta dai interi dispari, come nella risposta R .

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

... ma ho capito che gli interi negativi e gli interi dispari potevano essere fatti in una volta sola, moltiplicando entrambi gli array generati (i valori mod 2 dell'intervallo e l'intervallo stesso) 2sottraendo 1. Questo dà alternanza se 1e-1 s per il primo intervallo e numeri dispari per il secondo!

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

... e poi mi sono ricordato di avere un built-in per i prefissi di mappatura. ^ - ^

Julia 0.6 , 44 byte

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

Provalo online!

Poiché OP menziona "il formato di output è flessibile", questo stampa una matrice di sotto array, ad es. U (3) =>[[0, 1], [0, -1, -2, -1], [0, 1, 2, 3]] .

i%2*2-1 decide il segno del sottoarray corrente: negativo per numeri pari, positivo per dispari.

[0:i;(n>i)*~-i:-1:1]è in due parti. 0: i è semplice, l'intervallo di valori da 0 all'attuale i. Nella parte successiva, ~ -i: -1: 1 è l'intervallo discendente da i-1 a 1. Ma vogliamo aggiungere questo solo se non siamo ancora al valore finale, quindi moltiplica l'estremità superiore dell'intervallo di (n> i) in modo che quando n == i, l'intervallo sarà 0: -1: 1 che finirà vuoto (quindi l'array si arresta correttamente in n).

Ed ecco una versione che può supportare l'accesso casuale - qui la lambda interna restituisce l'undicesimo termine della sequenza senza dover aver memorizzato nessuno dei termini prima di esso. Questo fornisce anche l'output come un singolo array pulito.

49 47 byte

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

Provalo online!