우리는 모두 많은 운동이 신체의 절반에만 영향을 미치므로 각 측면마다 한 번씩 두 번 수행해야한다는 것을 알고 있습니다. 이러한 연습에는 왼쪽과 오른쪽에 각각 하나씩 두 가지가 있습니다. 그러나 양측 연습이 동일한 순서로되어있는 한 두 상대방을 연속적으로 실행할 필요는 없습니다. 운동 프로그램에서 측면을 전환 할 수도 있지만, 한쪽과 다른 쪽을 시작하는 것은 합리적이지 않습니다.

도전

운동 부분은 두 번째 절반 부인 전반 정수와 같은 순서로 구성되어 비제로 정수들의리스트이고, 각각의 절반의 정수의 부호는 동일하다. 운동 부분의 상반기 부호는 앞면 입니다.

운동 세트는 함께 연결된 동일한 선단 측과 0 개 이상의 운동 부이다.

입력으로 0이 아닌 정수 목록이 주어지면 그것이 운동 세트인지 판별하십시오. 정수가 반드시 고유하지는 않습니다. 목록의 길이가 반드시 짝수는 아닙니다.

솔루션은 표준 허점을 사용하지 않을 수 있습니다 . 출력에 대해 서로 다른 두 가지 일관된 값을 사용할 수 있습니다. 이것은 code-golf 이므로 가장 짧은 솔루션이 승리합니다.

예

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

파이썬 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Ẹ

온라인으로 사용해보십시오!

자바 (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끝) 으로 인한 +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 바이트 버전입니다.

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 54 바이트

Dennis의 Python answer 에서 영감을 얻은 최적화 된 버전 .

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]

파이썬 (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]

온라인으로 사용해보십시오!

저장 됨 :

• Dennis 덕분에 -27 바이트

레티 나 0.8.2 , 57 바이트

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

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

온라인으로 사용해보십시오! 쉼표로 구분 된 입력을 취하지 만 링크에는 테스트 케이스를 처리하는 헤더가 포함됩니다. 설명:

^\b|,\b
$&=

각 양의 정수 앞에 마커를 삽입하십시오.

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

동일한 부호의 정수 사이에서 쉼표를 밑줄로 변경하십시오.

-|=

나머지 표지판을 삭제하십시오.

.$
$&,

입력이 비어 있지 않으면 쉼표를 추가하십시오.

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

문자열이 동일한 정수의 런 쌍으로 구성되어 있는지 확인하십시오.

파이썬 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

온라인으로 사용해보십시오!

자바 스크립트 (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≠/ר⍵}

온라인으로 사용해보십시오!