Nous savons tous que beaucoup d'exercices n'affectent que la moitié de votre corps, vous devez donc les faire deux fois, une fois de chaque côté. Ces exercices ont deux homologues, un pour le côté gauche et un pour la droite. Cependant, il n'est pas nécessaire d'exécuter les deux homologues consécutivement, tant que les exercices pour les deux parties sont dans le même ordre. Vous pouvez aussi bien basculer d'un côté à l'autre de votre programme d'exercices, mais cela n'aurait aucun sens de commencer certains exercices d'un côté et d'autres de l'autre.

Défi

Une partie exercice est une liste d'entiers non nuls, où sa seconde moitié se compose des entiers de la première moitié niés et dans le même ordre, et les signes des entiers sur chaque moitié sont égaux. Le signe de la première moitié d'une partie d'exercice est son côté principal .

Un ensemble d' exercices comprend zéro ou plusieurs parties d'exercices avec le même côté avant concaténé ensemble.

Étant donné une liste d'entiers non nuls en entrée, déterminez s'il s'agit d'un ensemble d'exercices. Les entiers ne sont pas nécessairement uniques. La longueur de la liste n'est pas nécessairement égale.

Votre solution ne peut utiliser aucune des failles standard . Vous pouvez utiliser deux valeurs cohérentes différentes pour la sortie. C'est le code-golf , donc la solution la plus courte l'emporte.

Exemples

[-5, -1, -7, -6, -5, 5, 1, 7, 6, 5]est un exemple de partie exercice. La première moitié est [-5, -1, -7, -6, -5], et la dernière moitié est [5, 1, 7, 6, 5], qui est chaque entier de la première moitié nié. De plus, les entiers de la première moitié sont tous du même signe. Le côté principal de cette partie d'exercice est -1.

[3, 6, 5, -3, -6, -5, 1, 6, 4, 3, -1, -6, -4, -3]est un exemple d'un ensemble d'exercices. Ses parties d'exercice individuelles sont [3, 6, 5, -3, -6, -5]et [1, 6, 4, 3, -1, -6, -4, -3], et elles ont toutes deux un côté d'attaque 1.

[4, -4, -5, 5], bien qu'il ne se compose que de parties d'exercice valides, n'est pas un ensemble d'exercices, car la première partie [4, -4], a le côté principal 1, tandis que la deuxième partie [-5, 5], a le côté principal -1.

Cas de test

Cas de test valides:

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

Cas de test non valides:

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

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

Essayez-le en ligne!

Gelée , 10 octets

ṁṠŒg$+2/FẸ

Essayez-le en ligne!

Java 8, 186 183 185 octets

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 octets en raison d'un correctif de bogue pour les cas de test de taille 3 (presque toutes les permutations de 1et -1à la fin de mon lien TIO).

Peut certainement être joué au golf. Le défi semble aller droit au but, mais il est assez difficile à mettre en œuvre. Surtout le cas de test [4,-4,-5,5]était ennuyeux à corriger .. Mais cela fonctionne maintenant. Va jouer au golf d'ici.

Essayez-le en ligne.

Explication:

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 octets

Entre un vecteur de nombres séparés par des espaces. Sorties FALSEvalides et TRUEinvalides.

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 donne le codage de la longueur de course, dans ce cas de la séquence de valeurs positives et négatives.

Le cas de bord vide complètement et totalement injuste;) ajoute un énorme 15 octets.

Beaucoup d'octets rasés par @Giuseppe.

Voici une version de 92 octets exprimée en fonction qui est meilleure pour les tests:

Essayez-le en ligne!

JavaScript (ES6), 54 octets

Version optimisée, inspirée de la réponse Python de Dennis .

Renvoie 0 ou 1 .

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

Essayez-le en ligne!

Version originale, 74 octets

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]

Essayez-le en ligne!

Comment?

Nous stockons les premières moitiés de toutes les parties d'exercice dans b [0] et les deuxièmes moitiés dans b [1] , en basculant entre b [0] et b [1] chaque fois que le signe change. Les entrées sont au carré pour se débarrasser du signe. Nous préfixons chaque entrée avec une virgule et suffixons chaque partie avec un 0 .

Il y a une logique supplémentaire pour gérer le cas de bord `` entrée vide '' sans frais (voir le commentaire vers la fin du code source).

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 106 octets

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]

Essayez-le en ligne!

Enregistré:

• -27 octets, merci à Dennis

Retina 0.8.2 , 57 octets

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

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

Essayez-le en ligne! Prend une entrée séparée par des virgules, mais le lien inclut un en-tête qui traite les cas de test. Explication:

^\b|,\b
$&=

Insérez un marqueur avant chaque entier positif.

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

Remplacez les virgules entre les entiers du même signe par des traits de soulignement.

-|=

Supprimez les signes restants.

.$
$&,

Ajoutez une virgule si l'entrée n'est pas vide.

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

Vérifiez que la chaîne se compose de paires d'exécutions des mêmes entiers.

Python 2 , 111 octets

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

Essayez-le en ligne!

JavaScript (Node.js) , 155 octets

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

Essayez-le en ligne!

L'inspiration était la réponse de @ KevinCruijssen

Merci aussi à lui d'avoir corrigé 2 cas de test à moi

Stax , 13 octets

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

Exécuter et déboguer

Brachylog , 18 14 octets

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

Essayez-le en ligne!

4 octets enregistrés grâce à @ErikTheOutgolfer.

Explication

                    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 octets

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

Essayez-le en ligne!