# In for a bumpy ride

Your task is to write a computer program or function that takes a list of nonnegative integers of at least length 2 and determines if they are a "zigzag". A sequence is a zigzag if and only if the numbers alternate in being larger and smaller than the number that comes before them. For example $$\[1,2,0,3,2]\$$ and $$\[4,2,3,0,1]\$$ are zigzags but $$\[1,2,0,0,3,1]\$$ and $$\[1,2,3,1]\$$ are not.

For your decision you should output one of two different consistent values for each possibility (zigzag and not zigzag).

The code-points of your program or function must also be a zigzag itself. This means that when you take the sequence of code-points it should be a zigzag.

This is so answers will be scored in bytes with fewer bytes being better.

• A penalty for each non-zigzag in the code points might have been another approach, to allow for a wider variety of languages to participate.
– ngm
Jul 4, 2018 at 15:31
• @ngm I disagree. Introducing bonuses/penalties would make users come up with multiple possible answers (e.g. short one + penalty vs long + no penalty), making answering process slower. Plus, the amount of penalty given will be quite arbitrary, meaning the scoring process wouldn't be that objective. Jul 4, 2018 at 15:34
• Should we take Unicode code points or the code points of the encoding we're using? Jul 4, 2018 at 15:49
• @Dennis The code-points of the encoding you are using. Jul 4, 2018 at 15:50
• @Dennis of course, technically that is true. However, we already established that awarding bonuses for code-golf isn't that ideal because they detract from the main challenge. Penalty in this case would be a negative bonus. Jul 4, 2018 at 17:00

# Jelly, 5 bytes

IṠIỊẸ


Returns $0$ (zigzag) or $1$ (not zigzag).

The code points are $[73, 205, 73, 176, 174]$ in the Jelly code page.

Try it online!

### How it works

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.


# K (ngn/k), 23 bytes

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


Try it online!

• Why are the spaces needed? Jul 4, 2018 at 16:14
• @Zacharý the k code itself wouldn't be bumpy without them
– ngn
Jul 4, 2018 at 16:15
• What do you mean by that? Is it just ngn/k that neads the spaces Jul 4, 2018 at 16:17
• @Zacharý This challenge is restricted-source, and the restriction is that the code must be a zigzag. Jul 4, 2018 at 16:18
• Whoops, forgot about that, too. Jul 4, 2018 at 16:19

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


Try it online!

I wanted to get the ball rolling in terms of Haskell answers. I can't see a way to improve this yet, but I am convinced it can be done. I'm looking forward to what people can do from here.

# MATL, 9 bytes

dt?ZSd]pA


My first ever MATL program! The penultimate p was added for the zigzag requirement.

Explanation:

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 -1s and 1s now)
d  %take the difference of that (so if there are successive 1s or -1s, 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 ")

• Thank you! Yeah, like I mentioned in the answer, I added it only for the zigzag requirement (since the code itself has to go zigzag). ] apparently lives between capital letters and small letters, so d to ] and ] to A would both have been decrements, which isn't allowed. So the p is mainly there to have a codepoint increment between the two. Jul 4, 2018 at 20:18
• Oh, I totally forgot about that requirement. That makes the answer more impressive! Jul 4, 2018 at 20:29

# Python 2, 225223161 139 bytes

-2 bytes thanks to Jakob
-62 bytes thanks to 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: ])]) )")


Try it online!

Credits for the bumpy algorithm goes to this answer

input, print, exec, def and lambda aren't bumpy so I only got eval left, which is stored on e
There are 2 main ways to bypass the restriction, placing "+" or between the non-bumpy pairs, I opted for the former ( is shorter for each use, but it would need replace(' ','') resulting in more bytes)
Since print isn't bumpy, I can't use it directly, and since it isn't a funcion I can't use it inside eval(), so I had to use input(result) to output the result

• Nice. You can substitute ' ' * 0 for ' ' [1: ]. Jul 4, 2018 at 18:17
• You can use input(text) to write to STDOUT. Jul 4, 2018 at 18:38

# Ohm v2, 5 bytes

δyδ½Å


Try it online!

The indices of the characters are $[131,121,131,16,165]$ in the linked code page.

### How it works

δyδ½Å – Full program / Single-argument block.
δy    – The signs of the deltas of the input
δ   – The differences of the signs. Results in a sequences of 2's or -2's for
bumpy arrays, as the signs alternate, giving either -1-1=-2 or 1-(-1)=2.
Å – Check if all elements yield truthy results when...
½  – Halved.


