Göreviniz, en az 2 uzunluğundaki pozitif tamsayıların listesini alan ve bir "zikzak" olup olmadığını belirleyen bir bilgisayar programı veya işlevi yazmaktır. Sekans, yalnızca sayıların kendilerinden önce gelen sayıdan daha büyük ve daha küçük olması durumunda zikzaktır. Örneğin ve [ 4 , 2 , 3 , 0 , 1 ] zikzaktır ancak [ 1 , 2 , 0 , 0 , 3 , 1 $[1,2,0,3,2]$$[4,2,3,0,1]$$[1,2,0,0,3,1]$ve değildir.$[1,2,3,1]$

Kararınız için her olasılık için iki farklı tutarlı değerden birini çıkarmalısınız (zikzak değil, zikzak değil).

Programınızın veya fonksiyonunuzun kod noktaları da bir zikzak olmalıdır. Bu, kod noktaları dizisini aldığınızda bunun bir zikzak olması gerektiği anlamına gelir.

Bu kod golftür, bu nedenle cevaplar daha az bayt daha iyi olacak şekilde bayt cinsinden puanlanır.

Jöle , 5 bayt

IṠIỊẸ

(zikzak) veya 1 (zikzak değil ) döndürür .$0$$1$

Kod noktaları içinde jöle kod sayfa .$[73, 205, 73, 176, 174]$

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Çevrimiçi deneyin!

Haskell cevapları açısından topu yuvarlatmak istedim. Henüz bunu geliştirmenin bir yolunu göremiyorum, ama yapılabileceğine inanıyorum. İnsanların buradan yapabileceklerini dört gözle bekliyorum.

MATL , 9 bayt

dt?ZSd]pA

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın

İlk MATL programım! Sondan bir önceki pzikzak gereksinimi için eklenmiştir.

Açıklama:

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 bayt

^{Jakob sayesinde -2 bayt
-Dennis sayesinde teşekkürler -62 bayt}

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: ])])` )")

Çevrimiçi deneyin!

Engebeli algoritmanın kredileri bu cevaba gider

input, print, exec, defVe lambdasadece var bu yüzden engebeli değildir evaldepolanmış olan, sol e
yerleştirilmesi sınırlama baypas 2 ana yolu vardır "+"ya da olmayan engebeli çiftleri arasında, I (eski seçti her bir kullanım için daha kısa, fakat o gerekir replace(' ','')) daha bayt sonuçlanan
beri printben içerde kullanamayan bir funcion olmadığından inişli çıkışlı değil ben bunu doğrudan kullanamaz, ve eval()ben kullanmak zorunda, input(result)çıkış sonuç için

K (ngn / k) , 23 bayt

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

Çevrimiçi deneyin!

Ohm v2 , 5 bayt

δyδ½Å

Çevrimiçi deneyin!

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

Nasıl çalışır

Fullyδ½Å - Tam program / Tek argüman bloğu.
δy - Girdilerin deltalarının işaretleri 
  δ - İşaretlerin farklılıkları. İçin 2'li veya -2'li dizilerle sonuçlanır
        engebeli diziler, işaretler dönüşümlü olarak -1-1 = -2 veya 1 - (- 1) = 2 verir.
    Å - Aşağıdaki durumlarda tüm öğelerin doğru sonuçlar verip vermediğini kontrol edin ...
   ½ - Yarıya.

Japt -! , 16 14 bayt

Bu güzel değil ama işe yaradığı için mutluyum!

trueZig-zag için çıkışlar veya falsedeğilse.

ä'- m'g ä'a èÍ

Dene

Kod noktaları [228,39,45,32,109,39,103,32,228,39,97,32,232,205]yukarıdaki bağlantıya test olarak dahil edilmiştir.

açıklama

                   :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.

Jöle , 6 bayt

IṠµaIẠ

Çevrimiçi deneyin!

İade 1truthy için, 0falsy için.

Kod noktaları : [73, 205, 9, 97, 73, 171]( geçerli )

Perl 6 , 61 bayt

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

Çevrimiçi deneyin!

Kod noktaları:

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

Ve evet, oradaki unicode karakterler. Bu, az ya da çok kıvrımlı parantezlerle karıştırılmış orijinal çözümüm.

05AB1E , 10 bayt

¥DÄ/¥(Ä2QP

Çevrimiçi deneyin!

açıklama

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

Kod noktaları: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

JavaScript (ES6), 62 60 bayt

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

Çevrimiçi deneyin!

Kod noktaları:

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 bayt

¥.±¥Ä2/P

İade 1.0girintili çıkıntılı olmasına ve0.0 olmayan zikzak dizileri için.

Kod noktaları [164,108,176,164,195,2,109,25]içinde 05AB1E kod sayfası .

Çevrimiçi deneyin.

Açıklama:

¥           # 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