上下上下

34

挑战：

给定正整数输入n，创建一个遵循此模式的向量：

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

或者用词来解释：向量从处开始0，递增1直到它达到不属于序列的最小奇数正整数，然后递减直到它达到最小（幅度）甚至是负整数。不是序列的一部分。它以这种方式继续直到n到达。该序列将在正端n，如果n是奇数，阴性n，如果n是偶数。

输出格式灵活。

测试用例：

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

您可以选择采用n个零索引。n = 1然后会给0 1 0 -1 -2。

这是代码高尔夫球，因此每种语言中最短的代码胜出！一如既往地鼓励您进行解释！

code-golf  sequence  integer 
— 斯蒂夫·格里芬
source
2
相关：OEIS A196199。
— Xcoder先生18年

Answers:

10

R，58 54 50 48 43字节

-2个字节，感谢MickyT

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

在线尝试！

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

— 朱塞佩
source
8

Perl 6的， 60  26个字节

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

试试吧

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

试试吧

展开：

{  # 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..$_ 产生序列 0 1 -2 3 -4 5

— 布拉德·吉尔伯特b2gills
source
7

Python 2中，69个 57 56字节

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

在线尝试！

对于每一个n 到input所述range(-n,n)（含）的计算，在倒置时n是偶数，有拳头两个数字（反转之后）除去，然后附加到输出。

— 竿
source
7

05AB1E，9 7字节

@Emigna节省了2个字节

Ýā®sm*Ÿ

在线尝试！

我的第一个05AB1E答案（我认为），所以我可能缺少一些窍门...

说明

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

我必须感谢@Dennis 的原始用法Ÿ，否则我可能永远不会知道...

— ETH生产
source
不错:)！我ÝεDÈi®*}}Ÿ没有检查，ā®sm是疯狂的聪明哈哈。
— 魔术章鱼缸
6

05AB1E，15 14字节

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

在线尝试！

说明

Ý                # 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
— 艾米尼亚
source
6

JavaScript（ES6），56个字节

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

在线尝试！

已评论

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

Haskell，43个字节

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

在线尝试！

计算list的取反的累加和，即list [(-1)^k|k<-[1..n],_<-[2..2*k]]的第一n行

