เราทุกคนรู้ว่าการออกกำลังกายจำนวนมากมีผลกับร่างกายคุณเพียงครึ่งเดียวดังนั้นคุณต้องทำสองครั้งครั้งละข้าง แบบฝึกหัดดังกล่าวมีสองแบบหนึ่งแบบด้านซ้ายและแบบฝึกหัดด้านขวา อย่างไรก็ตามไม่จำเป็นที่จะต้องดำเนินการทั้งสองอย่างต่อเนื่องตราบใดที่แบบฝึกหัดของทั้งสองฝ่ายอยู่ในลำดับเดียวกัน คุณอาจสลับไปมาระหว่างด้านต่าง ๆ ในโปรแกรมการออกกำลังกายของคุณได้ แต่มันก็ไม่มีเหตุผลที่จะเริ่มต้นการออกกำลังกายด้วยด้านใดด้านหนึ่งและด้านอื่น ๆ

ท้าทาย

ส่วนการออกกำลังกายคือรายการที่ไม่ใช่ศูนย์จำนวนเต็มที่ครึ่งหลังประกอบด้วยจำนวนเต็มของครึ่งแรกเมื่อตะกี้และในลำดับเดียวกันและสัญญาณของจำนวนเต็มในแต่ละครึ่งปีที่มีค่าเท่ากัน เข้าสู่ระบบในช่วงครึ่งแรกของการออกกำลังกายเป็นส่วนหนึ่งของมันด้านชั้นนำ

ชุดออกกำลังกายเป็นศูนย์หรือออกกำลังกายมากขึ้นกับชิ้นส่วนชั้นนำด้านเดียวกันตัดแบ่งกัน

รับรายการของเลขจำนวนเต็มที่ไม่ใช่ศูนย์เป็นอินพุตให้พิจารณาว่าเป็นชุดการออกกำลังกายหรือไม่ จำนวนเต็มไม่จำเป็นต้องซ้ำกัน ความยาวของรายการไม่จำเป็นต้องเท่ากับ

วิธีการแก้ปัญหาของคุณอาจไม่ใช้ใด ๆ ของช่องโหว่มาตรฐาน คุณสามารถใช้ค่าที่สอดคล้องกันสองค่าสำหรับเอาต์พุต นี่คือรหัสกอล์ฟดังนั้นทางออกที่สั้นที่สุดชนะ

ตัวอย่าง

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

+2 ไบต์เนื่องจากการแก้ไขข้อบกพร่องสำหรับกรณีทดสอบขนาด 3 (พีชคณิตเกือบทั้งหมดของ1และ-1ในตอนท้ายของ TIO-link ของฉัน)

สามารถเล่นกอล์ฟได้แน่นอน .. ความท้าทายดูเป็นประเด็น แต่ก็ยากที่จะนำไปปฏิบัติ โดยเฉพาะอย่างยิ่งกรณีทดสอบ[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 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{ṅᵈ¹ṡ}ᵛ}ᵛ

ลองออนไลน์!

บันทึกแล้ว 4 ไบต์ขอบคุณ @ErikTheOutgolfer

คำอธิบาย

                    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≠/ר⍵}

ลองออนไลน์!