Ihre Aufgabe ist es, ein Computerprogramm oder eine Funktion zu schreiben, die eine Liste positiver Ganzzahlen von mindestens Länge 2 erstellt und feststellt, ob es sich um "Zickzack" handelt. Eine Sequenz ist nur dann ein Zickzack, wenn die Zahlen abwechselnd größer und kleiner sind als die Zahl, die vor ihnen steht. Zum Beispiel sind und [ 4 , 2 , 3 , 0 , 1 ] Zickzacke, aber und sind nicht.$[1,2,0,3,2]$$[4,2,3,0,1]$$[1,2,0,0,3,1]$$[1,2,3,1]$

Für Ihre Entscheidung sollten Sie für jede Möglichkeit einen von zwei verschiedenen konsistenten Werten ausgeben (Zickzack und nicht Zickzack).

Die Code-Punkte Ihres Programms oder Ihrer Funktion müssen auch selbst ein Zick-Zack sein. Das heißt, wenn Sie die Sequenz der Codepunkte nehmen, sollte es ein Zickzack sein.

Dies ist Codegolf, daher werden die Antworten in Bytes bewertet, wobei weniger Bytes besser sind.

Gelee , 5 Bytes

IṠIỊẸ

Gibt (Zickzack) oder 1 (nicht Zickzack) zurück.$0$$1$

Die Codepunkte sind in der Jelly-Codepage .$[73, 205, 73, 176, 174]$

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online!

Ich wollte den Ball ins Rollen bringen, was die Antworten von Haskell angeht. Ich kann noch keinen Weg finden, dies zu verbessern, aber ich bin überzeugt, dass dies möglich ist. Ich freue mich darauf, was die Leute von hier aus tun können.

MATL , 9 Bytes

dt?ZSd]pA

Probieren Sie es online! Oder überprüfen Sie alle Testfälle

Mein erstes MATL-Programm! Das vorletzte pwurde für die Zick-Zack-Anforderung hinzugefügt.

Erläuterung:

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 dank Jakob
-62 Bytes dank 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: ])])` )")

Probieren Sie es online!

Credits für den holprigen Algorithmus gehen an diese Antwort

input, print, exec, defUnd lambdasind nicht so holprig I bekam nur evallinks, die auf gespeichert e
Es 2 wichtigsten Möglichkeiten zur Umgehung der Beschränkung sind, Anordnen "+"oder zwischen den nicht holprigen Paaren I entschied sich für die erstere ( ist für jede Verwendung kürzer, aber es müsste replace(' ','')mehr Bytes ergeben)
Da printes nicht holprig ist, kann ich es nicht direkt verwenden, und da es keine Funktion ist, kann ich es nicht im Inneren verwenden eval(), also musste ich es verwenden, input(result)um das Ergebnis auszugeben

K (ngn / k) , 23 Bytes

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

Probieren Sie es online!

Ohm v2 , 5 Bytes

δyδ½Å

Probieren Sie es online!

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

Wie es funktioniert

δyδ½Å - Vollständiges Programm / Block mit einem Argument.
δy - Die Vorzeichen der Deltas der Eingabe 
  δ - Die Unterschiede der Vorzeichen. Ergibt eine Folge von 2 oder -2 für
        holprige Arrays, wenn sich die Zeichen abwechseln, was entweder -1-1 = -2 oder 1 - (- 1) = 2 ergibt.
    Å - Überprüfen Sie, ob alle Elemente wahrheitsgemäße Ergebnisse liefern, wenn ...
   ½ - halbiert.

Japt -! , 16 14 Bytes

Nun, das ist nicht schön, aber ich bin froh, dass es funktioniert!

Ausgänge truefür Zick-Zack oder falsewenn nicht.

ä'- m'g ä'a èÍ

Versuch es

Codepunkte sind [228,39,45,32,109,39,103,32,228,39,97,32,232,205]und als Test im obigen Link enthalten.

Erläuterung

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

Gelee , 6 Bytes

IṠµaIẠ

Probieren Sie es online!

1Kehrt zurück für Wahres, 0für Falsches.

Codepunkte : [73, 205, 9, 97, 73, 171]( gültig )

Perl 6 , 61 Bytes

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

Probieren Sie es online!

Die Codepunkte sind:

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

Und ja, das sind Unicode-Zeichen. Dies ist mehr oder weniger meine ursprüngliche Lösung, mit ein paar Leerzeichen und geschweiften Klammern.

05AB1E , 10 Bytes

¥DÄ/¥(Ä2QP

Probieren Sie es online!

Erläuterung

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

Codepunkte sind: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]

JavaScript (ES6), 62 - 60 Byte

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

Probieren Sie es online!

Code Punkte:

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

Gibt 1.0für zickzackförmige und 0.0nicht zickzackförmige Sequenzen zurück.

Die Codepunkte befinden sich [164,108,176,164,195,2,109,25]auf der Codepage 05AB1E .

Probieren Sie es online aus.

Erläuterung:

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