Su tarea es escribir un programa o función de computadora que tome una lista de enteros positivos de al menos 2 y determine si son un "zigzag". Una secuencia es un zigzag si y solo si los números se alternan en ser más grandes y más pequeños que el número que viene antes que ellos. Por ejemplo, y son zigzags pero y no lo son.$[1,2,0,3,2]$$[4,2,3,0,1]$$[1,2,0,0,3,1]$$[1,2,3,1]$

Para su decisión, debe generar uno de dos valores consistentes diferentes para cada posibilidad (zigzag y no zigzag).

Los puntos de código de su programa o función también deben ser un zigzag. Esto significa que cuando tomas la secuencia de puntos de código, debería ser un zigzag.

Este es el código de golf, por lo que las respuestas se puntuarán en bytes con menos bytes mejor.

Jalea , 5 bytes

IṠIỊẸ

Devuelve (zigzag) o 1 (no zigzag).$0$$1$

Los puntos de código son en la página de códigos Jelly$[73, 205, 73, 176, 174]$ .

Pruébalo en línea!

Cómo funciona

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 bytes

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

Pruébalo en línea!

Quería hacer rodar la pelota en términos de respuestas de Haskell. Todavía no puedo ver una manera de mejorar esto, pero estoy convencido de que se puede hacer. Estoy ansioso por lo que la gente pueda hacer desde aquí.

MATL , 9 bytes

dt?ZSd]pA

Pruébalo en línea! O verificar todos los casos de prueba

¡Mi primer programa MATL! El penúltimo pse agregó para el requisito de zigzag.

Explicación:

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 bytes

^{-2 bytes gracias a Jakob
-62 bytes gracias a 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: ])])` )")

Pruébalo en línea!

Los créditos para el algoritmo lleno de baches van a esta respuesta

input, print, exec, defY lambdano son desiguales por lo que sólo obtuve evalizquierda, que se almacena en e
Hay 2 formas principales de derivación la restricción, la colocación de "+"o entre los pares no llenas de baches, I optado por la primera ( es más corto para cada uso, pero necesitaría dar como replace(' ','')resultado más bytes)
Como printno está lleno de baches, no puedo usarlo directamente, y dado que no es una función, no puedo usarlo en el interior eval(), así que tuve que usarlo input(result)para generar el resultado

K (ngn / k) , 23 bytes

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

Pruébalo en línea!

Ohm v2 , 5 bytes

δyδ½Å

Pruébalo en línea!

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

Cómo funciona

δyδ½Å: programa completo / bloque de argumento único.
δy: los signos de los deltas de la entrada 
  δ - Las diferencias de los signos. Resultados en una secuencia de 2 o -2 para
        matrices desiguales, ya que los signos se alternan, dando -1-1 = -2 o 1 - (- 1) = 2.
    Å - Comprueba si todos los elementos producen resultados verdaderos cuando ...
   ½ - Reducido a la mitad.

Japt -! , 16 14 bytes

Bueno, esto no es bonito, ¡pero estoy feliz de que funcione!

Salidas truepara zig-zag o falsesi no.

ä'- m'g ä'a èÍ

Intentalo

Los puntos de código se [228,39,45,32,109,39,103,32,228,39,97,32,232,205]incluyen como prueba en el enlace de arriba.

Explicación

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

Jalea , 6 bytes

IṠµaIẠ

Pruébalo en línea!

Vuelve 1por la verdad, 0por la falsedad.

Puntos de código : [73, 205, 9, 97, 73, 171]( válido )

Perl 6 , 61 bytes

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

Pruébalo en línea!

Los puntos de código son:

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

Y sí, esos son caracteres Unicode allí. Esta es más o menos mi solución original, con algunos espacios y llaves combinadas.

05AB1E , 10 bytes

¥DÄ/¥(Ä2QP

Pruébalo en línea!

Explicación

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

Los puntos de código son: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

JavaScript (ES6), 62 60 bytes

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

Pruébalo en línea!

Puntos de código:

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 bytes

¥.±¥Ä2/P

Devuelve 1.0para 0.0secuencias en zigzag y no zigzagueantes.

Los puntos de código están [164,108,176,164,195,2,109,25]en la página de códigos 05AB1E .

Pruébalo en línea.

Explicación:

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