Programa Java para verificar si es posible hacer que la array aumente o disminuya girando la array

Dada una array arr[] de N elementos distintos, la tarea es verificar si es posible hacer que la array aumente o disminuya rotando la array en cualquier dirección.
Ejemplos: 
 

Entrada: arr[] = {4, 5, 6, 2, 3} 
Salida: Sí  La
array se puede rotar como {2, 3, 4, 5, 6}
Entrada: arr[] = {1, 2, 4, 3 , 5} 
Salida: No 
 

Enfoque: Hay cuatro posibilidades: 
 

  • Si la array ya está aumentando , la respuesta es .
  • Si la array ya está disminuyendo , la respuesta es .
  • Si la array se puede hacer creciente, esto puede ser posible si la array dada primero aumenta hasta el elemento máximo y luego disminuye.
  • Si la array se puede hacer decreciente, esto puede ser posible si la array dada primero disminuye hasta el elemento mínimo y luego aumenta.

Si no es posible hacer que la array aumente o disminuya, imprima No.
A continuación se muestra la implementación del enfoque anterior: 
 

Java

// Java implementation of the approach
class GFG
{
     
// Function that returns true if the array
// can be made increasing or decreasing
// after rotating it in any direction
static boolean isPossible(int a[], int n)
{
    // If size of the array is less than 3
    if (n <= 2)
        return true;
 
    int flag = 0;
     
    // Check if the array is already decreasing
    for (int i = 0; i < n - 2; i++)
    {
        if (!(a[i] > a[i + 1] &&
              a[i + 1] > a[i + 2]))
        {
            flag = 1;
            break;
        }
    }
 
    // If the array is already decreasing
    if (flag == 0)
        return true;
 
    flag = 0;
     
    // Check if the array is already increasing
    for (int i = 0; i < n - 2; i++)
    {
        if (!(a[i] < a[i + 1] &&
              a[i + 1] < a[i + 2]))
        {
            flag = 1;
            break;
        }
    }
 
    // If the array is already increasing
    if (flag == 0)
        return true;
 
    // Find the indices of the minimum
    // && the maximum value
    int val1 = Integer.MAX_VALUE, mini = -1,
        val2 = Integer.MIN_VALUE, maxi = 0;
    for (int i = 0; i < n; i++)
    {
        if (a[i] < val1)
        {
            mini = i;
            val1 = a[i];
        }
        if (a[i] > val2)
        {
            maxi = i;
            val2 = a[i];
        }
    }
 
    flag = 1;
     
    // Check if we can make array increasing
    for (int i = 0; i < maxi; i++)
    {
        if (a[i] > a[i + 1])
        {
            flag = 0;
            break;
        }
    }
 
    // If the array is increasing upto max index
    // && minimum element is right to maximum
    if (flag == 1 && maxi + 1 == mini)
    {
        flag = 1;
         
        // Check if array increasing again or not
        for (int i = mini; i < n - 1; i++)
        {
            if (a[i] > a[i + 1])
            {
                flag = 0;
                break;
            }
        }
        if (flag == 1)
            return true;
    }
 
    flag = 1;
     
    // Check if we can make array decreasing
    for (int i = 0; i < mini; i++)
    {
        if (a[i] < a[i + 1])
        {
            flag = 0;
            break;
        }
    }
 
    // If the array is decreasing upto min index
    // && minimum element is left to maximum
    if (flag == 1 && maxi - 1 == mini)
    {
        flag = 1;
 
        // Check if array decreasing again or not
        for (int i = maxi; i < n - 1; i++)
        {
            if (a[i] < a[i + 1])
            {
                flag = 0;
                break;
            }
        }
        if (flag == 1)
            return true;
    }
 
    // If it is not possible to make the
    // array increasing or decreasing
    return false;
}
 
// Driver code
public static void main(String args[])
{
    int a[] = { 4, 5, 6, 2, 3 };
    int n = a.length;
 
    if (isPossible(a, n))
        System.out.println( "Yes");
    else
        System.out.println( "No");
}
}
 
// This code is contributed by Arnab Kundu
Producción: 

Yes

 

Complejidad de tiempo: O(n), donde n representa el tamaño de la array dada.

Espacio auxiliar: O(1), no se requiere espacio adicional, por lo que es una constante.

¡ Consulte el artículo completo sobre Comprobar si es posible hacer que la array aumente o disminuya girando la array para obtener más detalles!
 

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *