Atas dan ke bawah, ke atas dan ke bawah

34

Tantangan:

Diberikan input bilangan bulat positif n , buat vektor yang mengikuti pola ini:

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

Atau, dijelaskan dengan kata-kata: Vektor dimulai pada 0, dan membuat peningkatan 1hingga mencapai bilangan bulat positif terkecil terkecil yang bukan bagian dari urutan, kemudian membuat penurunan hingga mencapai bilangan bulat terkecil (dalam besaran) bahkan bilangan negatif yang tidak adalah bagian dari urutan. Terus seperti ini sampai ntercapai. Urutannya akan berakhir pada positif njika nganjil, dan negatif njika ngenap.

Format output fleksibel.

Kasus uji:

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

Anda dapat memilih untuk mengambil n -diindeks. n = 1akan memberi 0 1 0 -1 -2.

Ini adalah kode-golf , jadi kode terpendek dalam setiap bahasa menang! Penjelasan didorong seperti biasa!

code-golf  sequence  integer 
— Stewie Griffin
sumber
2
Relevan: OEIS A196199 .
— Tn. Xcoder

Jawaban:

10

R , 58 54 50 48 43 byte

-2 byte terima kasih kepada MickyT

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

Cobalah 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
sumber
8

Perl 6 ,  60  26 byte

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

Cobalah

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

Cobalah

Diperluas:

{  # 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..$_ menghasilkan urutan 0 1 -2 3 -4 5

— Brad Gilbert b2gills
sumber
7

Python 2 , 69 57 56 byte

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

Cobalah online!

Untuk setiap n sampai inputdengan range(-n,n)(inklusif) dihitung, terbalik saat nini jumlah yang lebih, memiliki tinju dua angka (setelah inversi) dihapus, dan kemudian ditambahkan ke output.

— tongkat
sumber
7

05AB1E , 9 7 byte

Disimpan 2 byte berkat @Emigna

Ýā®sm*Ÿ

Cobalah online!

Jawaban 05AB1E pertama saya (saya pikir), jadi saya mungkin kehilangan beberapa trik ...

Penjelasan

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

Saya harus berterima kasih kepada @ Dennis untuk penggunaan asliŸ , kalau tidak saya mungkin tidak akan pernah tahu tentang itu ...

— Produksi ETH
sumber
Bagus :)! Saya dapatkan ÝεDÈi®*}}Ÿtanpa memeriksa, ā®smgila pintar haha.
— Magic Gurita Guci
6

05AB1E , 15 14 byte

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

Cobalah online!

Penjelasan

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

Cobalah online!

Berkomentar

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
sumber
6

Haskell , 43 byte

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

Cobalah online!

Menghitung jumlah kumulatif yang dinegasikan dari daftar [(-1)^k|k<-[1..n],_<-[2..2*k]], yang merupakan nbaris pertama dari