[-1,
 +1, +1, +1,
 -1, -1, -1, -1, -1,
 +1, +1, +1, +1, +1, +1, +1…
— 林恩
source
6

果冻，11 9字节

²Ḷƽ-*0;Ä

在线尝试！

怎么运行的

²Ḷƽ-*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.
— 丹尼斯
source
6

Haskell，48 42字节

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

在线尝试！

多亏了ous为-1个字节

尽管事后看来很明显，但我还是花了一段时间才得出(-1)^i*x什么x时候i是偶数，-x什么时候i是奇数。先前的迭代，其中：

(-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
— 莱科尼
source
1
您可以通过在表达式中使用1-i代替来保存字节。-i+1..
— 很好
4

C＃（.NET核心），300个  167字节

我以前从未做过任何事情，但是这个看起来很有趣。我知道为什么人们使用“打高尔夫球”语言，因为167似乎比其他一些答案要高得多。但是，您必须去了解您所知道的。

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

在线尝试！

// 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）
source
1
如果仅对using语句和函数进行计数，则可以使此操作更短。除非挑战指定它必须是完整程序，否则默认情况下允许这样做（即使确实如此，您也可以缩短包含的类名）。
— 世纪
谢谢！感谢您的建议，我弄清了TIO网站“页眉”和“页脚”部分的含义。这使我的提交大小减少了一半！
— Darrin Cullop
2
欢迎来到PPCG！（这看起来像是您的第一篇文章。）不用担心其他语言，只需尝试使用您的语言尽可能地做到最好。/提示：删除不必要的空格。在C＃中，您可以删除符号（[](){};.）周围的所有空格(n-1)*2，2*n-2并且可以进行一些重新排列以删除括号。
— user202729
此外，!=优先级小于，%因此您可以删除一对括号。并且您可以使用>0而不是`！= 0来保存一个字节。
— user202729
1
同样来自我：欢迎来到PPCG！阅读C＃和所有语言的高尔夫技巧可能会很有趣。:)至于一些打高尔夫球的技巧：static int[] f(int n)可以f=n=>通过使用（递归）lambda来实现，并且(n-1)*2可以~-n*2节省括号。我将其减少到155（137 + 18）字节：在线尝试。18个字节用于using System.Linq;，因为必需的导入对于字节数是必需的。入住愉快！
— 凯文·克鲁伊森
4

J，25个字节

-5个字节，感谢FrownyFrog！ 

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

在线尝试！

J，30个字节

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

说明：

i.,] 创建列表0..n

&.> 为列表中的每个数字执行（...）中的动词并将结果装箱（我需要装箱，因为结果的长度不同）

[:( _1&^)求-1的i幂（-1或1）

i:@* 根据上面的符号列出-n..n或n ..- n

;@ 拆箱

>:@*: 找出n ^ 2 + 1

}. 并从列表中取出这么多数字

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source
1
您会考虑编写与从零开始的n版本相同的代码吗？例如*:{.;@([:(i:@*_1&^)&.>i.)..规范允许
— jayprich
“ n = 1会给0 1 0 -1 -2”
— FrownyFrog，
@FrownyFrog-嗯，我没有检查。我恢复了第一个解决方案。谢谢您的观察！
— Galen Ivanov '18
1
25 使用$的截止，没有必要&.>因为*是等级0。
— FrownyFrog
3

Java 8，85 83 79字节

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

-6个字节，感谢@OlivierGrégoire。

在线尝试。

说明：

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
— 凯文·克鲁伊森
source
好的方法。我现在正在研究这种方法，以改善答案，但是您却击败了我（尽管会见了），做得很好！;-)
— OlivierGrégoire18年
1
83个字节（我刚刚删除了j）。
— 奥利维尔·格雷戈尔（OlivierGrégoire）'18年
1
79字节：我做i了上移而不是下移以删除冗余n*n。
— 奥利维尔·格雷戈尔（OlivierGrégoire）'18年
你好 写这封信是为了告诉您，我基本上已经把您的答案扯掉了。（移植到JavaScript）。希望一切都好
— 穆罕默德·萨尔曼
@MuhammadSalman当然，np。我也经常从别人那里得到答案。:)只要提到原始答案，就像您所做的那样，对我来说一切都很好。
— 凯文·克鲁伊森
3

R，48 46 42字节

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

在线尝试！

Kirill L. 的Ruby答案的端口-由于同一个Kirill L.节省了6个字节！现在比朱塞佩的解决方案还短;）

路易斯·门多（Luis Mendo）使用此八度音阶答案的端口approx不太像高尔夫球。n=n^2+1可以被代替,,n^2+1; 或按 0:n^2+1（位置参数xout）表示相同的字节数：

R，56个字节

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

在线尝试！

— 杰西
source
我认为它approx在这里的工作方式也与Luis Mendo的Octave解决方案类似。
— 朱塞佩
@Giuseppe谢谢！它虽然更长，但确实可以工作。我已经学会了diffinv和approx来自这个问题...
— JayCe
尽管我也不知道用高尔夫球手做-1幂的方法（在R中，~它不能作为补码运算符:(）起作用，但是您仍然可以通过切换到完整程序来节省另外2个字节。）
— Kirill L.
...并且由于它是一个完整的程序，我们还可以使用和破坏预定义的内置文件：42个字节 -最后，比朱塞佩的短！
— Kirill L.
3

APL（Dyalog Unicode），17个字节

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

在线尝试！

@FrownyFrog通过转换为火车来打高尔夫球了2个字节。请参阅下面的旧答案及其解释。

APL（Dyalog Unicode），19个字节

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

在线尝试！

（用途⎕IO←0）

我的第一种方法是构造多个范围并将它们连接在一起，这很容易超过30个字节。然后我开始分析序列

      +\⍣¯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 表示逆累积和

有一个1s和¯1s的重复模式，其中每个连续的1s或¯1s序列的长度为1 + 2×n。每个子序列在1和1之间交替。我现在可以做的是创建1和1列表，然后按+进行扫描

      ⍳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）
source
现在检查其他答案，我看到许多人也使用+ \方法，但是生成的1和1的序列与1 *⌊.5*⍨×⍨⍳差不多短了至少3个字节。
— Kritixi Lithos
+\0,¯1*⍳(/⍨)1+2×⍳是17
— FrownyFrog
我知道我的解决方案感到长
— 扎卡里
2

MATL，17 15字节

-2个字节感谢Luis Mendo！

0i:oEqG:EqY"Ysh

在线尝试！

解释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
— 朱塞佩
source
2

红宝石，52 47字节

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

在线尝试！

以下是原始的52字节版本，并带有说明：

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

在线尝试！

演练

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
}
— 基里尔
source
我不了解Ruby-您能解释一下这map(&:-@)部分功能吗？
— JayCe
@JayCe添加了解释。基本上，这只是个否定，R中的内容将很简单-r。
— Kirill L.
感谢您的解释-它帮助我将其移植到
— R。– JayCe
1

Python 3，83个字节

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
source
1

木炭，19字节

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

在线尝试！链接是详细版本的代码。说明：

  Ｎ                 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

替代说明：

Ｆ⊕Ｎ

将整数从循环0到输入端（含）。

Ｉ

在打印之前将结果转换为字符串。

×∨﹪ι²±¹

否定备用结果集。

…·∧ι⁻²ιι

形成一个从前一个索引到当前索引的列表，不包括前一个索引。

— 尼尔
source
1

果冻， 11  12 字节

ah，我以为我有11周岁 _2+ỊrN)N;¥/

_2+ỊrN×-*$)Ẏ

在线尝试！

怎么样？

_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]
— 乔纳森·艾伦
source
1

Scala，119字节

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}

取消高尔夫：

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
}

这也许可以打得更好，但是我想要一个利用延迟流的解决方案。

— 伊森
source
1

堆叠式，44位元组

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

在线尝试！自从我用Stacked编程以来已经有一段时间了，但我认为我仍然可以做到。

备择方案

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

这与我的附加答案中使用的“生成索引的范围”方法一致。事实证明，这很长，因为Stacked没有内置可逆范围，也不会崩溃。（就是:...|>\rev...|>rev#,$#'sortby 1#behead这样。）

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

...所以我决定采用一种方法，代替R答案，在奇数整数上查找并重复累积和（inits$summap）。1-1

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

...但是我意识到，可以通过将两个生成的数组（范围的mod 2值和范围本身的值）相乘然后减去，来一次性生成负整数和奇数整数。这样就可以在第一个范围内交替显示s和s，在第二个范围内给出奇数整数！211-1

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

...然后我记得我有一个内置的映射前缀。^-^

— 科纳·奥布莱恩
source
1

朱莉娅0.6，44字节

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

在线尝试！

由于OP提到“输出格式是灵活的”，因此将打印子数组的数组，例如。U（3）=> [[0, 1], [0, -1, -2, -1], [0, 1, 2, 3]]。

i%2*2-1 决定当前子数组的符号-偶数为负，奇数为正。

[0:i;(n>i)*~-i:-1:1]分两部分。0：i很简单，取值范围是从0到当前i。在下一部分中，〜-i：-1：1是从i-1到1的下降范围。但是，我们仅在尚未达到最终值时才想附加此值，因此将范围的上限乘以（n> i），因此当n == i时，范围将为0：-1：1，最终为空（因此数组正确地在n处停止）。

这是一个可以支持随机访问的版本-此处的内部lambda返回序列的第i个项，而不必在其之前存储任何项。这也将输出作为单个整齐的数组提供。

49 47字节

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

在线尝试！

— sundar-恢复莫妮卡
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.