Votre tâche consiste à écrire un programme ou une fonction informatique qui prend une liste d'entiers positifs d'au moins 2 et détermine s'il s'agit d'un "zigzag". Une séquence est un zigzag si et seulement si les nombres alternent en étant plus grands et plus petits que le nombre qui les précède. Par exemple, et sont des zigzags mais et ne le sont pas.$[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]$

Pour votre décision, vous devez sortir l'une des deux valeurs cohérentes différentes pour chaque possibilité (zigzag et non zigzag).

Les points de code de votre programme ou fonction doivent également être un zigzag lui-même. Cela signifie que lorsque vous prenez la séquence de points de code, il doit s'agir d'un zigzag.

Il s'agit de code-golf donc les réponses seront notées en octets avec moins d'octets mieux.

Gelée , 5 octets

IṠIỊẸ

Renvoie (zigzag) ou 1 (pas zigzag).$0$$1$

Les points de code sont dans la page de codes Jelly .$[73, 205, 73, 176, 174]$

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

Je voulais faire bouger les choses en termes de réponses Haskell. Je ne vois pas encore de moyen d'améliorer cela, mais je suis convaincu que cela peut être fait. J'ai hâte de voir ce que les gens peuvent faire d'ici.

MATL , 9 octets

dt?ZSd]pA

Essayez-le en ligne! Ou vérifiez tous les cas de test

Mon tout premier programme MATL! L'avant-dernier a pété ajouté pour l'exigence de zigzag.

Explication:

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 octets

^{-2 octets grâce à Jakob
-62 octets grâce à 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: ])])` )")

Essayez-le en ligne!

Les crédits pour l'algorithme cahoteux vont à cette réponse

input, print, exec, defEt lambdane sont pas bosselée donc je ne suis evalparti, ce qui est stocké sur e
Il existe 2 façons de contourner la restriction, en plaçant "+"ou entre les paires non bosselées, j'ai opté pour l'ancien ( est plus courte pour chaque utilisation, mais il faudrait qu'il en replace(' ','')résulte plus d'octets.)
Comme ce printn'est pas cahoteux, je ne peux pas l'utiliser directement, et comme ce n'est pas une fonction, je ne peux pas l'utiliser à l'intérieur eval(), donc j'ai dû utiliser input(result)pour sortir le résultat

K (ngn / k) , 23 octets

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

Essayez-le en ligne!

Ohm v2 , 5 octets

δyδ½Å

Essayez-le en ligne!

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

Comment ça fonctionne

δyδ½Å - Programme complet / bloc à argument unique.
δy - Les signes des deltas de l'entrée 
  δ - Les différences des signes. Résultats dans une séquence de 2 ou -2 pour
        tableaux cahoteux, comme les signes alternent, donnant soit -1-1 = -2 ou 1 - (- 1) = 2.
    Å - Vérifiez si tous les éléments donnent des résultats véridiques lorsque ...
   ½ - Coupé en deux.

Japt -! , 16 14 octets

Eh bien, ce n'est pas joli mais je suis juste content que ça marche!

Sorties truepour zig-zag ou falsesinon.

ä'- m'g ä'a èÍ

Essayez-le

Les points de code sont [228,39,45,32,109,39,103,32,228,39,97,32,232,205]et sont inclus comme test dans le lien ci-dessus.

Explication

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

Gelée , 6 octets

IṠµaIẠ

Essayez-le en ligne!

Retourne 1pour la vérité, 0pour la fausseté.

Codepoints : [73, 205, 9, 97, 73, 171]( valide )

Perl 6 , 61 octets

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

Essayez-le en ligne!

Les points de code sont:

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

Et oui, ce sont des caractères unicode là-dedans. C'est plus ou moins ma solution d'origine, avec quelques espaces et accolades mélangés.

05AB1E , 10 octets

¥DÄ/¥(Ä2QP

Essayez-le en ligne!

Explication

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

Les points de code sont: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

JavaScript (ES6), 62 60 octets

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

Essayez-le en ligne!

Points de code:

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 octets

¥.±¥Ä2/P

Renvoie 1.0pour les 0.0séquences en zigzag et pour les séquences sans zigzag.

Les points de code se trouvent [164,108,176,164,195,2,109,25]dans la page de codes 05AB1E .

Essayez-le en ligne.

Explication:

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