[-1,
 +1, +1, +1,
 -1, -1, -1, -1, -1,
 +1, +1, +1, +1, +1, +1, +1…
— Lynn
sumber
6

Jelly , 11 9 byte

²Ḷƽ-*0;Ä

Cobalah online!

Bagaimana itu bekerja

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

Haskell , 48 42 byte

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

Cobalah online!

Berkat Οurous untuk -1 byte

Even though it's kind of obvious in hindsight, it took me a while to arrive at (-1)^i*x which is x when i is even and -x when i is odd. Previous iterations where:

(-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
sumber
1
You can save a byte by using 1-i instead of -i+1 in the .. expression.
— Οurous
4

C# (.NET Core), 300 167 bytes

I've never done any of these before, but this one seemed fun. I see why people use those "golfing" languages as 167 seems way higher than some of the other answers. But, you gotta go with what you know.

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

Try it 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
sumber
1
You can make this a lot shorter if you only count the using statements and the function. This is allowed by default unless the challenge specifies it must be a full program (even if it did, you could shorten the containing class name).
— Οurous
Thank you! Thanks to your suggestion, I figured out the meaning of the "header" and "footer" sections of the TIO site. That cut my submission size in half!
— Darrin Cullop
2
Welcome to PPCG! (this looks like your first post.) Don't worry about the other languages, just try to be as good as possible in your language. / Tips: Remove unnecessary spaces. In C# you can remove all spaces surrounding symbols ([](){};.) (n-1)*2 is just 2*n-2 and with some rearrangement you can remove the parentheses there.
— user202729
Besides, != has precedence less than % so you can remove a pair of parens. And you can use >0 instead of `!=0, saves a byte.
— user202729
1
Also from me: welcome to PPCG! Tips for golfing in C# and Tips for golfing in all languages might be interesting to read through. :) As for some golfing tips: static int[] f(int n) can become f=n=> by using a (recursive) lambda, and (n-1)*2 can become ~-n*2 to save on the parenthesis. I got it down to 155 (137 + 18) bytes: Try it online. The 18 bytes are for using System.Linq;, because required imports are mandatory for the byte-count. Enjoy your stay!
— Kevin Cruijssen
4

J, 25 bytes

-5 bytes thanks to FrownyFrog! 

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

Try it online!

J, 30 bytes

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

Explanation:

i.,] creates list 0..n

&.> for each number in the list execute the verb in (...) and box the result (I need boxing because the results have different length)

[:( _1&^) find -1 to the ith power (-1 or 1)

i:@* make a list -n..n or n..-n, depending on the sign of the above

;@ unbox

>:@*: find n^2 + 1

}. and take so many numbers from the list

Try it online!

— Galen Ivanov
sumber
1
would you consider writing the same code as a zero based n version? e.g *:{.;@([:(i:@*_1&^)&.>i.) .. the specification allows that
— jayprich
"n = 1 would then give 0 1 0 -1 -2"
— FrownyFrog
@FrownyFrog - Hmm, I didn't check it. I reverted to my first solution. Thank you for the observation!
— Galen Ivanov
1
25 Use $ for the cut-off, no need for &.> because * is rank-0.
— FrownyFrog
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 thanks to @OlivierGrégoire.

Try it online.

Explanation:

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
sumber
Nice approach. I was working on such approach right now, to improve my answer, but you beat me to it (despite your meeting), well done! ;-)
— Olivier Grégoire
1
83 bytes (I just removed j).
— Olivier Grégoire
1
79 bytes: I made i go up instead of down to remove a redundant n*n.
— Olivier Grégoire
Hi. Writing this to inform me you that I basically ripped off your answer. (port to JavaScript). Hope it's ok
— Muhammad Salman
@MuhammadSalman Sure, np. I port answers from others pretty often as well. :) As long as the original answer is mentioned, like you did, it's all fine by me.
— Kevin Cruijssen
3

R, 48 46 42 bytes

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

Try it online!

A port of the Ruby answer by Kirill L. - and saved 6 bytes thanks to the same Kirill L.! Now shorter than Giuseppe's solution ;)

A port of this Octave answer by Luis Mendo using approx is less golfy. n=n^2+1 can be replaced by ,,n^2+1; or by 0:n^2+1(positional argument xout) for the same byte count :

R, 56 bytes

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

Try it online!

— JayCe
sumber
I think approx will work here in a similar manner to Luis Mendo's Octave solution as well.
— Giuseppe
@Giuseppe Thanks! It does work though it's longer. I've learned diffinv and approx from this question...
— JayCe
Although I also don't know a golfier way to do -1 power (in R ~ doesn't work as a complement operator :(), you can still save another 2 bytes by switching to a full program.
— Kirill L.
...and since it is a full program we can also use and spoil a predefined built-in: 42 bytes - finally, shorter than Giuseppe's!
— Kirill L.
3

APL (Dyalog Unicode), 17 bytes

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

Try it online!

Golfed 2 bytes thanks to @FrownyFrog by converting to a train. See the older answer and its explanation below.

APL (Dyalog Unicode), 19 bytes

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

Try it online!

(Uses ⎕IO←0)

My first approach was to construct multiple ranges and concatenate them together, this easily went over 30 bytes. Then I started analysing the sequence

      +\⍣¯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 denotes the inverse cumulative sum

There is a repeating pattern of 1s and ¯1s, where the length of each consecutive sequence of 1s or ¯1s is 1+2×n. And each subsequence alternates between 1 and ¯1. What I can do now is to create the 1s and ¯1s list, and then scan by +

      ⍳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
— Kritixi Lithos
sumber
Checking other answers now, I see many also use the +\ method, but generate the sequence of 1s and ¯1s with ¯1*⌊.5*⍨×⍨⍳ which happens to be at least 3 bytes shorter.
— Kritixi Lithos
+\0,¯1*⍳(/⍨)1+2×⍳ is 17
— FrownyFrog
I knew my solution felt long
— Zacharý
2

Java (JDK 10), 98 bytes

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

Try it online!

— Olivier Grégoire
sumber
Ah, while I was in my meeting you sneaked in an answer before me.. ;) Will leave mine as well through, because we use a completely different approach. +1 either way.
— Kevin Cruijssen
2

MATL, 17 15 bytes

-2 bytes thanks to Luis Mendo!

0i:oEqG:EqY"Ysh

Try it online!

Explanation for 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
sumber
2

Ruby, 52 47 bytes

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

Try it online!

Below is the original 52-byte version with an explanation:

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

Try it online!

Walkthrough

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.
sumber
I don't know Ruby - can you explain what this does especially the map(&:-@) portion?
— JayCe
@JayCe Added an explanation. Basically, this is just negation, what in R would be simply -r.
— Kirill L.
Thanks for the explanation - it helped me port this to 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
sumber
1

Charcoal, 19 bytes

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

Try it online! Link is to verbose version of code. Explanation:

  Ｎ                 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 explanation:

Ｆ⊕Ｎ

Loop over the integers from 0 to the input inclusive.

Ｉ

Cast the results to string before printing.

×∨﹪ι²±¹

Negate alternate sets of results.

…·∧ι⁻²ιι

Form a list from the previous index to the current index, excluding the previous index.

— Neil
sumber
1

Jelly,  11  12 bytes

Bah, I thought I had 11 wih _2+ỊrN)N;¥/

_2+ỊrN×-*$)Ẏ

Try it online!

How?

_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
sumber
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
}

This can probably be golfed much better, but I wanted a solution utilizing lazy Streams.

— Ethan
sumber
1

Stacked, 44 bytes

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

Try it online! It's been a while since I programmed in Stacked, but I think I still got it.

Alternatives

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

This goes with the "ranges from generated indices" approach used in my Attache answer. This proved to be pretty long, since Stacked has no builtin for reversed ranges nor collapsing. (That's what :...|>\rev...|>rev#,$#'sortby 1#behead does.)

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

...so I decided to go for an approach which instead finds the cumulative sum (inits$summap) over 1 and -1 repeated by the odd integers, as in the R answer.

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

...but I realized that the negative integers and the odd integers could be made in one go, by multiplying both generated arrays (the mod 2 values of the range and the range itself) by 2 then subtracting 1. This gives alternating 1s and -1s for the first range and the odd integers for the second!

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

... and then I remembered I had a builtin for mapping prefixes. ^-^

— Conor O'Brien
sumber
1

Julia 0.6, 44 bytes

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

Try it online!

Since OP mentions "the output format is flexible", this prints an array of sub arrays, eg. U(3) => [[0, 1], [0, -1, -2, -1], [0, 1, 2, 3]].

i%2*2-1 decides the sign of the current subarray - negative for even numbers, positive for odd.

[0:i;(n>i)*~-i:-1:1] is in two parts. 0:i is straightforward, the range of values from 0 to the current i. In the next part, ~-i:-1:1 is the descending range from i-1 to 1. But we want to append this only if we're not yet at the final value, so multiply the upper end of the range by (n>i) so that when n==i, the range will be 0:-1:1 which ends up empty (so the array stops at n correctly).

And here's a version that can support random access - the inner lambda here returns the i'th term of the sequence without having to have stored any of the terms before it. This one gives the output as a single neat array too.

49 47 bytes

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

Try it online!

— sundar - Reinstate Monica
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.