Detecting zigzags in an array using python

Question

I'm new to programming and studying python. I solved the following "zigzag" question using python language.

You are given an array of integers and your task is to check all the triples of its consecutive elements for being a zigzag.

zigzag- This means for any consecutive triples which holds $ac$ or $a>b<c.$

for example:

• if the array is [2, 3, 1, 4] the output is [1,1] since 2<3>1 and 3>1<4
• if the array is [4, 3, 6, 4, 2] the output is [1, 1, 0] since 4>3<6 and 3<6>4

I have a constraints for the length of the array(<10000) and value of single element(<1000) of the array. Although it's working, I'm not sure whether it is the proper way of coding for these type of questions. I would like to hear your suggestions.

This is my code.

`import sys
import numpy as np
a = np.array([])
b = np.array([])
n = int(input("Enter the length of the array:"))
if 3 < n < 10000:
    for j in range(n):
        x = int(input("Enter inputs:"))
        if x < 1000:
            a = np.append(a, [x])
        else:
            sys.exit("Value is not less than 1000")
    print(a)

    i = 0
    while i < len(a) - 2:
        if a[i] < a[i + 1] and a[i + 1] > a[i + 2]:
            b = np.append(b, [1])
        elif a[i] > a[i + 1] and a[i + 1] < a[i + 2]:
            b = np.append(b, [1])
        else:
            b = np.append(b, [0])
        i += 1

    print(b)
else:
    print("Length is out of bound")`

Answer 1

Since you are using numpy, you could take benefit of sliding_window_view.

For example, something like

view=np.lib.stride_tricks.sliding_window_view(a,(3,))
res=(view[:,1]<view[:,[0,2]].min(axis=1)) | (view[:,1]>view[:,[0,2]].max(axis=1))

In your examples, view would be

array([[2, 3, 1],
       [3, 1, 4]])

and

array([[4, 3, 6],
       [3, 6, 4],
       [6, 4, 2]])

So, rows of triplets of successive elements.

The beauty of it, is that it is a view, not really and array. It doesn't use extra memory. It is just your original array, viewed differently.

From there, there are many way to vectorize your computation. Above, I've chosen to say that a row (that is a triplet) is a zig zag if the center (view[:,1]) element is smaller than the minimum of the outer elements (view[:,[0,2]]), or on the contrary, bigger than the maximum.

Or, I could have done explicitly the same test you did

((view[:,0]>view[:,1]) & (view[:,2]>view[:,1])) | ((view[:,0]<view[:,1]) & (view[:,2]<view[:,1]))

Point is, I do it on whole vectors, not on rows.

Without numpy, you could also use list comprehension

[a[i]>a[i+1]<a[i+2] or a[i]<a[i+1]>a[i+2] for i in range(len(a)-2)]

for example