36

给定N，输出此无限序列的第N个项：

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ... etc.

您可以根据需要将N索引为0或1。

例如，如果0索引然后输入0，1，2，3，4应该产生相应的输出-1，2，-2，1，-3。

如果1索引然后输入1，2，3，4，5应该产生相应的输出-1，2，-2，1，-3。

需要明确的是，该序列是通过将两次重复的正整数序列生成的

1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 ...

并重新排列每对奇数以包围其上方的偶数

1 2 2 1 3 4 4 3 5 6 6 5 7 8 8 7 9 10 10 9 11 12 12 11 ...

最后从第一个词开始否定其他所有词

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ...

以字节为单位的最短代码获胜。

— 卡尔文的爱好
source

A001057没有前导零？

— devRicher

@devRicher不，绝对值1,1,2,2,3,3,4,4,...在这里，但在这里1,2,2,1,3,4,4,3,...。

— Martin Ender

6

你可以为这个序列提供了一个封闭的形式，或者至少东西多一点具体的不仅仅是第一几个术语

— 0“

第n个项的等式永远不会求出负值……这是有问题的。

— Magic Octopus Urn'Mar

1

@ 0'我以直观的方式添加了我的想法，尽管不是封闭形式。挑战的一部分是弄清楚模式是什么以及如何将其转换为数学和代码。

— 加尔文的业余爱好

32

Python 2，23个字节

lambda n:~n/2+n%2*(n|2)

奇数输入大致给出n/2，甚至大致给出-n/2。因此，我-n/2+n%2*n从那里开始并进行了调整。

在线尝试！

— 异或
source

1

说明？:)

— MildlyMilquetoast

17

Mathematica，29个字节

