Sua tarefa é escrever um programa ou função de computador que obtenha uma lista de números inteiros positivos de pelo menos o comprimento 2 e determine se eles são um "zigue-zague". Uma sequência é um ziguezague se, e somente se, os números se alternarem em maiores e menores do que o número que vem antes deles. Por exemplo e são ziguezagues, mas e não são.[ 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]$

Para sua decisão, você deve gerar um dos dois valores consistentes diferentes para cada possibilidade (em zigue-zague e não em zigue-zague).

Os pontos de código do seu programa ou função também devem ser em zigue-zague. Isso significa que quando você pega a sequência de pontos de código, deve ser um zigue-zague.

Isso é código-golfe, então as respostas serão pontuadas em bytes, com menos bytes sendo melhores.

Gelatina , 5 bytes

IṠIỊẸ

Retorna (em zigue-zague) ou 1 (não em zigue-zague).$0$$1$

Os pontos de código estão na página de códigos Jelly .$[73, 205, 73, 176, 174]$

Experimente online!

Como 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

Experimente online!

Eu queria fazer a bola rolar em termos de respostas de Haskell. Ainda não vejo uma maneira de melhorar isso, mas estou convencido de que isso pode ser feito. Estou ansioso pelo que as pessoas podem fazer daqui.

MATL , 9 bytes

dt?ZSd]pA

Experimente online! Ou verifique todos os casos de teste

Meu primeiro programa de MATL! O penúltimo pfoi adicionado para o requisito em zigue-zague.

Explicação:

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 graças a Jakob
-62 bytes graças 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: ])])` )")

Experimente online!

Os créditos para o algoritmo acidentado vão para esta resposta

input, print, exec, defE lambdanão são acidentado então eu só fui evalpara a esquerda, que é armazenado no e
Há 2 principais maneiras de contornar a restrição, colocando "+"ou entre os pares não-esburacadas, optei para a antiga ( é mais curto para cada uso, mas seria necessário replace(' ','')resultar em mais bytes)
Como printnão é acidentado, não posso usá-lo diretamente e, como não é uma função, não posso usá-lo por dentro eval(), então tive que usar input(result)para gerar o resultado

K (ngn / k) , 23 bytes

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

Experimente online!

Ohm v2 , 5 bytes

δyδ½Å

Experimente online!

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

Como funciona

δyδ½Å - Programa completo / Bloco de argumento único.
δy - Os sinais dos deltas da entrada 
  δ - As diferenças dos sinais. Resulta em uma sequência de 2 ou -2 para
        matrizes irregulares, como os sinais se alternam, dando -1-1 = -2 ou 1 - (- 1) = 2.
    Å - Verifique se todos os elementos produzem resultados verdadeiros quando ...
   ½ - Metade.

Japonês -! , 16 14 bytes

Bem, isso não é bonito, mas estou feliz que funcione!

Saídas truepara zig-zag ou falsese não.

ä'- m'g ä'a èÍ

Tente

Os pontos de código são [228,39,45,32,109,39,103,32,228,39,97,32,232,205]e estão incluídos como teste no link acima.

Explicação

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

Gelatina , 6 bytes

IṠµaIẠ

Experimente online!

Retorna 1por verdade, 0por falsidade.

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

Perl 6 , 61 bytes

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

Experimente online!

Os pontos de código são:

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

E sim, esses são caracteres unicode lá. Esta é mais ou menos a minha solução original, com alguns espaços e suspensórios misturados.

05AB1E , 10 bytes

¥DÄ/¥(Ä2QP

Experimente online!

Explicação

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

Os pontos de código são: [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

Experimente online!

Pontos 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

Retorna 1.0para 0.0sequências em zigue-zague e para não zigue-zague.

Os pontos de código estão [164,108,176,164,195,2,109,25]na página de códigos 05AB1E .

Experimente online.

Explicação:

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