Twoim zadaniem jest napisanie programu komputerowego lub funkcji, która pobiera listę liczb całkowitych dodatnich o długości co najmniej 2 i określa, czy są one „zygzakiem”. Sekwencja jest zygzakiem wtedy i tylko wtedy, gdy liczby na przemian są większe i mniejsze niż liczba, która jest przed nimi. Na przykład i to zygzaki, ale i nie są.[ 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]$

Dla swojej decyzji powinieneś wypisać jedną z dwóch różnych spójnych wartości dla każdej możliwości (zygzak i nie zygzak).

Punkty kodowe twojego programu lub funkcji muszą być również zygzakiem. Oznacza to, że jeśli weźmiesz sekwencję punktów kodowych, powinna to być zygzak.

To jest golf golfowy, więc odpowiedzi będą liczone w bajtach, przy czym mniej bajtów będzie lepszych.

Galaretka , 5 bajtów

IṠIỊẸ

Zwraca (zygzak) lub (nie zygzak).$0$$1$

Punkty kodowe to na stronie kodowej Jelly .$[73, 205, 73, 176, 174]$

Wypróbuj online!

Jak to działa

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 bajtów

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

Wypróbuj online!

Chciałem sprawić, by piłka potoczyła się pod względem odpowiedzi Haskella. Nie widzę jeszcze sposobu, aby to poprawić, ale jestem przekonany, że da się to zrobić. Nie mogę się doczekać, co ludzie mogą zrobić stąd.

MATL , 9 bajtów

dt?ZSd]pA

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe

Mój pierwszy w historii program MATL! Przedostatni pzostał dodany do wymogu zygzaka.

Wyjaśnienie:

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 bajtów

^{-2 bajty dzięki Jakobowi
-62 bajtów dzięki Dennisowi}

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

Wypróbuj online!

Kredyty na wyboisty algorytm trafiają do tej odpowiedzi

input, print, exec, defI lambdanie nie są proste, więc mam tylko evalw lewo, który jest przechowywany na e
Istnieją 2 główne sposoby na ominięcie ograniczeń, wprowadzania "+"lub między non-wyboistej parach, Zdecydowałem się na pierwszej ( jest krótszy dla każdego zastosowania, ale wymagałoby to uzyskania replace(' ','')większej liczby bajtów)
Ponieważ printnie jest wyboisty, nie mogę go użyć bezpośrednio, a ponieważ nie jest to żadna funkcja, nie mogę go użyć wewnątrz eval(), więc musiałem użyć go, input(result)aby wygenerować wynik

K (ngn / k) , 23 bajty

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

Wypróbuj online!

Ohm v2 , 5 bajtów

δyδ½Å

Wypróbuj online!

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

Jak to działa

--yδ½Å - Pełny program / Blok z jednym argumentem.
--y - Znaki delta wejścia 
  δ - Różnice znaków. Wyniki w sekwencji 2 lub -2 dla
        wyboiste tablice, na przemian znaki, dając -1-1 = -2 lub 1 - (- 1) = 2.
    Å - Sprawdź, czy wszystkie elementy dają prawdziwe wyniki, gdy ...
   ½ - o połowę.

Japt -! , 16 14 bajtów

Cóż, to nie jest ładne, ale cieszę się, że to działa!

Wyjścia truedla zygzaka lub falsejeśli nie.

ä'- m'g ä'a èÍ

Spróbuj

Punkty kodowe są [228,39,45,32,109,39,103,32,228,39,97,32,232,205]i uwzględniane jako test w powyższym linku.

Wyjaśnienie

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

Galaretka , 6 bajtów

IṠµaIẠ

Wypróbuj online!

Zwraca 1za prawdę, 0za fałsz.

Punkty kodowe : [73, 205, 9, 97, 73, 171]( ważne )

Perl 6 , 61 bajtów

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

Wypróbuj online!

Punkty kodowe to:

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

I tak, są tam znaki Unicode. To mniej więcej moje oryginalne rozwiązanie, z kilkoma spacjami i nawiasami klamrowymi.

05AB1E , 10 bajtów

¥DÄ/¥(Ä2QP

Wypróbuj online!

Wyjaśnienie

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

Punkty kodowe to: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

JavaScript (ES6), 62 60 bajtów

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

Wypróbuj online!

Punkty kodowe:

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 bajtów

¥.±¥Ä2/P

Zwraca 1.0dla 0.0sekwencji zygzakowatych i dla sekwencji niezygzakowatych.

Punkty kodowe znajdują się [164,108,176,164,195,2,109,25]na stronie kodowej 05AB1E .

Wypróbuj online.

Wyjaśnienie:

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