Nhiệm vụ của bạn là viết một chương trình hoặc chức năng máy tính có danh sách các số nguyên dương có độ dài ít nhất là 2 và xác định xem chúng có phải là "zigzag" hay không. Một chuỗi là một zigzag khi và chỉ khi các số thay thế lớn hơn và nhỏ hơn số đi trước chúng. Ví dụ: và là ngoằn nhưng và không phải.[ 4 , 2 , 3 , 0 , 1 ] [ 1 , 2 , 0 , 0 , 3 , 1 ] [ 1 , 2 , 3 , 1 $[1,2,0,3,2]$$[4,2,3,0,1]$$[1,2,0,0,3,1]$$[1,2,3,1]$

Đối với quyết định của bạn, bạn nên xuất một trong hai giá trị nhất quán khác nhau cho từng khả năng (zigzag và không zigzag).

Các điểm mã của chương trình hoặc chức năng của bạn cũng phải là một đường ngoằn ngoèo. Điều này có nghĩa là khi bạn lấy chuỗi các điểm mã thì nó phải là một đường ngoằn ngoèo.

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte với ít byte hơn.

Thạch , 5 byte

IṠIỊẸ

Trả về (zigzag) hoặc 1 (không zigzag).$0$$1$

Các điểm mã là trong trang mã Jelly .$[73, 205, 73, 176, 174]$

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Hãy thử trực tuyến!

Tôi muốn có được quả bóng lăn theo câu trả lời của Haskell. Tôi chưa thể thấy một cách để cải thiện điều này, nhưng tôi tin rằng nó có thể được thực hiện. Tôi đang mong chờ những gì mọi người có thể làm từ đây.

MATL , 9 byte

dt?ZSd]pA

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm

Chương trình MATL đầu tiên của tôi! Áp chót pđã được thêm vào cho yêu cầu ngoằn ngoèo.

Giải trình:

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 nhờ Jakob
-62 byte nhờ 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: ])])` )")

Hãy thử trực tuyến!

Tín dụng cho thuật toán gập ghềnh đi đến câu trả lời này

input, print, exec, defVà lambdakhông bumpy vì vậy tôi chỉ bị evalrời đi, mà được lưu trữ trên e
Có 2 cách chính để bỏ qua những hạn chế, đặt "+"hoặc giữa các cặp không gập ghềnh, tôi chọn cho cựu ( ngắn hơn cho mỗi lần sử dụng, nhưng nó sẽ cần replace(' ','')kết quả là nhiều byte hơn)
Vì printkhông phải là gập ghềnh, tôi không thể sử dụng nó trực tiếp và vì nó không phải là một chức năng nên tôi không thể sử dụng nó bên trong eval(), vì vậy tôi phải sử dụng input(result)để đưa ra kết quả

K (ngn / k) , 23 byte

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

Hãy thử trực tuyến!

Ohm v2 , 5 byte

δyδ½Å

Hãy thử trực tuyến!

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

Làm thế nào nó hoạt động

δyδ½Å - Chương trình đầy đủ / Khối đối số đơn.
δy - Dấu hiệu của vùng đồng bằng của đầu vào 
  δ - Sự khác biệt của các dấu hiệu. Kết quả trong một chuỗi 2 giây hoặc -2 giây cho
        các mảng gập ghềnh, khi các dấu hiệu xen kẽ, cho -1-1 = -2 hoặc 1 - (- 1) = 2.
    - Kiểm tra xem tất cả các yếu tố có mang lại kết quả trung thực khi ...
   - Giảm một nửa.

Japt -! , 16 14 byte

Chà, cái này không đẹp nhưng tôi rất vui vì nó hoạt động!

Đầu ra truecho zig-zag hoặc falsenếu không.

ä'- m'g ä'a èÍ

Thử nó

Codepoints [228,39,45,32,109,39,103,32,228,39,97,32,232,205]và được bao gồm như là thử nghiệm trong liên kết ở trên.

Giải trình

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

Thạch , 6 byte

IṠµaIẠ

Hãy thử trực tuyến!

Trả lại 1cho sự thật, 0cho giả.

Codepoints : [73, 205, 9, 97, 73, 171]( hợp lệ )

Perl 6 , 61 byte

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

Hãy thử trực tuyến!

Các điểm mã là:

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

Và vâng, đó là những nhân vật unicode trong đó. Đây ít nhiều là giải pháp ban đầu của tôi, với một vài khoảng trắng và dấu ngoặc nhọn trộn lẫn vào nhau.

05AB1E , 10 byte

¥DÄ/¥(Ä2QP

Hãy thử trực tuyến!

Giải trình

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

Điểm mã là: [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

Hãy thử trực tuyến!

Mã điểm:

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

Trả về 1.0cho zigzagging và 0.0cho các chuỗi không zigzagging.

Các điểm mã nằm [164,108,176,164,195,2,109,25]trong trang mã 05AB1E .

Hãy thử trực tuyến.

Giải trình:

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