Ваше завдання - написати комп’ютерну програму або функцію, яка займає список натуральних чисел принаймні довжиною 2 і визначає, чи є вони "зигзагом". Послідовність - це зигзаг, якщо і лише тоді, коли числа чергуються в більших і менших розмірах, ніж число, що йде перед ними. Наприклад $[1,2,0,3,2]$ та є зигзагами, але та не є.[ 1 , 2 , 0 , 0 , 3 , 1 ] [ 1 , 2 , 3 , 1 $[4,2,3,0,1]$$[1,2,0,0,3,1]$$[1,2,3,1]$

Для свого рішення слід вивести одне з двох різних послідовних значень для кожної можливості (зигзаг, а не зигзаг).

Кодові точки вашої програми чи функції також повинні бути самим зигзагом. Це означає, що коли ви берете послідовність точок коду, це повинен бути зигзаг.

Це кодовий гольф, тому відповіді будуть набрані в байтах, а менша кількість байтів буде кращою.

Желе , 5 байт

IṠIỊẸ

Повертає (зигзаг) або 1 (не зигзаг).$0$$1$

Кодові точки на кодовій сторінці Jelly .$[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 байти завдяки Якобу
-62 байти завдяки Деннісу}

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)для виведення результату

К (нг / к) , 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