您的任务是编写一个计算机程序或函数，该程序或函数采用长度至少为2的正整数列表，并确定它们是否为“ zigzag”。当且仅当数字交替地大于和小于其前面的数字时，序列才为之字形。例如和是曲折形，但和不是。$[1,2,0,3,2]$$[4,2,3,0,1]$$[1,2,0,0,3,1]$$[1,2,3,1]$

根据您的决定，应为每种可能性输出两个不同的一致值之一（之字形而不是之字形）。

程序或函数的代码点本身也必须是Z字形。这意味着当您采用代码点序列时，它应该是锯齿形的。

这是代码高尔夫球，因此答案将以字节计分，而字节越少越好。

果冻，5个字节

IṠIỊẸ

返回（之字形）或1（非之字形）。$0$$1$

所述代码点在果冻代码页。$[73, 205, 73, 176, 174]$

在线尝试！

怎么运行的

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个字节

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

在线尝试！

我想根据Haskell的答案让球滚动。我还没有办法改善它，但是我坚信它可以做到。我期待人们从这里可以做什么。

MATL，9个字节

dt?ZSd]pA

在线尝试！或验证所有测试用例

我的第一个MATL程序！倒数第二个p添加为之字形要求。

说明：

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字节

^{-2字节归功于Jakob
-62字节归功于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: ])])` )")

在线尝试！

颠簸算法的功劳归功于此答案

input，print，exec，def和lambda不颠簸，所以我只得到了eval离开，这是存储在e
有2种主要途径绕过限制，放置"+"或无颠簸对之间，我选择了前者（对于每个使用更短，但它会replace(' ','')导致产生更多的字节）。
由于print它不是凹凸不平的，所以我不能直接使用它，而且由于它不是函数eval()，所以我不能在内部使用它，所以我不得不使用它input(result)来输出结果

K（ngn / k），23个字节

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

在线尝试！

欧姆v2，5个字节

δyδ½Å

在线尝试！

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

怎么运行的

δyδ½Å–完整程序/单参数块。
δy–输入增量的符号 
  δ–符号的差异。结果为2或-2的序列
        颠簸的数组，随着符号交替出现，给出-1-1 = -2或1-（-1）= 2。
    Å–在以下情况下检查所有元素是否得出真实结果：
   ½–减半。

Japt -!，16 14字节

好吧，这不是很漂亮，但是我很高兴它能起作用！

输出true为之字形或false否。

ä'- m'g ä'a èÍ

尝试一下

代码点[228,39,45,32,109,39,103,32,228,39,97,32,232,205]作为测试并包含在上面的链接中。

说明

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

果冻，6 个字节

IṠµaIẠ

在线尝试！

返回1真相，0虚假。

代码点：[73, 205, 9, 97, 73, 171]（有效）

Perl 6、61字节

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

在线尝试！

代码点是：

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

是的，这些是那里的unicode字符。这或多或少是我最初的解决方案，其中混入了一些空格和花括号。

05AB1E，10个字节

¥DÄ/¥(Ä2QP

在线尝试！

说明

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

代码点是： [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

JavaScript（ES6），62 60字节

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

在线尝试！

代码点：

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 个字节

¥.±¥Ä2/P

返回1.0锯齿形和0.0非锯齿形序列。

代码点[164,108,176,164,195,2,109,25]在05AB1E代码页中。

在线尝试。

说明：

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