Chúng ta đều biết rằng rất nhiều bài tập chỉ ảnh hưởng đến một nửa cơ thể của bạn, vì vậy bạn phải thực hiện chúng hai lần, một lần cho mỗi bên. Các bài tập như vậy có hai đối tác, một cho bên trái và một cho bên phải. Tuy nhiên, không cần phải thực hiện hai đối tác liên tiếp, miễn là các bài tập cho cả hai bên theo cùng một thứ tự. Bạn cũng có thể chuyển đổi giữa các bên trong chương trình tập thể dục của mình, nhưng sẽ không có ý nghĩa khi bắt đầu một số bài tập với một bên và một số với bên kia.

Thử thách

Một phần bài tập là một danh sách các số nguyên khác không, trong đó nửa thứ hai của nó bao gồm các số nguyên của nửa đầu được phủ định và theo cùng một thứ tự, và các dấu của các số nguyên trên mỗi nửa bằng nhau. Dấu hiệu của nửa đầu của một phần tập thể dục là mặt hàng đầu của nó .

Một bộ bài tập là 0 hoặc nhiều phần bài tập với cùng một mặt dẫn được nối với nhau.

Đưa ra một danh sách các số nguyên khác không làm đầu vào, xác định xem đó có phải là tập bài tập không. Các số nguyên không nhất thiết phải là duy nhất. Độ dài của danh sách không nhất thiết là thậm chí.

Giải pháp của bạn có thể không sử dụng bất kỳ sơ hở tiêu chuẩn . Bạn có thể sử dụng bất kỳ hai giá trị nhất quán khác nhau cho đầu ra. Đây là môn đánh gôn , vì vậy giải pháp ngắn nhất sẽ thắng.

Ví dụ

[-5, -1, -7, -6, -5, 5, 1, 7, 6, 5]là một ví dụ về một phần bài tập. Nửa đầu là [-5, -1, -7, -6, -5]và nửa cuối là [5, 1, 7, 6, 5], mỗi số nguyên trong nửa đầu bị phủ định. Ngoài ra, số nguyên của nửa đầu là tất cả cùng một dấu hiệu. Phần hàng đầu của bài tập này là -1.

[3, 6, 5, -3, -6, -5, 1, 6, 4, 3, -1, -6, -4, -3]là một ví dụ về một bộ bài tập. Phần bài tập cá nhân của nó là [3, 6, 5, -3, -6, -5]và [1, 6, 4, 3, -1, -6, -4, -3], và cả hai đều có mặt hàng đầu 1.

[4, -4, -5, 5], mặc dù chỉ bao gồm các phần bài tập hợp lệ, không phải là một bộ bài tập, vì phần thứ nhất [4, -4], có phần dẫn đầu 1, trong khi phần thứ hai [-5, 5], có phần dẫn đầu -1.

Các trường hợp thử nghiệm

Các trường hợp kiểm tra hợp lệ:

[]
[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]

Các trường hợp kiểm tra không hợp lệ:

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

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

Hãy thử trực tuyến!

Thạch , 10 byte

ṁṠŒg$+2/FẸ

Hãy thử trực tuyến!

Java 8, 186 183 185 byte

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

+2 byte do sửa lỗi cho các trường hợp thử nghiệm có kích thước 3 (gần như tất cả các hoán vị của 1và-1 ở cuối liên kết TIO của tôi).

Chắc chắn có thể chơi gôn .. Thử thách có vẻ rất quan trọng, nhưng nó khá khó để thực hiện. Đặc biệt là trường hợp thử nghiệm[4,-4,-5,5] đã gây khó chịu để sửa chữa .. Nhưng nó hoạt động ngay bây giờ. Sẽ đánh gôn từ đây.

Hãy thử trực tuyến.

Giải trình:

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 byte

Nhập một vectơ phân tách khoảng trắng. Đầu ra FALSEhợp lệ và TRUEkhông hợp lệ.

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 đưa ra mã hóa độ dài chạy, trong trường hợp này là chuỗi các giá trị dương và âm.

Các trường hợp cạnh trống hoàn toàn và hoàn toàn không công bằng;) cho biết thêm một con số khổng lồ 15 byte.

Nhiều byte bị loại bỏ bởi @Giuseppe.

Đây là phiên bản 92 byte được biểu thị dưới dạng hàm tốt hơn để kiểm tra:

Hãy thử trực tuyến!

JavaScript (ES6), 54 byte

Phiên bản tối ưu hóa, lấy cảm hứng từ câu trả lời Python của Dennis .

Trả về 0 hoặc 1 .

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

Hãy thử trực tuyến!

Phiên bản gốc, 74 byte

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]

Hãy thử trực tuyến!

Làm sao?

Chúng tôi lưu trữ nửa đầu của tất cả các phần bài tập trong b [0] và nửa thứ hai trong b [1] , chuyển đổi giữa b [0] và b [1] mỗi khi dấu hiệu thay đổi. Các mục được bình phương để thoát khỏi các dấu hiệu. Chúng tôi tiền tố mỗi mục nhập bằng dấu phẩy và hậu tố mỗi phần bằng 0 .

Có một số logic bổ sung để xử lý trường hợp cạnh 'đầu vào trống' về cơ bản miễn phí (xem bình luận gần cuối mã nguồn).

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 byte

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]

Hãy thử trực tuyến!

Đã lưu:

• -27 byte, nhờ Dennis

Võng mạc 0.8.2 , 57 byte

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

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

Hãy thử trực tuyến! Có đầu vào được phân tách bằng dấu phẩy, nhưng liên kết bao gồm tiêu đề xử lý các trường hợp thử nghiệm. Giải trình:

^\b|,\b
$&=

Chèn một điểm đánh dấu trước mỗi số nguyên dương.

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

Thay đổi dấu phẩy giữa các số nguyên của cùng một dấu thành dấu gạch dưới.

-|=

Xóa các dấu hiệu còn lại.

.$
$&,

Nối một dấu phẩy nếu đầu vào không trống.

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

Kiểm tra xem chuỗi bao gồm các cặp chạy của cùng một số nguyên.

Python 2 , 111 byte

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 155 byte

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')

Hãy thử trực tuyến!

Cảm hứng là câu trả lời của @ KevinCruijssen

Cũng cảm ơn anh ấy đã sửa 2 trường hợp kiểm tra của tôi

Stax , 13 byte

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

Chạy và gỡ lỗi nó

Brachylog , 18 14 byte

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

Hãy thử trực tuyến!

Đã lưu 4 byte nhờ @ErikTheOutgolfer.

Giải trình

                    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 byte

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

Hãy thử trực tuyến!