我们都知道，很多运动只影响身体的一半，因此您必须做两次，每一侧一次。这种练习有两个对应项，一个对应左侧，一个对应右侧。但是，只要双方的练习顺序相同，就不必连续执行两个对应的任务。您也可以在锻炼程序中在两边之间进行切换，但是从一侧开始进行一些练习而从另一侧开始进行一些练习则没有意义。

挑战

一个运动部分是非零整数，其中其第二部分包含否定了上半年的整数，并以相同的顺序列表，并在每个半整数的迹象是相等的。练习部分上半部分的标志是其领先的一面。

一个锻炼组是连接在一起的同一侧领先零个或多个运动部件。

给定一个非零整数列表作为输入，请确定它是否为练习集。整数不一定是唯一的。列表的长度不一定是偶数。

您的解决方案可能不使用任何标准漏洞。您可以使用任何两个不同的一致值进行输出。这是代码高尔夫球，因此最短的解决方案是成功的。

例子

[-5, -1, -7, -6, -5, 5, 1, 7, 6, 5]是运动部分的一个例子。前半部分是[-5, -1, -7, -6, -5]，后半部分是[5, 1, 7, 6, 5]，这是上半部分取反的每个整数。此外，前半部分的整数都是相同的符号。本练习部分的主要内容是-1。

[3, 6, 5, -3, -6, -5, 1, 6, 4, 3, -1, -6, -4, -3]是练习集的一个例子。它的各个运动部分分别是[3, 6, 5, -3, -6, -5]和[1, 6, 4, 3, -1, -6, -4, -3]，并且都具有领先优势1。

[4, -4, -5, 5]尽管仅由有效的练习部分组成，但它不是练习集，因为第一部分[4, -4]具有领先优势1，而第二部分[-5, 5]具有领先优势-1。

测试用例

有效的测试用例：

[]
[1, -1]
[1, -1, 1, -1]
[-6, 6, -5, -4, -3, 5, 4, 3]
[-1, -5, -8, 1, 5, 8, -7, -6, -5, -3, 7, 6, 5, 3]
[-1, -5, -8, 1, 5, 8, -1, 1]

无效的测试用例：

[1]
[1, -2]
[1, 2, -3, -1, -2, 3]
[1, 2, 3, -3, -1, -2]
[-1, -5, -8, 1, 5, 8, 7, 6, 5, 3, -7, -6, -5, -3]
[1, 2, 3, 5, 1, 2, 3, 5]
[1, 2, -5, 4, -6, 5, 5, -6]
[1, 2, -1, 3, -2, -3]
[1, -2, 1]
[-1, -1, 1]
[1, -1, 1]

Python 2中，69个 67字节

a,b=x=[[],[]];k=0
for n in input():x[n>0]+=n*n,n*k>0;k=n
print a==b

在线尝试！

果冻，10字节

ṁṠŒg$+2/FẸ

在线尝试！

Java的8，186个 183 185字节

a->{int i=a.length-1,t,j;boolean r=i%2>0,f;if(i<0)return!r;for(f=a[i]<0;i>0;){for(r&=f==(t=a[j=i])<0;j>0&&t>>>31==a[--j]>>>31;);for(t=i-j,i-=2*t;j>=0&j>i;)r&=a[j+t]==-a[j--];}return r;}

由于错误修复了大小为3的测试用例（几乎所有TIO链接的所有排列1和-1在TIO链接的末尾），因此+2字节。

绝对可以打高尔夫球。挑战看起来很关键，但是很难实现。特别是测试用例[4,-4,-5,5]很烦人。.但是现在可以用了。从这里打高尔夫。

在线尝试。

说明：

a->{                   // Method with integer-array parameter and boolean return-type
  int i=a.length-1,j,  //  Index integers (`i` starting at the last index)
      t;               //  Temp integer
  boolean r=i%2>0,     //  Result-boolean, starting at true if the input-list is even
          f;           //  Flag-integer
  if(i<0)              //  If the input was empty (edge case)
    return!r;          //   Return true
  for(f=a[i]<0;        //  Set the flag-boolean to "Is the current item negative?"
      i>0;){           //  Loop down over the array
    for(r&=f==(t=a[j=i])<0;
                       //   Set `s` to the current number
                       //   And verify if the initial flag and `s` have the same sign
        j>0            //   Loop `j` from `i` down as long as `j` is larger than 0,
        &&t>>>31==a[--j]>>>31;);
                       //   and both `s` and the current item have the same sign
                       //    Decreasing `j` by 1 every iteration
    for(t=i-j,         //   Set `t` to `i-j` (amount of same signed adjacent values)
        i-=2*t;        //   Decrease `i` by two times `t`
        j>=0           //   Loop as long as `j` is larger than or equal to 0,
        &j>i;)         //   and also larger than `i`
      r&=a[j+t]==-a[j--];}
                       //    Verify if the pairs at index `j+t` and `j`
                       //    are negatives of each other
  return r;}           //  Return if `r` is still true (if all verifications succeeded)