# 05AB1E, 7 5 bytes

¥ü*dZ


-2 bytes by taking the answer from the same challenge without source restriction. All credit goes to @Grimmy, so make sure to upvote his answer as well!!

Outputs 0 for zigzagging and 1 for non-zigzagging sequences.

The code points are [165,252,42,100,90] in the 05AB1E code page.

Try it online.

Original 7-byter:

¥.±¥Ä;P


Outputs 1.0 for zigzagging and 0.0 for non-zigzagging sequences.

The code points are [165,46,177,165,196,59,80] in the 05AB1E code page.

Try it online.

Explanation:

¥        # Take the forward differences (deltas) of the (implicit) input-list
#  i.e. [1,2,0,3,2,3] → [1,-2,3,-1,1]
ü       # For each overlapping pair:
*      #  Multiply them together
#   → [[1,-2],[-2,3],[3,-1],[-1,1]] → [-2,-6,-3,-1]
d     # Check for each whether it's non-negative (>= 0)
#  → [0,0,0,0]
Z    # Take the maximum of that
#  → 0
# (after which it is output implicitly as result)

¥        # Take the forward differences (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)
#  → [1,-1,1,-1,1]
¥     # Calculate the deltas of those
#  → [-2,2,-2,2]
Ä    # Take the absolute value of each
#  → [2,2,2,2]
;   # Halve each
#  → [1.0,1.0,1.0,1.0]
P  # Take the product of the list resulting in either 1.0 or 0.0
#  → 1.0
# (after which it is output implicitly as result)


# Japt-!, 16 14 bytes

Well, this ain't pretty but I'm just happy it works!

Outputs true for zig-zag or false if not.

ä'- m'g ä'a èÍ


Try it

Codepoints are [228,39,45,32,109,39,103,32,228,39,97,32,232,205] and included as the test in the link above.

## Explanation

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

• @KamilDrakari, normally you'd be right but, sadly, they're necessary to meet the restricted-source requirements of the challenge. Otherwise this could be 10 bytes. Jul 4, 2018 at 17:09
• Oh, I didn't see that this was restricted-source. My bad Jul 4, 2018 at 17:11
• @KamilDrakari, don't worry; it looks like you weren't the only one. Jul 4, 2018 at 18:12

# tinylisp, 154 bytes

(d Z(q ( ( X Y T )(i T(i(l X Y )(i(l(h T)Y )(F(c Y T ) ) 0 )(i(l Y X )(i(l Y(h T ) )(F(c Y T ) ) 0)0 ) )(e(e X Y)0
( d F(q ( ( L )(Z(h L )(h(t L ) )(t(t L


Tr y i t o n lin e!

### Explanation

(load library) is disallowed by the source restriction, so we have to use only builtins. Since these are each one character, we can just add spaces wherever necessary to make the codepoints zigzag.

The solution uses a pair of mutually recursive functions. F takes a list of at least two elements and calls Z with three arguments: the first two elements (X and Y) and the remainder of the list (T). Z does most of the work:

• If T is not empty:
• If X is less than Y:
• If head of T is also less than Y, call F with Y prepended to T
• Otherwise, return false
• Else, if Y is less than X:
• If Y is also less than head of T, call F with Y prepended to T
• Otherwise, return false
• Else (X equals Y), return false
• Else (T is empty, X and Y represent a two-element list):
• Return true if X is not equal to Y, false otherwise

Ungolfed:

(load library)
(def zigzag?
(lambda (X Y T)
(if T
(if (less? X Y)
(if
(zigzag-list? (cons Y T))
0)
(if (less? Y X)
(if
(zigzag-list? (cons Y T))
0)
0))
(equal? (equal? X Y) 0))))
(def zigzag-list?
(lambda (L)
(zigzag?
(tail (tail L)))))


# Jelly, 6 bytes

IṠµaIẠ


Try it online!

Returns 1 for truthy, 0 for falsy.

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

# Perl 6, 61 bytes

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


Try it online!

The code points are:

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


And yes, those are unicode characters in there. This is more or less my original solution, with a few spaces and curly braces mixed in.

# 05AB1E, 10 bytes

¥DÄ/¥(Ä2QP


Try it online!

Explanation

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


Code points are: [165, 68, 196, 47, 165, 40, 196, 50, 81, 80]