Find the amplitude and number of waves for the given array

Given an array arr[] of N integers, the task is to find the amplitude and number of waves for the given array. If the array is not a wave array then print -1.

Wave Array: An array is a wave array if it is continuously strictly increasing and decreasing or vice-versa. 
Amplitude is defined as the maximum difference of consecutive numbers. 

Examples:

Input: arr[] = {1, 2, 1, 5, 0, 7, -6} 
Output: Amplitude = 13, Waves = 3 
Explanation:
For the array observe the pattern 1->2 (increase), 2->1 (decrease), 1->5 (increase), 5->0 (decrease), 0->7 (increase), 7->-6 (decrease). Amplitude = 13 (between 7 and -6) and total waves = 3
Input: arr[] = {1, 2, 1, 5, 0, 7, 7} 
Output: -1 
Explanation:
The array is not waved array as the last two elements of the array are equal, hence the answer is -1.  

Approach:
The idea is to check for both sides adjacent elements where both must be either less or greater than the current element. If this condition is satisfied then count the number of waves otherwise print -1, where the number of waves is (n – 1) / 2. While traversing the array keep updating the maximum difference between the consecutive element to get the amplitude of the given wave array. 

Below is the implementation of the above approach: 

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the amplitude and
// number of waves for the given array
bool check(int a[], int n)
{
    int ma = a[1] - a[0];

    // Check for both sides adjacent
    // elements that both must be less
    // or both must be greater
    // than current element
    for (int i = 1; i < n - 1; i++) {

        if ((a[i] > a[i - 1]
             && a[i + 1] < a[i])
            || (a[i] < a[i - 1]
                && a[i + 1] > a[i]))

            // Update amplitude with max value
            ma = max(ma, abs(a[i] - a[i + 1]));

        else
            return false;
    }

    // Print the Amplitude
    cout << "Amplitude = " << ma;
    cout << endl;
    return true;
}

// Driver Code
int main()
{
    // Given array a[]
    int a[] = { 1, 2, 1, 5, 0, 7, -6 };
    int n = sizeof a / sizeof a[0];

    // Calculate number of waves
    int wave = (n - 1) / 2;

    // Function Call
    if (check(a, n))
        cout << "Waves = " << wave;
    else
        cout << "-1";

    return 0;
}

Java

// Java program for the above approach
import java.util.*;
class GFG{

// Function to find the amplitude and
// number of waves for the given array
static boolean check(int a[], int n)
{
    int ma = a[1] - a[0];

    // Check for both sides adjacent
    // elements that both must be less
    // or both must be greater
    // than current element
    for (int i = 1; i < n - 1; i++)
    {
        if ((a[i] > a[i - 1] &&
             a[i + 1] < a[i]) ||
            (a[i] < a[i - 1] &&
             a[i + 1] > a[i]))

            // Update amplitude with max value
            ma = Math.max(ma, Math.abs(a[i] - a[i + 1]));

        else
            return false;
    }

    // Print the Amplitude
    System.out.print("Amplitude = " +  ma);
    System.out.println();
    return true;
}

// Driver Code
public static void main(String[] args)
{
    // Given array a[]
    int a[] = { 1, 2, 1, 5, 0, 7, -6 };
    int n = a.length;

    // Calculate number of waves
    int wave = (n - 1) / 2;

    // Function Call
    if (check(a, n))
        System.out.print("Waves = " +  wave);
    else
        System.out.print("-1");
}
}

// This code is contributed by sapnasingh4991

Python3

# Python3 program for the above approach

# Function to find the amplitude and
# number of waves for the given array
def check(a, n):
    ma = a[1] - a[0]

    # Check for both sides adjacent
    # elements that both must be less
    # or both must be greater
    # than current element
    for i in range(1, n - 1):

        if ((a[i] > a[i - 1] and
             a[i + 1] < a[i]) or
            (a[i] < a[i - 1] and
             a[i + 1] > a[i])):

            # Update amplitude with max value
            ma = max(ma, abs(a[i] - a[i + 1]))

        else:
            return False

    # Print the Amplitude
    print("Amplitude = ", ma)
    return True

# Driver Code
if __name__ == '__main__':

    # Given array a[]
    a = [1, 2, 1, 5, 0, 7, -6]
    n = len(a)

    # Calculate number of waves
    wave = (n - 1) // 2

    # Function Call
    if (check(a, n)):
        print("Waves = ",wave)
    else:
        print("-1")

# This code is contributed by Mohit Kumar

C#

// C# program for the above approach
using System;
class GFG{

// Function to find the amplitude and
// number of waves for the given array
static bool check(int []a, int n)
{
    int ma = a[1] - a[0];

    // Check for both sides adjacent
    // elements that both must be less
    // or both must be greater
    // than current element
    for (int i = 1; i < n - 1; i++)
    {
        if ((a[i] > a[i - 1] &&
             a[i + 1] < a[i]) ||
            (a[i] < a[i - 1] &&
             a[i + 1] > a[i]))

            // Update amplitude with max value
            ma = Math.Max(ma, Math.Abs(a[i] - a[i + 1]));
        else
            return false;
    }

    // Print the Amplitude
    Console.Write("Amplitude = " + ma);
    Console.WriteLine();
    return true;
}

// Driver Code
public static void Main(String[] args)
{
    // Given array []a
    int []a = { 1, 2, 1, 5, 0, 7, -6 };
    int n = a.Length;

    // Calculate number of waves
    int wave = (n - 1) / 2;

    // Function Call
    if (check(a, n))
        Console.Write("Waves = " + wave);
    else
        Console.Write("-1");
}
}

// This code is contributed by sapnasingh4991

Javascript

<script>
// JavaScript program for the above approach

// Function to find the amplitude and
// number of waves for the given array
function check(a, n)
{
    let ma = a[1] - a[0];

    // Check for both sides adjacent
    // elements that both must be less
    // or both must be greater
    // than current element
    for (let i = 1; i < n - 1; i++)
    {
        if ((a[i] > a[i - 1] &&
             a[i + 1] < a[i]) ||
            (a[i] < a[i - 1] &&
             a[i + 1] > a[i]))

            // Update amplitude with max value
            ma = Math.max(ma, Math.abs(a[i] - a[i + 1]));

        else
            return false;
    }

    // Print the Amplitude
    document.write("Amplitude = " +  ma);
    document.write("<br/>");
    return true;
}

// Driver Code

           // Given array a[]
    let a = [ 1, 2, 1, 5, 0, 7, -6 ];
    let n = a.length;

    // Calculate number of waves
    let wave = (n - 1) / 2;

    // Function Call
    if (check(a, n))
        document.write("Waves = " +  wave);
    else
        document.write("-1");

</script>

Output:

Amplitude = 13
Waves = 3

Time Complexity: O(N) 
Auxiliary Space: O(1)