Type of array (Ascending, Descending, Left or Right Rotated)

You are given an array arr[] having unique elements. Your task is to return the type of array described below.

Return 1 if the array is in ascending order
Return 2 if the array is in descending order
Return 3 if the array is in descending rotated order
Return 4 if the array is in ascending rotated order

You may assume that the input array is always one of the four types.

Examples:

Input: arr[] = [2, 1, 5, 4, 3]
Output: 3
Explanation: Descending rotated, rotate 2 times left.
Input: arr[] = [3, 4, 5, 1, 2]
Output: 4
Explanation: Ascending rotated, rotate 2 times right.

Try It Yourself

Table of Content

[Naive Approach] Using Single Pass Order Detection - O(n) Time O(1) Space
[Expected Approach] Using Maximum Element Position - O(n) Time O(1) Space

[Naive Approach] Using Single Pass Order Detection - O(n) Time O(1) Space

The Idea is to Traverse the array once to find where the sorted order breaks. If no break occurs, the array is ascending or descending. If a break appears in between, the array is rotated. The position of the first break point (i) determines the type of array.

Algorithm:

Start from index 0 and move forward while elements are in increasing order.
If traversal reaches the end, the array is Ascending -> return 1.
If the order breaks at index 0, check if the array is fully decreasing -> return 2.
If not fully decreasing, decide rotation: increasing next -> Descending Rotated (3), else Ascending Rotated (4).
If the array was partially increasing, use the next element to classify -> Ascending Rotated (4) or Descending Rotated (3).

C++

// C++ program to find type of array, ascending
// descending, clockwise rotated or anti-clockwise
// rotated.
#include <bits/stdc++.h>
using namespace std;

// Function to find the type of an array
// and maximum element in it.
int typeOfArr(vector<int> &arr)
{
    int n = arr.size();
    int i = 0;

    // Check ascending
    while (i < n - 1 && arr[i] <= arr[i + 1])
        i++;

    // array increasing to Ascending
    if (i == n - 1)
    {
        return 1;
    }

    // decreasing
    if (i == 0)
    {
        while (i < n - 1 && arr[i] >= arr[i + 1])
            i++;

        // array decreasing is Descending
        if (i == n - 1)
        {
            return 2;
        }

        // Rotated cases
        if (arr[0] < arr[i + 1])
        {
            return 3; // Descending Rotated
        }
        else
        {
            return 4; // Ascending Rotated
        }
    }

    // Partially increasing → Ascending Rotated
    if (i < n - 1 && arr[0] > arr[i + 1])
    {
        return 4;
    }

    // Otherwise Descending Rotated
    return 3;
}

// Driver code
int main() {
    vector<int> arr = {2, 1, 5, 4, 3};

    int result = typeOfArr(arr);

    cout << "Type of array: " << result << endl;

    return 0;
}

#include <stdio.h>

// Function to find the type of an array
// and maximum element in it.
int typeOfArr(int arr[], int n)
{
    int i = 0;

    // Check ascending
    while (i < n - 1 && arr[i] <= arr[i + 1])
        i++;

    // array increasing to Ascending
    if (i == n - 1)
    {
        return 1;
    }

    // decreasing
    if (i == 0)
    {
        while (i < n - 1 && arr[i] >= arr[i + 1])
            i++;

        // array decreasing is Descending
        if (i == n - 1)
        {
            return 2;
        }

        // Rotated cases
        if (arr[0] < arr[i + 1])
        {
            return 3; // Descending Rotated
        }
        else
        {
            return 4; // Ascending Rotated
        }
    }

    // Partially increasing → Ascending Rotated
    if (i < n - 1 && arr[0] > arr[i + 1])
    {
        return 4;
    }

    // Otherwise Descending Rotated
    return 3;
}

// Driver code
int main() {
    int arr[] = {2, 1, 5, 4, 3};
    int n = sizeof(arr) / sizeof(arr[0]);

    int result = typeOfArr(arr, n);

    printf("Type of array: %d\n", result);

    return 0;
}

Java

import java.util.*;

// Function to find the type of an array
// and maximum element in it.
public class GfG {
    public static int typeOfArr(int[] arr) {
        int n = arr.length;
        int i = 0;

        // Check ascending
        while (i < n - 1 && arr[i] <= arr[i + 1])
            i++;

        // array increasing to Ascending
        if (i == n - 1)
        {
            return 1;
        }

        // decreasing
        if (i == 0)
        {
            while (i < n - 1 && arr[i] >= arr[i + 1])
                i++;

            // array decreasing is Descending
            if (i == n - 1)
            {
                return 2;
            }

            // Rotated cases
            if (arr[0] < arr[i + 1])
            {
                return 3; // Descending Rotated
            }
            else
            {
                return 4; // Ascending Rotated
            }
        }

        // Partially increasing → Ascending Rotated
        if (i < n - 1 && arr[0] > arr[i + 1])
        {
            return 4;
        }

        // Otherwise Descending Rotated
        return 3;
    }

