Todos sabemos que muitos exercícios afetam apenas metade do seu corpo, então você deve executá-los duas vezes, uma de cada lado. Tais exercícios têm duas contrapartes, uma para o lado esquerdo e outra para a direita. No entanto, não há necessidade de executar as duas contrapartes consecutivamente, desde que os exercícios para os dois lados estejam na mesma ordem. Você também pode alternar entre os lados do seu programa de exercícios, mas não faria sentido começar alguns exercícios com um lado e outros com o outro.

Desafio

Uma parte do exercício é uma lista de números inteiros diferentes de zero, em que sua segunda metade consiste nos números inteiros da primeira metade negados e na mesma ordem, e os sinais dos números inteiros em cada metade são iguais. O sinal da primeira metade de uma parte do exercício é o seu lado principal .

Um conjunto de exercícios é zero ou mais partes do exercício com o mesmo lado principal concatenado juntos.

Dada uma lista de números inteiros diferentes de zero como entrada, determine se é um conjunto de exercícios. Os números inteiros não são necessariamente únicos. O comprimento da lista não é necessariamente uniforme.

Sua solução não pode usar nenhuma das brechas padrão . Você pode usar dois valores consistentes diferentes para a saída. Isso é código-golfe , então a solução mais curta vence.

Exemplos

[-5, -1, -7, -6, -5, 5, 1, 7, 6, 5]é um exemplo de uma parte do exercício. A primeira metade é [-5, -1, -7, -6, -5], e a última metade é [5, 1, 7, 6, 5], que é cada número inteiro na primeira metade negado. Além disso, os números inteiros da primeira metade são todos do mesmo sinal. O lado principal desta parte do exercício é -1.

[3, 6, 5, -3, -6, -5, 1, 6, 4, 3, -1, -6, -4, -3]é um exemplo de um conjunto de exercícios. Suas partes individuais do exercício são [3, 6, 5, -3, -6, -5]e [1, 6, 4, 3, -1, -6, -4, -3], e ambos têm o lado principal 1.

[4, -4, -5, 5], apesar de consistir apenas em partes válidas do exercício, não é um conjunto de exercícios, uma vez que a primeira parte [4, -4]tem lado principal 1, enquanto a segunda parte [-5, 5]tem lado principal -1.

Casos de teste

Casos de teste 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 teste 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

Experimente online!

Gelatina , 10 bytes

ṁṠŒg$+2/FẸ

Experimente online!

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 devido a uma correção de bug para casos de teste de tamanho 3 (quase todas as permutações 1e -1no final do meu link TIO).

Definitivamente, você pode jogar golfe .. O desafio parece direto ao ponto, mas é bem difícil de implementar. Especialmente o caso de teste [4,-4,-5,5]foi chato de corrigir. Mas funciona agora. Vai jogar golfe daqui a baixo.

Experimente online.

Explicação:

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

Insere um vetor de números separados por espaço em branco. Saídas FALSEválidas e TRUEinvá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 fornece a codificação do comprimento da execução, neste caso da sequência de valores positivos e negativos.

O caso completo e totalmente injusto da borda vazia;) adiciona uns 15 bytes impressionantes.

Muitos bytes eliminados pelo @ Giuseppe.

Aqui está uma versão de 92 bytes, expressa como uma função que é melhor para testar:

Experimente online!

JavaScript (ES6), 54 bytes

Versão otimizada, inspirada na resposta Python de Dennis .

Retorna 0 ou 1 .

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

Experimente online!

Versão 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]

Experimente online!

Quão?

Nós armazenamos as primeiras metades de todas as partes do exercício em b [0] e as segundas metades em b [1] , alternando entre b [0] e b [1] cada vez que o sinal está mudando. As entradas são quadradas para se livrar do sinal. Prefixamos cada entrada com uma vírgula e sufixamos cada parte com um 0 .

Existe alguma lógica extra para lidar com o caso de borda de 'entrada vazia' basicamente sem nenhum custo (veja o comentário no final do código-fonte).

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]

Experimente online!

Salvou:

• -27 bytes, graças a Dennis

Retina 0.8.2 , 57 bytes

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

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

Experimente online! Recebe entrada separada por vírgula, mas o link inclui o cabeçalho que processa casos de teste. Explicação:

^\b|,\b
$&=

Insira um marcador antes de cada número inteiro positivo.

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

Altere as vírgulas entre números inteiros do mesmo sinal para sublinhados.

-|=

Exclua os sinais restantes.

.$
$&,

Acrescente uma vírgula se a entrada não estiver vazia.

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

Verifique se a sequência consiste em pares de execuções dos mesmos números inteiros.

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

Experimente online!

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

Experimente online!

Inspiration was @ KevinCruijssen's answer

Também agradeço a ele por corrigir 2 casos de teste meus

Stax , 13 bytes

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

Execute e depure

Braquilog , 18 14 bytes

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

Experimente online!

Guardado 4 bytes graças a @ErikTheOutgolfer.

Explicação

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

Experimente online!