Всі ми знаємо, що багато вправ впливають лише на одну половину вашого тіла, тому робити їх потрібно двічі, один раз для кожної сторони. Такі вправи мають два аналоги, один для лівого боку та один для правого. Однак, немає необхідності виконувати два аналоги послідовно, до тих пір, поки вправи для обох сторін будуть в одному порядку. Ви також можете перемикатися між сторонами у вашій програмі вправ, але не було б сенсу починати деякі вправи з одного боку, а деякі з іншого.

Виклик

Вправа частина являє собою список ненульових цілих чисел, де його друга половина складається з чисел першої половини заперечується і в тому ж порядку, і знаки чисел на кожній половині рівні. Ознакою першої половини частини вправи є її ведуча сторона .

Набір вправ дорівнює нулю або більше вправ частин з одного і того ж провідною стороні об'єднуються разом.

Давши список ненульових цілих чисел як вхід, визначте, чи це набір вправ. Цілі числа не обов'язково є унікальними. Довжина списку не обов'язково рівномірна.

У вашому рішенні може не використовуватися жодна зі стандартних лазів . Ви можете використовувати будь-які два різних послідовних значення для виводу. Це код-гольф , тому найкоротше рішення виграє.

Приклади

[-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-посилання).

Однозначно можна пограти в гольф. Проблема виглядає точно, але це досить важко здійснити. Особливо тестовий випадок [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 байти

Оптимізована версія, натхненна відповіддю Денніса Пітона .

Повертає 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)*$

Переконайтеся, що рядок складається з пар прогонів однакових цілих чисел.

Пітон 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 моїх тестових випадків

Стакс , 13 байт

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

Запустіть і налагоджуйте його

Брахілог , 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≠/ר⍵}

Спробуйте в Інтернеті!