Wir alle wissen, dass viele Übungen nur eine Körperhälfte betreffen. Sie müssen sie also zweimal machen, einmal für jede Seite. Solche Übungen haben zwei Gegenstücke, eines für die linke und eines für die rechte Seite. Es ist jedoch nicht erforderlich, die beiden Gegenstücke nacheinander auszuführen, solange die Übungen für beide Seiten in derselben Reihenfolge ausgeführt werden. Sie können in Ihrem Übungsprogramm auch zwischen den Seiten wechseln, aber es wäre nicht sinnvoll, einige Übungen mit der einen Seite und einige mit der anderen Seite zu beginnen.

Herausforderung

Ein Übungsteil ist eine Liste von Ganzzahlen ungleich Null, wobei die zweite Hälfte aus den Ganzzahlen der ersten Hälfte besteht, die in derselben Reihenfolge negiert wurden und die Vorzeichen der Ganzzahlen in jeder Hälfte gleich sind. Das Vorzeichen der ersten Hälfte eines Übungsteils ist dessen führende Seite .

Ein Übungssatz besteht aus null oder mehr Übungsteilen, bei denen dieselbe führende Seite miteinander verknüpft ist.

Bestimmen Sie anhand einer Liste von Ganzzahlen ungleich Null als Eingabe, ob es sich um einen Übungssatz handelt. Die ganzen Zahlen sind nicht unbedingt eindeutig. Die Länge der Liste ist nicht unbedingt gerade.

Ihre Lösung verwendet möglicherweise keine der Standardlücken . Sie können zwei verschiedene konsistente Werte für die Ausgabe verwenden. Das ist Code-Golf , also gewinnt die kürzeste Lösung.

Beispiele

[-5, -1, -7, -6, -5, 5, 1, 7, 6, 5]ist ein Beispiel für einen Übungsteil. Die erste Hälfte ist [-5, -1, -7, -6, -5]und die letzte Hälfte ist [5, 1, 7, 6, 5], die jeweils eine ganze Zahl in der ersten Hälfte negiert. Außerdem haben die Ganzzahlen der ersten Hälfte alle dasselbe Vorzeichen. Die führende Seite dieses Übungsteils ist -1.

[3, 6, 5, -3, -6, -5, 1, 6, 4, 3, -1, -6, -4, -3]ist ein Beispiel für ein Übungsset. Die einzelnen Übungsteile sind [3, 6, 5, -3, -6, -5]und [1, 6, 4, 3, -1, -6, -4, -3]und beide haben eine führende Seite 1.

[4, -4, -5, 5]Obwohl es nur aus gültigen Übungsteilen besteht, handelt es sich nicht um ein Übungsset, da der erste Teil [4, -4]eine führende Seite hat 1, während der zweite Teil [-5, 5]eine führende Seite hat -1.

Testfälle

Gültige Testfälle:

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

Ungültige Testfälle:

[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

Probieren Sie es online!

Gelee , 10 Bytes

ṁṠŒg$+2/FẸ

Probieren Sie es 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 aufgrund eines Bugfixes für Testfälle der Größe 3 (fast alle Permutationen von 1 und -1am Ende meines TIO-Links).

Kann auf jeden Fall golfen werden. Die Herausforderung scheint auf den Punkt zu kommen, ist aber ziemlich schwer umzusetzen. Vor allem der Testfall[4,-4,-5,5] war nervig zu beheben .. Aber es funktioniert jetzt. Wird es von hier aus Golf spielen.

Probieren Sie es online aus.

Erläuterung:

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

Gibt einen durch Leerzeichen getrennten Vektor von Zahlen ein. Ausgänge FALSEfür gültig und TRUEungültig.

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 gibt die Lauflängencodierung an, in diesem Fall aus der Folge positiver und negativer Werte.

Der völlig und total unfaire Leerkantenkoffer;) fügt satte 15 Bytes hinzu.

Viele Bytes wurden von @ Giuseppe abgeschabt.

Hier ist eine 92-Byte-Version, die als eine Funktion ausgedrückt wird, die zum Testen besser ist:

Probieren Sie es online!

JavaScript (ES6), 54 Byte

Optimierte Version, inspiriert von Dennis 'Python-Antwort .

Gibt 0 oder 1 zurück .

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

Probieren Sie es online!

Originalversion, 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]

Probieren Sie es online!

Wie?

Wir speichern die ersten Hälften aller Übungsteile in b [0] und die zweiten Hälften in b [1] und wechseln bei jedem Vorzeichenwechsel zwischen b [0] und b [1] . Die Einträge sind quadratisch, um das Zeichen zu entfernen. Wir stellen jedem Eintrag ein Komma voran und fügen jedem Teil eine 0 hinzu .

Es gibt eine zusätzliche Logik, um den Randfall "leere Eingabe" im Grunde kostenlos zu behandeln (siehe den Kommentar am Ende des Quellcodes).

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]

Probieren Sie es online!

Gerettet:

• -27 Bytes, danke an Dennis

Retina 0.8.2 , 57 Bytes

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

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

Probieren Sie es online! Übernimmt kommagetrennte Eingaben, aber der Link enthält einen Header, der Testfälle verarbeitet. Erläuterung:

^\b|,\b
$&=

Fügen Sie vor jeder positiven Ganzzahl einen Marker ein.

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

Ändern Sie die Kommas zwischen ganzen Zahlen desselben Zeichens in Unterstriche.

-|=

Löschen Sie die restlichen Zeichen.

.$
$&,

Fügen Sie ein Komma hinzu, wenn die Eingabe nicht leer ist.

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

Stellen Sie sicher, dass die Zeichenfolge aus Laufpaaren derselben ganzen Zahlen besteht.

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

Probieren Sie es 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')

Probieren Sie es online!

Inspiration war die Antwort von @ KevinCruijssen

Danke auch an ihn für die Korrektur von 2 meiner Testfälle

Stax , 13 Bytes

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

Führen Sie es aus und debuggen Sie es

Brachylog , 18 14 Bytes

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

Probieren Sie es online!

4 Bytes gespart dank @ErikTheOutgolfer.

Erläuterung

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

Probieren Sie es online!