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

Вызов

Упражнение часть представляет собой список ненулевых целых чисел, где его вторая половина состоит из чисел первой половины отрицается и в том же порядке, и знаки чисел на каждой половине равны. Признак первой половины части упражнения - ее ведущая сторона. .

Набор упражнений равен нулю или больше упражнений частей с одной и той же ведущей стороне объединяются вместе.

Учитывая список ненулевых целых чисел в качестве входных данных, определите, является ли это набор упражнений. Целые числа не обязательно уникальны. Длина списка не обязательно четная.

Ваше решение не может использовать какие-либо стандартные лазейки . Вы можете использовать любые два различных последовательных значения для вывода. Это код-гольф , поэтому выигрывает самое короткое решение.

Примеры

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

Попробуйте онлайн!

Ява 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)

р , 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 байта

Оптимизированная версия, вдохновленная ответом Денниса на 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

Запустите и отладьте его

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

Попробуйте онлайн!