Il tuo compito è quello di scrivere un programma per computer o una funzione che prende un elenco di numeri interi positivi di almeno lunghezza 2 e determina se sono "a zigzag". Una sequenza è un zigzag se e solo se i numeri si alternano in più grandi e più piccoli del numero che li precede. Ad esempio e sono zigzag ma e non lo sono.$[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]$

Per la tua decisione dovresti produrre uno di due diversi valori coerenti per ogni possibilità (zigzag e non zigzag).

I punti di codice del programma o della funzione devono essere anch'essi a zigzag. Ciò significa che quando si prende la sequenza di punti di codice dovrebbe essere a zigzag.

Si tratta di code-golf, quindi le risposte verranno classificate in byte con un numero inferiore di byte migliori.

Gelatina , 5 byte

IṠIỊẸ

Restituisce (zigzag) o (non zigzag).$0$$1$

I punti di codice sono nella tabella codici Jelly .$[73, 205, 73, 176, 174]$

Provalo online!

Come funziona

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 byte

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

Provalo online!

Volevo far rotolare la palla in termini di risposte di Haskell. Non riesco ancora a vedere un modo per migliorarlo, ma sono convinto che si possa fare. Non vedo l'ora di cosa le persone possano fare da qui.

MATL , 9 byte

dt?ZSd]pA

Provalo online! Oppure verifica tutti i casi di test

Il mio primo programma MATL in assoluto! Il penultimo è pstato aggiunto per il requisito di zigzag.

Spiegazione:

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 byte

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

Provalo online!

I crediti per l'algoritmo irregolare vanno a questa risposta

input, print, exec, defE lambdanon sono irregolari così ho ottenuto solo evala sinistra, che è memorizzato su e
Ci sono 2 modi principali per bypassare la restrizione, ponendo "+"o tra le coppie non sconnesse, ho optato per l'ex ( è più breve per ogni uso, ma avrebbe bisogno di replace(' ','')generare più byte)
Dato che printnon è irregolare, non posso usarlo direttamente, e poiché non è una funzione non posso usarlo all'interno eval(), quindi ho dovuto usare input(result)per produrre il risultato

K (ngn / k) , 23 byte

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

Provalo online!

Ohm v2 , 5 byte

δyδ½Å

Provalo online!

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

Come funziona

δyδ½Å - Blocco programma completo / argomento singolo.
δy - I segni dei delta dell'input 
  δ - Le differenze dei segni. Risultati in sequenze di 2 o -2 per
        matrici irregolari, mentre i segni si alternano, dando -1-1 = -2 o 1 - (- 1) = 2.
    Å - Controlla se tutti gli elementi producono risultati veritieri quando ...
   ½ - Dimezzato.

Japt -! , 16 14 byte

Bene, questo non è carino ma sono solo felice che funzioni!

Uscite trueper zig-zag o in falsecaso contrario.

ä'- m'g ä'a èÍ

Provalo

I punti di codice sono [228,39,45,32,109,39,103,32,228,39,97,32,232,205]e inclusi come test nel link sopra.

Spiegazione

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

IṠµaIẠ

Provalo online!

Ritorna 1per la verità, 0per la falsità.

Codici : [73, 205, 9, 97, 73, 171]( valido )

Perl 6 , 61 byte

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

Provalo online!

I punti di codice sono:

(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 sì, quelli sono personaggi unicode lì dentro. Questa è più o meno la mia soluzione originale, con alcuni spazi e parentesi graffe mescolate.

05AB1E , 10 byte

¥DÄ/¥(Ä2QP

Provalo online!

Spiegazione

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

I punti di codice sono: [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

Provalo online!

Punti codice:

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 byte

¥.±¥Ä2/P

Restituisce 1.0per le 0.0sequenze zigzaganti e non zigzaganti.

I punti di codice si trovano [164,108,176,164,195,2,109,25]nella tabella codici 05AB1E .

Provalo online.

Spiegazione:

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