((#~GCD~4/. 4->-2)+#)/2(-1)^#&

纯函数采用1索引输入。除交替符号外(-1)^#，两倍的序列接近输入，周期的差为1、2、1，-2。很好，#~GCD~4输入和的最大公约数4是1，2，1，4循环；因此，我们只是手动更换4->-2并称之为一天。我喜欢这种方法，因为它避免了大多数由多个字符组成的Mathematica命令。

— 格雷格·马丁
source

9

点，24 22字节

v**a*YaBA2|1+:--a//4*2

将1索引的输入作为命令行参数。在线尝试或验证1-20。

说明

请注意，可以通过组合三个其他序列（一个为零索引，另一个为一个索引）来获得该序列：

以0 0 0 0 2 2 2 2 4 4 4 4= a//4*2（0索引）开头；
Add 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1，其中BA按位与，且|为逻辑或（1索引）；
将总和乘以-1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a（1索引）。

如果我们从a1索引的部分开始，我们可以先计算1索引的部分（从左到右读取表达式），然后递减a0索引的部分。使用内置变量v=-1，我们得到

v**a*((aBA2|1)+--a//4*2)

要再剃掉两个字节，我们必须使用一些优先操作技巧。我们可以通过替换+为+:（+=在许多语言中等效）来消除内部括号。任何计算分配运算符的优先级都非常低，因此aBA2|1+:--a//4*2等效于(aBA2|1)+:(--a//4*2)。只有在启用警告的情况下，Pip才会发出有关分配给不是变量的内容的警告。

唯一比更低优先级的:是Yyank运算符。*它将其操作数的值分配给y变量，然后将其不更改地传递；因此我们也可以通过拉动该值而不是将其括在括号中来消除外部括号YaBA2|1+:--a//4*2。

_{* Print和Output的优先级与Yank 相同，但是在这里没有用。}

— DLosc
source

9

果冻，8 7字节

H^Ḃ~N⁸¡

这使用了我的Python答案中的算法，@GB对此算法进行了显着改进。

在线尝试！

怎么运行的

H^Ḃ~N⁸¡  Main link. Argument: n

H        Halve; yield n/2. This returns a float, but ^ will cast it to int.
  Ḃ      Bit; yield n%2.
 ^       Apply bitwise XOR to both results.
   ~     Take the bitwise NOT.
    N⁸¡  Negate the result n times.

— 丹尼斯
source

我认为这是我在Jelly提交中看到的最标准的ASCII字符。我只看到两个让我烦恼的角色（不计算¡

— 在内

google.com/…–

— 丹尼斯（Dennis）

9

Java 8，19字节

n->~(n/2)+n%2*(n|2)

Java 7，47 37字节

int c(int n){return~(n/2)+n%2*(n|2);}

第一次Java（8）实际上竞争，并且比其他一些答案要短。不过，仍然无法击败像Jelly之类的实际高尔夫语言（duhuh ..真是个惊喜。.>>

@Xnor的Python 2 answer中的 0索引
端口。 -10个字节，感谢@GB

在这里尝试。

— 凯文·克鲁伊森
source

2

如果将（n / 2）放在括号中，则不需要三元检查。

— GB

1

@GB啊，那就是问题。.谢谢。我现在有点傻。..>

— Kevin Cruijssen

哦，我们只允许使用Java的函数定义吗？

— Cruncher

@Cruncher除非问题另有说明，否则默认值为完整程序或函数。所以是的，它只允许发布Java中的方法或Java 8中的lambda（我在上面的回答中添加了Java 8等效项）。

— 凯文·克鲁伊森

1

@EricDuminil默认值为program或function，除非挑战另有说明。

— 凯文·克鲁伊森

8

果冻，15 12 11字节

Ḷ^1‘ż@N€Fị@

在线尝试！

怎么运行的

Ḷ^1‘ż@N€Fị@  Main link. Argument: n

Ḷ            Unlength; yield [0, 1, 2, 3, ..., n-1].
 ^1          Bitwise XOR 1; yield [1, 0, 3, 2, ..., n-1^1].
   ‘         Increment; yield [2, 1, 4, 3, ..., (n-1^1)+1].
      N€     Negate each; yield [-1, -2, -3, -4, ..., -n].
    ż@       Zip with swapped arguments; 
             yield [[-1, 2], [-2, 1], [-3, 4], [-4, 3], ..., [-n, (n-1^1)+1]].
        F    Flatten, yield [-1, 2, -2, 1, -3, 4, -4, 3, ..., -n, (n-1^1)+1].
         ị@  At-index with swapped arguments; select the item at index n.

— 丹尼斯
source

我知道在10点左右会有果冻的答案

— Cruncher

在7点还有一个果冻答案；;）

— 丹尼斯（Dennis

发布此评论后，我看到了它。这几天我真的需要学习Jelly ...如果您看一下这个SE上的问题历史，那真是有趣。过去都是GolfScript，后来CJam接手了，现在是Jelly。

— Cruncher

6

RProgN 2，31个 25 22字节

nx=x2÷1x4%{+$-1x^*}#-?

讲解

nx=                         # Convert the input to a number, set x to it.
   x2÷                      # Floor divide x by 2.
      1                     # Place a 1 on the stack.
       x4%{       }#-?      # If x%4 is 0, subtract 1 from x//2, otherwise...
           +                # Add the 1 and the x together.
            $-1             # Push -1
               x^           # To the power of x.
                 *          # Multiply x//2+1 by -1^x. (Invert if odd, do nothing if even)

在线尝试！

— 阿塔科
source

不错的方法！+1

— R. Kap's

6

Ruby，26 23 18字节

->n{~n/2+n%2*n|=2}

从0开始

-3个字节从Greg Martin，Dennis以及其他人那里窃取了-1 ^ n的想法，然后-5个字节从xnor窃取了n | 2的想法。

— 国标
source

5

堆叠，30 28字节

:2%([:2/\4%2=tmo+][1+2/_])\#

在线尝试！返回每个meta共识允许的函数。。从堆栈的顶部获取输入。

使用与RProgN 2答案相同的方法。

或者，为46个字节。在线尝试！：

{!()1[::1+,:rev,\srev\,\2+]n*@.n 1-#n 2%tmo*_}

这个生成范围，然后选择并否定该成员。

— 科纳·奥布莱恩
source

5

Python 2中， 44 33 27个字节

lambda n:(-1)**n*~(n/2^n%2)

感谢@GB打高尔夫球6个字节！

在线尝试！

— 丹尼斯
source

4

05AB1E，8字节

2‰`^±¹F(

在线尝试

说明

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate

— mbomb007
source

哇，我喜欢它，但是¹F(对于“如果是奇数，取反”似乎很昂贵。

— Magic Octopus Urn'Mar

@carusocomputing它可以，但这是我所知道的最短的。Dennis 在Jelly中的类似答案也有3个字节。它仍然比重复，按奇偶校验（如果否定）短。

— mbomb007 '03

我想15分钟，打败它，只有走近了，另3个字节的解决方案的能力的事情 n，给力1/n。

— Magic Octopus Urn'Mar

4

果冻，9 8字节

|2×Ḃ+H~$

在线尝试！

-1感谢丹尼斯。Duh float转换。

使用@xnor的Python 2方法。

编辑：> _>

— 暴民埃里克
source

3

就在您认为自己会赢的时候，丹尼斯会来击败您。

— HyperNeutrino

|2×Ḃ+H~$保存一个字节。tio.run/nexus/jelly#AR0A4v//fDLDl@G4gitIfiT/…–

— 丹尼斯

@丹尼斯，我认为那会吐出一个错误。

— 暴民埃里克（Erik the Outgolfer）'17

3

CJam，16字节

{_(_1&)^2/)W@#*}

基于1的输入。

在线尝试！

说明

这是代码的细分，其中包含从1到的每个输入的堆栈值4。前几个命令仅影响的最低两位，n-1因此4，该内容只是循环重复，结果由于减半而增加了2。

Cmd             Stack: [1]       [2]       [3]       [4]
_    Duplicate.        [1 1]     [2 2]     [3 3]     [4 4]
(    Decrement.        [1 0]     [2 1]     [3 2]     [4 3]
_    Duplicate.        [1 0 0]   [2 1 1]   [3 2 2]   [4 3 3]
1&   AND 1.            [1 0 0]   [2 1 1]   [3 2 0]   [4 3 1]
)    Increment.        [1 0 1]   [2 1 2]   [3 2 1]   [4 3 2]
^    XOR.              [1 1]     [2 3]     [3 3]     [4 1]
2/   Halve.            [1 0]     [2 1]     [3 1]     [4 0]
)    Increment.        [1 1]     [2 2]     [3 2]     [4 1]
W    Push -1.          [1 1 -1]  [2 2 -1]  [3 2 -1]  [4 1 -1]
@    Rotate.           [1 -1 1]  [2 -1 2]  [2 -1 3]  [1 -1 4]
#    -1^n.             [1 -1]    [2 1]     [2 -1]    [1 1]
*    Multiply.         [-1]      [2]       [-2]      [1]

— 马丁·恩德
source

2

Perl 6的， 55个27 24 22字节

{(-1,2,-2,1,{|($^a,$^b,$^c,$^d Z+ -2,2,-2,2)}...*)[$_]}

（受Haskell zipWith答案启发）
尝试一下

{+^($_ div 2)+$_%2*($_+|2)}

（受到几个答案的启发）
尝试一下

{+^($_+>1)+$_%2*($_+|2)}

试试吧

{+^$_+>1+$_%2*($_+|2)}

试试吧

展开：

{  # bare block lambda with implicit parameter ｢$_｣

    +^          # numeric binary invert the following
      $_ +> 1   # numeric bit shift right by one
  +
      $_ % 2    # the input modulo 2
    *
      ($_ +| 2) # numeric binary inclusive or 2
}

（均基于0）

— 布拉德·吉尔伯特b2gills
source

不错的提交！

— CraigR8806

2

Haskell，37 36字节

(([1,3..]>>= \x->[-x,x+1,-x-1,x])!!)

在线尝试！这是一个匿名函数，它以一个数字n作为参数，并返回n序列的第0 个元素，索引为0 。

— 莱科尼
source

1

Haskell，56个字节

f n=concat(iterate(zipWith(+)[-2,2,-2,2])[-1,2,-2,1])!!n

0索引

— 布莱克斯
source

1

Perl 5 47 +1（用于标志）= 48字节

print(((sin$_%4>.5)+1+2*int$_/4)*($_%4&1?1:-1))

旧提交82字节

@f=(sub{-$_[0]},sub{$_[0]+1},sub{-$_[0]-1},sub{$_[0]});print$f[$_%4](1+2*int$_/4)

像这样运行：

perl -n <name of file storing script>  <<<  n

— 克雷格R8806
source

您可以通过使用print +((和删除final 来节省一个字节)。还有两个通过使用say和-E。而且还可以通过($_%4&1||-1)三元组代替。

— simbabque

1

JavaScript（ES7），28个字节

n=>(n+2>>2)*2*(-1)**n-!(n&2)

1个索引。我还没有看其他答案，所以我不知道这是否是最好的算法，但我怀疑不是。

— ETH生产
source

1

JavaScript，28 22字节

感谢@ETHproductions打高尔夫球6个字节

x=>x%2?~x>>1:x%4+x/2-1

在线尝试！

— fəˈnɛtɪk
source

嗯... f=x=>x%2?~x>>1:x/2+x%4-1行得通吗？

— ETHproductions

由于某种原因，我将f =留在了匿名函数的前面：P

— fəˈnɛtɪk

1

直流，98字节

?sa0sb1sq[lq1+dsqla!<i3Q]sf[lb1-lfx]su[lblfx]sx[lb1+dsblfx]sj[lqdd4%d0=u1=j2%1=xljxlfx]dsix_1la^*p

天哪，这是最长的答案，主要是因为我根据以下递归公式逐一生成了序列中每个元素的绝对值：

然后输出(-1)^n * a_n，而不是直接计算n'th元素。无论如何，这是1索引的。

在线尝试！

— 卡普
source

1

R，38个字节

function(n)floor(n/2+1-2*!n%%4)*(-1)^n

说明

floor(n/2+1)                ->  1 2  2 3  3 4  4 5...
floor(n/2+1-2*!n%%4)        ->  1 2  2 1  3 4  4 3... (subtract 2 where n%%4 == 0)
floor(n/2+1-2*!n%%4)*(-1)^n -> -1 2 -2 1 -3 4 -4 3... (multiply odd n by -1)

— 用户名
source

1

TI-Basic（TI-84 Plus CE），31个字节

.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))i^(2Ans

TI-Basic是一种令牌化语言，此处使用的每个令牌均为一个字节，但除外remainder(，该字节为2。

这使用1索引版本。

说明：

有一种模式是每四个数字重复一次。在1索引版本中，输入值x为-（x + 1）/ 2，（x + 1）/ 2，-（x + 1）/ 2，（x-1）/ 2。这可以表示为分段定义的函数。

如果x≡1 mod 4，则f（x）=-（x + 1）/ 2; （x + 1）/ 2如果x≡2 mod 4; -（x + 1）/ 2如果x≡3 mod 4; 如果x≡0 mod 4（x-1）/ 2

因为“ x≡1 mod 4”和“ x≡3 mod 4”部分相同，所以我们可以将它们组合为“ x≡1 mod 2”。

现在是分段功能是：

如果x≡1 mod 2，则f（x）=-（x + 1）/ 2; （x + 2）/ 2如果x≡2 mod 4; （x-2）/ 2如果x 0 mod 4

这是我开始将其分解为实际命令的地方。由于该值对于偶数索引为正，而对于奇数索引为负，因此我们可以使用（-1）^ x。但是，在TI-Basic中，i^(2X（5个字节）比(-1)^Ans（6个字节）短。请注意，由于操作顺序，必须加上括号。

现在我们已经可以消除奇数输入了，现在我们进入mods（稍后再添加否定）。我将奇数输入的情况设为默认，因此我们从开始.5(Ans+1)。

要解决偶数输入的情况，只需在括号中的数字上加一个，但仅当x≡0 mod 2时才可以。这可以表示为.5(Ans+1+remainder(Ans+1,2))或.5(Ans+1+not(remainder(Ans,2)))，但是它们具有相同的字节数，因此这无关紧要。

要修正4的倍数输入的情况，我们需要从括号中的数字中减去3，还要减去1，因为4的所有倍数都是偶数，这将在上一步中加一个，所以现在有了.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))。

现在，只需将符号确定部分拖到最后即可获得完整程序。

— 比萨184
source

0

Befunge 93，25个字节

零索引

&4/2*1+&4%3%!!+&2%2*1-*.@

在线尝试！

该数字由 ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

— 轻度吐司
source

0

QBIC，53个字节

b=1:{[b,b+3|~b=a|_x(-(b%2)*2+1)*(q+(b%4>1)*-1)]]q=q+2

说明：

b=1     Set b to a starting value of 1
        QBIC would usually use the pre-initialised variable q, but that is already in use
:       Get an input number from the cmd-line, our term to find
{       Start an infinite loop
[b,b+3| FOR-loop: this runs in groups of 4, incrementing its own bounds between runs
~b=a|   If we've reached the term requested
_x      QUIT the program and print:

(-(b%2)*2+1)   The b%2 gives a 1 or a 0, times 2 (2,0), negged (-2,0) and plus one (-1,1)
*              That gives us the sign of our term. Now the value:
(q+(b%4>1)*-1) This is q + 1 if the inner loop counter MOD 4 (1,2,3,0...) is 2 or 3.
]       Close the IF that checks the term
]       Close the FOR-loop
q=q+2   And raise q by 2 for the next iteration of the DO-loop.

— 施滕伯格
source

0

明智的 19字节

::>!:><^^~![!-!-~]|

在线尝试！

这只是@Dennis对Wise 的果冻答案的端口。

— 轻度吐司
source

0

Q，52个字节

{(1 rotate(,/){x,(-)x}each 1_((_)x%4)+til 3)x mod 4}

0索引解决方案。

获取块号，即。序列中的[-x x + 1-（x + 1）x]块包含索引。
根据整个序列中值的索引获取块内值的索引。
创建块。
通过步骤2中导出的索引对其进行索引。

— 丹尼尔·普兰维尤
source

奇数偶数，正负数

Python 2，23个字节

Mathematica，29个字节

点，24 22字节

说明

果冻，8 7字节

怎么运行的

Java 8，19字节

Java 7，47 37字节

果冻，15 12 11字节

怎么运行的

RProgN 2，31个 25 22字节

讲解

Ruby，26 23 18字节

堆叠，30 28字节

Python 2中， 44 33 27个字节

05AB1E，8字节

果冻，9 8字节

CJam，16字节

说明

Perl 6的， 55个27 24 22字节

展开：

Haskell，37 36字节

Haskell，56个字节

Perl 5 47 +1（用于标志）= 48字节

旧提交82字节

JavaScript（ES7），28个字节

JavaScript，28 22字节

直流，98字节

R，38个字节

TI-Basic（TI-84 Plus CE），31个字节

Befunge 93，25个字节

QBIC，53个字节

明智的 19字节

Q，52个字节