Compruebe si la array dada es monotónica

Dada una array arr[] que contiene N enteros, la tarea es verificar si la array es monótona o no (monotónica significa que la array está en orden creciente o decreciente).

Ejemplos:

Entrada: arr[] = {1, 2, 2, 3}
Salida: Sí
Explicación: Aquí 1 < 2 <= 2 < 3. 
La array está en orden creciente. Por lo tanto, es monótono.

Entrada: arr[] = {6, 5, 4, 3}
Salida: Sí
Explicación: Aquí 6 > 5 > 4 > 3. 
La array está en orden decreciente. Entonces es monótono.

Entrada: arr[] = {1, 5, 2}
Salida: No
Explicación: Aquí 1 < 5 > 2. La array no aumenta ni disminuye. 
Entonces la array no es monótona.

Enfoque: el problema se puede resolver comprobando si la array está en orden creciente o decreciente. Esto se puede hacer fácilmente de la siguiente manera:

• Si para cada i en el rango [0, N-2], arr[i] ≥ arr[i+1] el arreglo está en orden decreciente.
• Si para cada i en el rango [0, N-2], arr[i] ≤ arr[i+1] , la array está en orden creciente.

Siga los pasos a continuación para resolver el problema:

• Atraviese la array arr[] de i = 0 a N-2 y verifique si la array aumenta en orden
• Atraviese la array arr[] de i = 0 a N-2 y verifique si la array está disminuyendo en orden
• Si ninguno de los dos anteriores es cierto, entonces la array no es monótona.

A continuación se muestra la implementación del enfoque anterior:

// C++ program for above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check array is monotonic
bool check(vector<int>& arr)
{
    int N = arr.size();
    bool inc = true;
    bool dec = true;
 
    // Loop to check if array is increasing
    for (int i = 0; i < N - 1; i++) {
 
        // To check if
        // array is not increasing
        if (arr[i] > arr[i + 1]) {
            inc = false;
        }
    }
 
    // Loop to check if array is decreasing
    for (int i = 0; i < N - 1; i++) {
 
        // To check if
        // array is not decreasing
        if (arr[i] < arr[i + 1]) {
            dec = false;
        }
    }
 
    // Pick one whether inc or dec
    return inc || dec;
}
 
// Driver code
int main()
{
    vector<int> arr = { 1, 2, 3, 3 };
 
    // Function call
    bool ans = check(arr);
    if (ans)
        cout << "Yes";
    else
        cout << "No";
    return 0;
}

// Java program for above approach
import java.io.*;
 
class GFG {
 
  // Function to check array is monotonic
  static boolean check(int arr[])
  {
    int N = arr.length;
    boolean inc = true;
    boolean dec = true;
 
    // Loop to check if array is increasing
    for (int i = 0; i < N - 1; i++) {
 
      // To check if
      // array is not increasing
      if (arr[i] > arr[i + 1]) {
        inc = false;
      }
    }
 
    // Loop to check if array is decreasing
    for (int i = 0; i < N - 1; i++) {
 
      // To check if
      // array is not decreasing
      if (arr[i] < arr[i + 1]) {
        dec = false;
      }
    }
 
    // Pick one whether inc or dec
    return inc || dec;
  }
 
  // Driver code
  public static void main (String[] args) {
    int arr[] = { 1, 2, 3, 3 };
 
    // Function call
    boolean ans = check(arr);
    if (ans == true)
      System.out.print("Yes");
    else
      System.out.print("No");
  }
}
 
// This code is contributed by hrithikgarg03188.

# Python program for above approach
 
# Function to check array is monotonic
def check(arr):
    N = len(arr)
    inc = True
    dec = True
     
    # Loop to check if array is increasing
    for i in range(0, N-1):
       
        # To check if array is not increasing
        if arr[i] > arr[i+1]:
            inc = False
 
    # Loop to check if array is decreasing
    for i in range(0, N-1):
       
       # To check if array is not decreasing
        if arr[i] < arr[i+1]:
            dec = False
 
    # Pick one whether inc or dec
    return inc or dec
 
# Driver code
if __name__ == "__main__":
    arr = [1, 2, 3, 3]
 
    # Function call
    ans = check(arr)
    if ans == True:
        print("Yes")
    else:
        print("No")
 
# This code is contributed by Rohit Pradhan

// C# program for above approach
using System;
class GFG {
 
  // Function to check array is monotonic
  static bool check(int[] arr)
  {
    int N = arr.Length;
    bool inc = true;
    bool dec = true;
 
    // Loop to check if array is increasing
    for (int i = 0; i < N - 1; i++) {
 
      // To check if
      // array is not increasing
      if (arr[i] > arr[i + 1]) {
        inc = false;
      }
    }
 
    // Loop to check if array is decreasing
    for (int i = 0; i < N - 1; i++) {
 
      // To check if
      // array is not decreasing
      if (arr[i] < arr[i + 1]) {
        dec = false;
      }
    }
 
    // Pick one whether inc or dec
    return (inc || dec);
  }
 
  // Driver code
  public static void Main()
  {
    int[] arr = { 1, 2, 3, 3 };
 
    // Function call
    bool ans = check(arr);
    if (ans)
      Console.Write("Yes");
    else
      Console.Write("No");
  }
}
 
// This code is contributed by Samim Hossain Mondal.

<script>
    // JavaScript program for above approach
 
    // Function to check array is monotonic
    const check = (arr) => {
        let N = arr.length;
        let inc = true;
        let dec = true;
 
        // Loop to check if array is increasing
        for (let i = 0; i < N - 1; i++) {
 
            // To check if
            // array is not increasing
            if (arr[i] > arr[i + 1]) {
                inc = false;
            }
        }
 
        // Loop to check if array is decreasing
        for (let i = 0; i < N - 1; i++) {
 
            // To check if
            // array is not decreasing
            if (arr[i] < arr[i + 1]) {
                dec = false;
            }
        }
 
        // Pick one whether inc or dec
        return inc || dec;
    }
 
    // Driver code
    let arr = [1, 2, 3, 3];
 
    // Function call
    let ans = check(arr);
    if (ans)
        document.write("Yes");
    else
        document.write("No");
         
// This code is contributed by rakeshsahni
 
</script>

Yes

Complejidad temporal: O(N)
Espacio auxiliar: O(1)

Otro enfoque: (JavaScript) En este enfoque, se usará el método de array de JavaScript, denominado como every() y, por lo tanto, verificaremos aún más con este método si la array pasada es de naturaleza monotónica o no.

Siga los pasos mencionados a continuación:

• Recorra la array usando el método every() y verifique si el elemento actual es más pequeño que el elemento anterior.
• De manera similar, nuevamente usando el método every() , así como con el uso del operador lógico OR ( | | ), verifique si el elemento actual es mayor que el elemento anterior o no.
• Devuelve verdadero si se descubre la secuencia creciente o la secuencia decreciente.

A continuación se muestra la implementación del enfoque anterior:

let checkMonotonic = (array) => {
  return (
    // First check for decreasing order sequence...
 
    array.every(
      (element, index) => index === 0 || element <= array[index - 1]
    ) ||
    // Then check for increasing order sequence...
    array.every((element, index) => index === 0 || element >= array[index - 1])
  );
};
 
console.log("Is Monotonic ?: " + checkMonotonic([7, 5, 3, 1]));
console.log("Is Monotonic ?: " + checkMonotonic([4, 0, 3, 1]));
console.log("Is Monotonic ?: " + checkMonotonic([5, 4, 3]));
 
 
// This code is contributed by Aman Singla...

Producción:

Is Monotonic ?: true
Is Monotonic ?: false
Is Monotonic ?: true