Sappiamo tutti che molti esercizi riguardano solo metà del tuo corpo, quindi devi eseguirli due volte, una volta per parte. Tali esercizi hanno due controparti, una per il lato sinistro e una per il lato destro. Tuttavia, non è necessario eseguire consecutivamente le due controparti, purché gli esercizi per entrambe le parti siano nello stesso ordine. Puoi anche passare da una parte all'altra del tuo programma di esercizi, ma non avrebbe senso iniziare alcuni esercizi da una parte e alcuni dall'altra.

Sfida

Una parte di esercizio è un elenco di numeri interi diversi da zero, in cui la sua seconda metà è costituita dai numeri interi della prima metà negati e nello stesso ordine, e i segni dei numeri interi su ciascuna metà sono uguali. Il segno della prima metà di una parte di esercizio è il suo lato principale .

Un set di esercizi è zero o più parti di esercizi con lo stesso lato iniziale concatenato insieme.

Dato un elenco di numeri interi diversi da zero come input, determinare se si tratta di un set di esercizi. I numeri interi non sono necessariamente unici. La lunghezza dell'elenco non è necessariamente pari.

La soluzione non può utilizzare nessuna delle scappatoie standard . È possibile utilizzare due valori coerenti diversi per l'output. Questo è code-golf , quindi vince la soluzione più breve.

Esempi

[-5, -1, -7, -6, -5, 5, 1, 7, 6, 5]è un esempio di una parte di esercizio. La prima metà è [-5, -1, -7, -6, -5]e l'ultima metà è [5, 1, 7, 6, 5], che è ogni numero intero nella prima metà negato. Inoltre, i numeri interi della prima metà hanno tutti lo stesso segno. Il lato principale di questa parte di esercizio è -1.

[3, 6, 5, -3, -6, -5, 1, 6, 4, 3, -1, -6, -4, -3]è un esempio di set di esercizi. Le sue singole parti di esercizio sono [3, 6, 5, -3, -6, -5]e [1, 6, 4, 3, -1, -6, -4, -3], ed entrambe hanno il lato principale 1.

[4, -4, -5, 5], nonostante sia costituito solo da parti di esercizi valide, non è un set di esercizi, poiché la prima parte [4, -4]ha un lato guida 1, mentre la seconda parte [-5, 5]ha un lato guida -1.

Casi test

Valori di test validi:

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

Casi di test non validi:

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

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

Provalo online!

Gelatina , 10 byte

ṁṠŒg$+2/FẸ

Provalo online!

Java 8, 186 183 185 byte

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 byte a causa di una correzione di bug per casi di test di dimensione 3 (quasi tutte le permutazioni di 1 e -1alla fine del mio collegamento TIO).

Può sicuramente essere giocato a golf .. La sfida sembra puntuale, ma è piuttosto difficile da implementare. Soprattutto il test case[4,-4,-5,5] stato fastidioso da risolvere .. Ma ora funziona. Lo golfò da qui.

Provalo online.

Spiegazione:

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 byte

Immette un vettore di numeri separato da spazi bianchi. Uscite FALSEper valido e TRUEper non valido.

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 fornisce la codifica della lunghezza della corsa, in questo caso della sequenza di valori positivi e negativi.

Il caso del bordo vuoto completamente e totalmente ingiusto;) aggiunge un enorme 15 byte.

Molti byte cancellati da @Giuseppe.

Ecco una versione da 92 byte espressa in funzione che è meglio per il test:

Provalo online!

JavaScript (ES6), 54 byte

Versione ottimizzata, ispirata alla risposta Python di Dennis .

Restituisce 0 o 1 .

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

Provalo online!

Versione originale, 74 byte

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]

Provalo online!

Come?

Abbiamo memorizzare prima metà di tutte le parti in esercizio b [0] e la seconda metà di b [1] , la commutazione tra b [0] e b [1] ogni volta il segno cambia. Le voci sono quadrate per eliminare il segno. Abbiamo anteposto ogni voce con una virgola e suffisso ogni parte con uno 0 .

C'è un po 'di logica in più per gestire il caso limite "input vuoto" praticamente a costo zero (vedi il commento vicino alla fine del codice sorgente).

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 byte

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]

Provalo online!

Salvato:

• -27 byte, grazie a Dennis

Retina 0.8.2 , 57 byte

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

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

Provalo online! Accetta input separati da virgola, ma il collegamento include un'intestazione che elabora i casi di test. Spiegazione:

^\b|,\b
$&=

Inserisci un marcatore prima di ogni numero intero positivo.

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

Cambia le virgole tra numeri interi dello stesso segno in caratteri di sottolineatura.

-|=

Elimina i segni rimanenti.

.$
$&,

Aggiungi una virgola se l'input non è vuoto.

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

Verificare che la stringa sia composta da coppie di esecuzioni degli stessi numeri interi.

Python 2 , 111 byte

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

Provalo online!

JavaScript (Node.js) , 155 byte

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

Provalo online!

L'ispirazione è stata la risposta di @ KevinCruijssen

Anche grazie a lui per aver corretto 2 miei casi di test

Stax , 13 byte

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

Esegui ed esegui il debug

Brachylog , 18 14 byte

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

Provalo online!

Salvato 4 byte grazie a @ErikTheOutgolfer.

Spiegazione

                    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 byte

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

Provalo online!