Kita semua tahu bahwa banyak latihan hanya memengaruhi setengah tubuh Anda, jadi Anda harus melakukannya dua kali, satu kali untuk setiap sisi. Latihan semacam itu memiliki dua rekan, satu untuk sisi kiri dan satu untuk sisi kanan. Namun, tidak perlu mengeksekusi kedua rekan secara berurutan, selama latihan untuk kedua belah pihak berada dalam urutan yang sama. Anda mungkin juga beralih antara sisi dalam program latihan Anda, tetapi tidak masuk akal untuk memulai beberapa latihan dengan satu sisi dan beberapa dengan yang lain.

Tantangan

Bagian latihan adalah daftar bilangan bulat bukan nol, di mana bagian kedua terdiri dari bilangan bulat dari bagian pertama yang dinegasikan dan dalam urutan yang sama, dan tanda-tanda bilangan bulat pada setiap bagian adalah sama. Tanda paruh pertama bagian latihan adalah sisi yang memimpin .

Sebuah set latihan adalah nol atau lebih bagian latihan dengan sisi terkemuka yang sama digabungkan bersama-sama.

Diberikan daftar bilangan bulat bukan nol sebagai input, tentukan apakah itu adalah set latihan. Bilangan bulat tidak selalu unik. Panjang daftar itu belum tentu genap.

Solusi Anda mungkin tidak menggunakan celah standar apa pun . Anda dapat menggunakan dua nilai konsisten berbeda untuk output. Ini adalah kode-golf , sehingga solusi terpendek menang.

Contohnya

[-5, -1, -7, -6, -5, 5, 1, 7, 6, 5]adalah contoh dari bagian latihan. Babak pertama adalah [-5, -1, -7, -6, -5], dan babak terakhir adalah [5, 1, 7, 6, 5], yang masing-masing bilangan bulat di babak pertama dinegasikan. Selain itu, bilangan bulat paruh pertama adalah semua tanda yang sama. Sisi utama bagian latihan ini adalah -1.

[3, 6, 5, -3, -6, -5, 1, 6, 4, 3, -1, -6, -4, -3]adalah contoh dari set latihan. Bagian latihan individualnya adalah [3, 6, 5, -3, -6, -5]dan [1, 6, 4, 3, -1, -6, -4, -3], dan mereka berdua memiliki sisi kepemimpinan 1.

[4, -4, -5, 5], meskipun hanya terdiri dari bagian latihan yang valid, bukan set latihan, karena bagian pertama [4, -4], memiliki sisi terdepan 1, sedangkan bagian kedua [-5, 5], memiliki sisi terdepan -1.

Uji kasus

Kasus uji yang valid:

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

Kasus uji tidak valid:

[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

Cobalah online!

Jelly , 10 byte

ṁṠŒg$+2/FẸ

Cobalah 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 karena perbaikan bug untuk kasus uji ukuran 3 (hampir semua permutasi 1dan -1pada akhir TIO-link saya).

Pasti bisa bermain golf .. Tantangannya to-the-point, tapi cukup sulit untuk diterapkan. Terutama uji kasus [4,-4,-5,5]itu menjengkelkan untuk memperbaikinya .. Tapi itu berfungsi sekarang. Akankah golf turun dari sini.

Cobalah online.

Penjelasan:

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

Input vektor angka yang dipisahkan spasi. Output FALSEuntuk valid dan TRUEtidak valid.

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 memberikan pengkodean run run, dalam hal ini urutan nilai positif dan negatif.

The kasus tepi kosong benar-benar dan benar-benar tidak adil;) menambahkan kekalahan 15 byte.

Banyak byte yang dipotong oleh @Giuseppe.

Berikut adalah versi 92 byte yang dinyatakan sebagai fungsi yang lebih baik untuk pengujian:

Cobalah online!

JavaScript (ES6), 54 byte

Versi yang dioptimalkan, terinspirasi oleh jawaban Python Dennis .

Mengembalikan 0 atau 1 .

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

Cobalah online!

Versi asli, 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]

Cobalah online!

Bagaimana?

Kami menyimpan bagian pertama dari semua bagian latihan di b [0] dan bagian kedua di b [1] , beralih di antara b [0] dan b [1] setiap kali tanda berubah. Entri dikuadratkan untuk menyingkirkan tanda. Kami awali setiap entri dengan koma dan sufiks setiap bagian dengan 0 .

Ada beberapa logika tambahan untuk menangani kasus tepi 'input kosong' pada dasarnya tanpa biaya (lihat komentar di dekat akhir kode sumber).

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]

Cobalah online!

Diselamatkan:

• -27 byte, terima kasih untuk Dennis

Retina 0.8.2 , 57 byte

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

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

Cobalah online! Mengambil input yang dipisahkan koma, tetapi tautan menyertakan tajuk yang memproses kasus uji. Penjelasan:

^\b|,\b
$&=

Masukkan penanda sebelum setiap bilangan bulat positif.

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

Ubah koma di antara bilangan bulat dari tanda yang sama ke garis bawah.

-|=

Hapus tanda yang tersisa.

.$
$&,

Tambahkan koma jika input tidak kosong.

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

Pastikan string terdiri dari pasangan run dari integer yang sama.

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

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

Cobalah online!

Inspirasi adalah jawaban @ KevinCruijssen

Juga terima kasih kepadanya untuk mengoreksi 2 kasus uji saya

Stax , 13 byte

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

Jalankan dan debug itu

Brachylog , 18 14 byte

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

Cobalah online!

Disimpan 4 byte berkat @ErikTheOutgolfer.

Penjelasan

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

Cobalah online!