Tugas Anda adalah menulis program atau fungsi komputer yang mengambil daftar bilangan bulat positif dengan panjang minimal 2 dan menentukan apakah mereka "zigzag". Urutan adalah zig-zag jika dan hanya jika angka berganti menjadi lebih besar dan lebih kecil dari angka yang datang sebelumnya. Misalnya dan [ 4 , 2 , 3 , 0 , 1 ] adalah zig-zag tetapi [ 1 , 2 , 0 , 0 , 3 , 1 $[1,2,0,3,2]$$[4,2,3,0,1]$$[1,2,0,0,3,1]$dan tidak.$[1,2,3,1]$

Untuk keputusan Anda, Anda harus menampilkan salah satu dari dua nilai konsisten yang berbeda untuk setiap kemungkinan (zigzag dan bukan zigzag).

Poin kode program atau fungsi Anda juga harus merupakan zigzag itu sendiri. Ini berarti bahwa ketika Anda mengambil urutan titik-kode itu harus zig-zag.

Ini adalah kode-golf sehingga jawaban akan dicetak dalam byte dengan lebih sedikit byte yang lebih baik.

Jelly , 5 byte

IṠIỊẸ

Mengembalikan (zigzag) atau 1 (bukan zigzag).$0$$1$

Poin kode adalah di halaman kode Jelly .$[73, 205, 73, 176, 174]$

Cobalah online!

Bagaimana itu bekerja

IṠIỊẸ  Main link. Argument: A (array)

I      Increments; compute the forward differences of A.
 Ṡ     Take their signs.
       A is zigzag iff the signs are alternating.
  I    Take the increments again.
       Alternating signs result in an increment of -2 or 2.
       Non-alternating signs result in an increment of -1, 0, or 1.
   Ị   Insignificant; map each increment j to (|j| ≤ 1).
    Ẹ  Any; return 0 if all results are 0, 1 in any other case.

Haskell , 87 byte

f(a:b:c:d)|(>)a b,b<c=f$b:c:d |(<)a b,b>c=f$b:c:d |1>0=1>12
f[a ] =1<12
f(a:b:_)= a/= b

Cobalah online!

Saya ingin mendapatkan bola bergulir dalam hal jawaban Haskell. Saya belum melihat cara untuk meningkatkan ini, tetapi saya yakin itu bisa dilakukan. Saya menantikan apa yang dapat dilakukan orang dari sini.

MATL , 9 byte

dt?ZSd]pA

Cobalah online! Atau verifikasi semua kasus uji

Program MATL pertama saya! Kedua dari belakang pditambahkan untuk persyaratan zigzag.

Penjelasan:

d    %take the difference between successive elements of input
t    %duplicate that
?    %if that is all non-zero
  ZS %take the sign of those differences (so input is all `-1`s and `1`s now)
  d  %take the difference of that (so if there are successive `1`s or `-1`s, this will have a 0)
]    %end-if
p    %take the product of topmost stack vector (will be 0 if either the original difference or 
     % the difference-of-signs contained a 0)
A    %convert positive products to 1 (since OP specifies "you should output one of two different consistent values for each possibility ")

Python 2 , 225 223 161 139 byte

^{-2 byte terima kasih kepada Jakob
-62 byte terima kasih untuk Dennis}

e={eval }.pop()
p ="i"+"n"+"p"+"u"+"t ( "
s=e(p +")")
e(p +"` a"+"l"+"l([(x<y>z)+(x>y<z)f"+"o"+"r x,y,z i"+"n zip(s,s [1: ],s [2: ])])` )")

Cobalah online!

Kredit untuk algoritma bergelombang digunakan untuk jawaban ini

input, print, exec, defDan lambdatidak bergelombang jadi aku hanya punya evalkiri, yang disimpan pada e
Ada 2 cara utama untuk memotong pembatasan, menempatkan "+"atau antara pasangan non-bergelombang, aku memilih untuk mantan ( lebih pendek untuk setiap penggunaan, tapi itu akan memerlukan replace(' ','')menghasilkan lebih banyak byte)
Karena printtidak bergelombang, saya tidak dapat menggunakannya secara langsung, dan karena itu bukan fungsi saya tidak dapat menggunakannya di dalam eval(), jadi saya harus menggunakan input(result)untuk menampilkan hasilnya

K (ngn / k) , 23 byte

