Todos sabemos que muchos ejercicios solo afectan a la mitad de su cuerpo, por lo que debe hacerlos dos veces, una para cada lado. Dichos ejercicios tienen dos contrapartes, uno para el lado izquierdo y otro para el derecho. Sin embargo, no es necesario ejecutar las dos contrapartes consecutivamente, siempre y cuando los ejercicios para ambos lados estén en el mismo orden. También puede cambiar de lado en su programa de ejercicios, pero no tendría sentido comenzar algunos ejercicios con un lado y otros con el otro.

Desafío

Una parte del ejercicio es una lista de enteros distintos de cero, donde su segunda mitad consiste en los enteros de la primera mitad negados y en el mismo orden, y los signos de los enteros en cada mitad son iguales. El signo de la primera mitad de una parte del ejercicio es su lado principal .

Un conjunto de ejercicios es cero o más partes de ejercicio con el mismo lado principal concatenados juntos.

Dada una lista de enteros distintos de cero como entrada, determine si se trata de un conjunto de ejercicios. Los enteros no son necesariamente únicos. La longitud de la lista no es necesariamente pareja.

Es posible que su solución no use ninguna de las lagunas estándar . Puede usar dos valores consistentes diferentes para la salida. Este es el código de golf , por lo que gana la solución más corta.

Ejemplos

[-5, -1, -7, -6, -5, 5, 1, 7, 6, 5]es un ejemplo de una parte de ejercicio. La primera mitad es [-5, -1, -7, -6, -5], y la última mitad es [5, 1, 7, 6, 5], que es cada número entero en la primera mitad negada. Además, los enteros de la primera mitad son todos del mismo signo. El lado principal de esta parte del ejercicio es -1.

[3, 6, 5, -3, -6, -5, 1, 6, 4, 3, -1, -6, -4, -3]es un ejemplo de un conjunto de ejercicios. Sus partes de ejercicio individuales son [3, 6, 5, -3, -6, -5]y [1, 6, 4, 3, -1, -6, -4, -3], y ambas tienen un lado principal 1.

[4, -4, -5, 5], a pesar de que solo consta de partes de ejercicio válidas, no es un conjunto de ejercicios, ya que la primera parte [4, -4]tiene un lado principal 1, mientras que la segunda parte [-5, 5]tiene un lado principal -1.

Casos de prueba

Casos de prueba válidos:

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

Casos de prueba inválidos:

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

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

Pruébalo en línea!

Jalea , 10 bytes

ṁṠŒg$+2/FẸ

Pruébalo en línea!

Java 8, 186 183 185 bytes

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 bytes debido a una corrección de errores para casos de prueba de tamaño 3 (casi todas las permutaciones de 1y -1al final de mi enlace TIO).

Definitivamente se puede jugar al golf. El desafío parece ir al grano, pero es bastante difícil de implementar. Especialmente el caso de prueba [4,-4,-5,5]fue molesto de arreglar ... Pero funciona ahora. Lo jugará golf desde aquí.

Pruébalo en línea.

Explicación:

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 bytes

Introduce un vector de números separados por espacios en blanco. Salidas FALSEválidas y TRUEno válidas.

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 da la codificación de longitud de ejecución, en este caso de la secuencia de valores positivos y negativos.

El caso de borde vacío completamente y totalmente injusto;) agrega la friolera de 15 bytes.

Muchos bytes recortados por @Giuseppe.

Aquí hay una versión de 92 bytes expresada como una función que es mejor para probar:

Pruébalo en línea!

JavaScript (ES6), 54 bytes

Versión optimizada, inspirada en la respuesta Python de Dennis .

Devuelve 0 o 1 .

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

Pruébalo en línea!

Versión original, 74 bytes.

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]

Pruébalo en línea!

¿Cómo?

Almacenamos las primeras mitades de todas las partes de ejercicio en b [0] y la segunda mitades en b [1] , el cambio entre b [0] y b [1] cada vez que la señal está cambiando. Las entradas son cuadradas para deshacerse del signo. Prefijamos cada entrada con una coma y sufijo cada parte con un 0 .

Hay cierta lógica adicional para manejar el caso de borde de 'entrada vacía' básicamente sin costo (vea el comentario cerca del final del código fuente).

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 bytes

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]

Pruébalo en línea!

Salvado:

• -27 bytes, gracias a Dennis

Retina 0.8.2 , 57 bytes

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

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

Pruébalo en línea! Toma una entrada separada por comas, pero el enlace incluye un encabezado que procesa los casos de prueba. Explicación:

^\b|,\b
$&=

Inserte un marcador antes de cada entero positivo.

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

Cambie las comas entre enteros del mismo signo a guiones bajos.

-|=

Eliminar los signos restantes.

.$
$&,

Agregue una coma si la entrada no está vacía.

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

Compruebe que la cadena consta de pares de corridas de los mismos enteros.

Python 2 , 111 bytes

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

Pruébalo en línea!

JavaScript (Node.js) , 155 bytes

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

Pruébalo en línea!

La inspiración fue la respuesta de @ KevinCruijssen

También gracias a él por corregir 2 casos de prueba míos

Stax , 13 bytes

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

Ejecutar y depurarlo

Brachylog , 18 14 bytes

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

Pruébalo en línea!

Guardado 4 bytes gracias a @ErikTheOutgolfer.

Explicación

                    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 bytes

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

Pruébalo en línea!