[R，91字节

输入数字的空格分隔向量。输出FALSE有效和TRUE无效。

x=scan()
y=x<0
z=rle(y)
"if"(sum(x|1),any(x[y]+x[!y],z$v==rev(z$v),z$l[!0:1]-z$l[!1:0]),F)

rle 给出游程长度编码，在这种情况下为正值和负值的序列。

的完全和完全不公平空边缘情况下）增加了高达15个字节。

@Giuseppe删除了许多字节。

这是一个92字节的版本，表示为更好地进行测试的功能：

在线尝试！

JavaScript（ES6），54个字节

优化版本，受Dennis的Python答案启发。

返回0或1。

a=>a.map(b=p=x=>b[+(x<0)]+=[x*x,p*(p=x)>0])|b[1]==b[0]

在线尝试！

原始版本，74字节

a=>a.map(x=>b[i^=p*(p=x)<0&&-~(b[i]+=0)]+=[,x*x],b=[p=0,i=0])|b[1]+0==b[0]

在线尝试！

怎么样？

我们将所有运动部分的前半部分存储在b [0]中，将后半部分存储在b [1]中，每次符号变化时在b [0]和b [1]之间切换。条目被平方以消除符号。我们在每个条目前面加上逗号，并在每个部分后缀0。

还有一些额外的逻辑可以免费处理“空输入”边缘情况（请参阅源代码结尾处的注释）。

a =>                    // given the input array a[]
  a.map(x =>            // for each x in a[]:
    b[i ^=              //   access b[i]:
      p * (p = x)       //     we keep track of the previous entry in p
      < 0 &&            //     if p and x have opposite signs:
      -~(b[i] += 0)     //       append a '0' to b[i] and update i: 0 -> 1, 1 -> 0
    ] += [, x * x],     //   append a comma followed by x² to b[i]
    b = [p = 0, i = 0]  //   start with p = 0, i = 0 and b = [0, 0]
  ) |                   // end of map()
  b[1] + 0              // this will append a '0' to b[1] if it was turned into a string
                        // or let it unchanged if it's still equal to zero (integer),
                        // which handles the 'empty input' edge case
  == b[0]               // compare the result with b[0]

Python 2中，147个 130 113 112 106字节

from itertools import*
def f(s):l=[map(abs,g)for v,g in groupby(s+[0],0 .__cmp__)];print l[1::2]==l[:-1:2]

在线尝试！

已保存：

• -27字节，感谢丹尼斯

视网膜0.8.2，57字节

^\b|,\b
$&=
(.)(\d+),(?=\1)
$2_
-|=

.$
$&,
^((\w+,)\2)*$

在线尝试！接受逗号分隔的输入，但链接包含用于处理测试用例的标头。说明：

^\b|,\b
$&=

在每个正整数之前插入一个标记。

(.)(\d+),(?=\1)
$2_

将相同符号的整数之间的逗号更改为下划线。

-|=

删除其余标志。

.$
$&,

如果输入不为空，请添加逗号。

^((\w+,)\2)*$

检查字符串是否由成对的相同整数组成。

Python 2，111字节

x=input()
o=[];p=[]
for a,b in zip(x,x[1:]):
 if 0<a*x[0]:
	p+=a,-a
	if b*a<0:o+=p[::2]+p[1::2];p=[]
print o==x

在线尝试！

JavaScript（Node.js），155个字节

b=>eval('i=b.length-1;r=i%2;0>i&&!r;for(f=0>b[i];0<i;){for(r&=f==(s=0>b[j=i]);0<j&&s&0>b[--j]|!s&0<b[j];);t=i-j;for(i-=2*t;0<=j&j>i;)r&=b[j+t]==-b[j--]}r')

在线尝试！

灵感来自@KevinCruijssen

也感谢他纠正了我的2个测试用例

Stax，13 个字节

Ç¥├W╦╣∩T~≥▌╨c

运行并调试

Brachylog，18 14字节

~c{ḍz{ṅᵈ¹ṡ}ᵛ}ᵛ

在线尝试！

@ErikTheOutgolfer节省了4个字节。

说明

                    Succeed if and only if:
~c                  You can deconcatenate the input list…
  {         }ᵛ      …and verify that for each of the sublists:
   ḍ                  Split it in half
    z                 Zip the elements of each half together
     {    }ᵛ          Verify that for each couple:
      ṅᵈ¹               The first integer is the negation of the second one
         ṡ              Take the sign of the first one
                      All signs should be equal in a sublist
                    All leading signs of the sublists should be equal

APL（Dyalog Classic），48字节

{0::1⋄0≠+/ר⍵:0⋄(~0∊⊢∨2|⍳∘⍴)2{⍺≡-⍵}/⍵⊂⍨1,2≠/ר⍵}

在线尝试！