{*/ 0 >1_ *':1_ -': x }

Cobalah online!

Ohm v2 , 5 byte

δyδ½Å

Cobalah online!

$[131,121,131,16,165]$

Bagaimana itu bekerja

δyδ½Å - Program penuh / Blok argumen tunggal.
δy - Tanda-tanda delta input 
  δ - Perbedaan tanda-tandanya. Hasil dalam urutan 2 atau -2 untuk
        array bergelombang, sebagai tanda-tanda bergantian, memberikan -1-1 = -2 atau 1 - (- 1) = 2.
    Å - Periksa apakah semua elemen menghasilkan hasil yang benar saat ...
   ½ - Dibelah dua.

Japt -! , 16 14 byte

Yah, ini tidak cantik tapi aku senang itu berhasil!

Output trueuntuk zig-zag atau falsejika tidak.

ä'- m'g ä'a èÍ

Cobalah

Codepoints [228,39,45,32,109,39,103,32,228,39,97,32,232,205]dan dimasukkan sebagai ujian dalam tautan di atas.

Penjelasan

                   :Implicit input of array
ä'-                :Consecutive differences
    m'g            :Map signs
        ä'a        :Consecutive absolute differences
             Í     :Subtract each from 2
            è      :Count the truthy (non-zero) elements
                   :Implicitly negate and output resulting boolean.

Jelly , 6 byte

IṠµaIẠ

Cobalah online!

Pengembalian 1untuk kebenaran, 0untuk kepalsuan.

Codepoints : [73, 205, 9, 97, 73, 171]( valid )

Perl 6 , 61 byte

{ [*] ($_[{1…*} ] Z<@$_)Z+^ ($_[{1…*} ] Z>@$_[{2…*} ])}

Cobalah online!

Poin kode adalah:

(123 32 91 42 93 32 40 36 95 91 123 49 8230 42 125 32 93 32 90 60 64 36 95 41 90 43 94 32 40 36 95 91 123 49 8230 42 125 32 93 32 90 62 64 36 95 91 123 50 8230 42 125 32 93 41 125)

Dan ya, itu adalah karakter unicode di sana. Ini kurang lebih solusi orisinal saya, dengan beberapa ruang dan kurung kurawal bercampur.

05AB1E , 10 byte

¥DÄ/¥(Ä2QP

Cobalah online!

Penjelasan

¥           # calculate deltas of input
 DÄ/        # divide each by its absolute value
    ¥       # calculate deltas
     (      # negate each
      Ä     # absolute value of each
       2Q   # equals 2
         P  # product

Poin kode adalah: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

JavaScript (ES6), 62 60 byte

a=> a.map(n=> e&=!~(p | q)| q <(q=p)^ p <(p=n), e=p=q=~ 0)|e

Cobalah online!

Poin kode:

61 3d 3e 20 61 2e 6d 61 70 28 6e 3d 3e 20 65 26
3d 21 7e 28 70 20 7c 20 71 29 7c 20 71 20 3c 28
71 3d 70 29 5e 20 70 20 3c 28 70 3d 6e 29 2c 20
65 3d 70 3d 71 3d 7e 20 30 29 7c

05AB1E , 8 byte

¥.±¥Ä2/P

Pengembalian 1.0untuk zig-zag dan 0.0untuk urutan non-zig-zag.

Poin kode ada [164,108,176,164,195,2,109,25]di halaman kode 05AB1E .

Cobalah online.

Penjelasan:

¥           # Take the deltas of the (implicit) input-list
            #  i.e. [1,2,0,3,2,3] → [1,-2,3,-1,1]
 .±         # Calculate the sign for each of them (-1 if a<0; 0 if 0; 1 if a>0)
            #  i.e. [1,-2,3,-1,1] → [1,-1,1,-1,1]
   ¥        # Calculate the deltas of those
            #  i.e. [1,-1,1,-1,1] → [-2,2,-2,2]
    Ä       # Take the absolute value of each
            #  i.e. [-2,2,-2,2] → [2,2,2,2]
     2/     # Divide them by 2
            #  i.e. [2,2,2,2] → [1.0,1.0,1.0,1.0]
            # (`;` {halve} would have been shorter, but doesn't comply to the challenge)
       P    # Take the product of the list resulting in either 1.0 or 0.0
            #  i.e. [1.0,1.0,1.0,1.0] → 1.0