    // Driver code
    public static void main(String[] args) {
        int[] arr = {2, 1, 5, 4, 3};

        int result = typeOfArr(arr);

        System.out.println("Type of array: " + result);
    }
}

Python

class Solution:
    
    # Function to find the type of an array
    # and maximum element in it.
    def typeOfArr(self, arr):
        n = len(arr)
        i = 0

        # Check ascending
        while i < n - 1 and arr[i] <= arr[i + 1]:
            i += 1

        # array increasing to Ascending
        if i == n - 1:
            return 1

        # decreasing
        if i == 0:
            while i < n - 1 and arr[i] >= arr[i + 1]:
                i += 1

            # array decreasing is Descending
            if i == n - 1:
                return 2

            # Rotated cases
            if arr[0] < arr[i + 1]:
                return 3  # Descending Rotated
            else:
                return 4  # Ascending Rotated

        # Partially increasing → Ascending Rotated
        if i < n - 1 and arr[0] > arr[i + 1]:
            return 4

        # Otherwise Descending Rotated
        return 3


# Driver code
if __name__ == "__main__":
    arr = [2, 1, 5, 4, 3]

    obj = Solution()
    result = obj.typeOfArr(arr)

    print("Type of array:", result)

// C# program to find type of array, ascending
// descending, clockwise rotated or anti-clockwise
// rotated.
using System;
using System.Collections.Generic;

class GfG
{
    // Function to find the type of an array
    // and maximum element in it.
    static int typeOfArr(List<int> arr)
    {
        int n = arr.Count;
        int i = 0;

        // Check ascending
        while (i < n - 1 && arr[i] <= arr[i + 1])
            i++;

        // array increasing to Ascending
        if (i == n - 1)
        {
            return 1;
        }

        // decreasing
        if (i == 0)
        {
            while (i < n - 1 && arr[i] >= arr[i + 1])
                i++;

            // array decreasing is Descending
            if (i == n - 1)
            {
                return 2;
            }

            // Rotated cases
            if (arr[0] < arr[i + 1])
            {
                return 3; // Descending Rotated
            }
            else
            {
                return 4; // Ascending Rotated
            }
        }

        // Partially increasing → Ascending Rotated
        if (i < n - 1 && arr[0] > arr[i + 1])
        {
            return 4;
        }

        // Otherwise Descending Rotated
        return 3;
    }

    // Driver code
    static void Main()
    {
        List<int> arr = new List<int> { 2, 1, 5, 4, 3 };

        int result = typeOfArr(arr);

        Console.WriteLine("Type of array: " + result);
    }
}

JavaScript

// JavaScript program to find type of array, ascending
// descending, clockwise rotated or anti-clockwise
// rotated.

// Function to find the type of an array
// and maximum element in it.
function typeOfArr(arr) {
    let n = arr.length;
    let i = 0;

    // Check ascending
    while (i < n - 1 && arr[i] <= arr[i + 1])
        i++;

    // array increasing to Ascending
    if (i == n - 1)
    {
        return 1;
    }

    // decreasing
    if (i == 0)
    {
        while (i < n - 1 && arr[i] >= arr[i + 1])
            i++;

        // array decreasing is Descending
        if (i == n - 1)
        {
            return 2;
        }

        // Rotated cases
        if (arr[0] < arr[i + 1])
        {
            return 3; // Descending Rotated
        }
        else
        {
            return 4; // Ascending Rotated
        }
    }

    // Partially increasing → Ascending Rotated
    if (i < n - 1 && arr[0] > arr[i + 1])
    {
        return 4;
    }

    // Otherwise Descending Rotated
    return 3;
}

// Driver code
let arr = [2, 1, 5, 4, 3];

let result = typeOfArr(arr);

console.log("Type of array: " + result);

Output

Type of array: 3

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

[Expected Approach] Using Maximum Element Position - O(n) Time O(1) Space

The Idea is to traverse the array to find the maximum element and its index. If the maximum is at the start, the array is descending; if at the end, it is ascending. Otherwise, the array is rotated, and its type is determined using the neighbors of the maximum element.