Producto máximo del elemento anterior y siguiente

Dada una array de enteros, la Tarea es imprimir el Producto Máximo entre la array de modo que su producto de elemento anterior y siguiente sea máximo. 
Nota: La array se puede considerar en el orden cíclico. El elemento anterior del primer elemento sería igual al último elemento y el siguiente elemento del último elemento sería el primer elemento.
Ejemplos:
 

Entrada: a[ ] = { 5, 6, 4, 3, 2} 
Salida: 20 
Para 5: el elemento anterior es 2 y el siguiente elemento es 6, por lo que el producto será 12. 
Para 6: el elemento anterior es 5 y el siguiente elemento es 4 entonces, el producto será 20. 
Para 4: el elemento anterior es 6 y el siguiente elemento es 3, entonces, el producto será 18. 
Para 3: el elemento anterior es 4 y el siguiente elemento es 2, entonces, el producto será 8. 
Para 2: anterior el elemento es 3 y el siguiente elemento es 5, por lo que el producto será 15.  El
producto máximo posible es 20 
y el elemento máximo en una array es 6.
Entrada: a[ ] = {9, 2, 3, 1, 5, 17} 
Salida: 45 
 

 

Acercarse: 
 

• La idea es encontrar primero el elemento anterior y el siguiente elemento.
• Después de encontrar ambos elementos, tome el producto y encuentre el producto máximo entre ellos.

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

     
// C++ program to print maximum product
// such that its previous and next
// element product is maximum.
#include<bits/stdc++.h>
using namespace std;
    // function to return largest element
    // such that its previous and next
    // element product is maximum.
     int maxProduct(int a[], int n)
    {
  
        int product[n];
  
        int maxA[n];
        int maxProd = 0;
        int maxArr = 0;
        for (int i = 0; i < n; i++) {
  
            // product of previous and next
            // element and stored into an
            // array product[i]
            product[i] = a[(i + 1) % n] *
                          a[(i + (n - 1)) % n];
  
            // find maximum product 
            // in product[i] array
            if (maxProd < product[i]) {
                maxProd = product[i];
            }
        }
        return maxProd;
    }
  
    // Driver program
   int main()
    {
        int a[] = { 5, 6, 4, 3, 2 };
  
        int n = sizeof(a)/sizeof(a[0]);
  
        cout<<(maxProduct(a, n));
    }
     
// This code contributed by Rajput-Ji

// Java program to print maximum product
// such that its previous and next
// element product is maximum.
import java.io.*;
 
class GFG
{
    // function to return largest element
    // such that its previous and next
    // element product is maximum.
    static int maxProduct(int a[], int n)
    {
 
        int[] product = new int[n];
 
        int maxA[] = new int[n];
 
        int maxProd = 0;
        int maxArr = 0;
        for (int i = 0; i < n; i++)
        {
 
            // product of previous and next
            // element and stored into an
            // array product[i]
            product[i] = a[(i + 1) % n] *
                        a[(i + (n - 1)) % n];
 
            // find maximum product
            // in product[i] array
            if (maxProd < product[i])
            {
                maxProd = product[i];
            }
        }
        return maxProd;
    }
 
    // Driver code
    public static void main(String[] args)
 
    {
        int[] a = { 5, 6, 4, 3, 2 };
 
        int n = a.length;
 
        System.out.println(maxProduct(a, n));
    }
}
 
// This code is contributed by Rajput-Ji

# Python3 program to print maximum product
# such that its previous and next
# element product is maximum.
 
# function to return largest element
# such that its previous and next
# element product is maximum.
def maxProduct(a, n) :
 
    product = [0]*n;
    maxA = [0]*n;
    maxProd = 0;
    maxArr = 0;
 
    for i in range(n) :
         
        # product of previous and next
        # element and stored into an
        # array product[i]
        product[i] = a[(i + 1) % n] * a[(i + (n - 1)) % n];
     
        # find maximum product
        # in product[i] array
        if (maxProd < product[i]) :
            maxProd = product[i];
             
    return maxProd;
 
 
# Driver code
if __name__ == "__main__" :
     
    a = [ 5, 6, 4, 3, 2 ];
    n = len(a);
     
    print(maxProduct(a, n));
     
# This code is contributed by AnkitRai01

// C# program to print maximum product
// such that its previous and next
// element product is maximum.
using System;
 
class GFG
{
    // function to return largest element
    // such that its previous and next
    // element product is maximum.
    static int maxProduct(int []a, int n)
    {
 
        int[] product = new int[n];
 
        //int []maxA = new int[n];
 
         int maxProd = 0;
        //int maxArr = 0;
        for (int i = 0; i < n; i++)
        {
 
            // product of previous and next
            // element and stored into an
            // array product[i]
            product[i] = a[(i + 1) % n] *
                        a[(i + (n - 1)) % n];
 
            // find maximum product
            // in product[i] array
            if (maxProd < product[i])
            {
                maxProd = product[i];
            }
        }
        return maxProd;
    }
 
    // Driver code
    public static void Main()
 
    {
        int[] a = { 5, 6, 4, 3, 2 };
 
        int n = a.Length;
 
        Console.WriteLine(maxProduct(a, n));
    }
}
 
// This code is contributed by anuj_67..

<script>
    // Javascript program to print maximum product
    // such that its previous and next
    // element product is maximum.
     
    // function to return largest element
    // such that its previous and next
    // element product is maximum.
    function maxProduct(a, n)
    {
   
        let product = new Array(n);
   
        //int []maxA = new int[n];
   
        let maxProd = 0;
        //int maxArr = 0;
        for (let i = 0; i < n; i++)
        {
   
            // product of previous and next
            // element and stored into an
            // array product[i]
            product[i] = a[(i + 1) % n] *
                        a[(i + (n - 1)) % n];
   
            // find maximum product
            // in product[i] array
            if (maxProd < product[i])
            {
                maxProd = product[i];
            }
        }
        return maxProd;
    }
     
    let a = [ 5, 6, 4, 3, 2 ];
   
    let n = a.length;
 
    document.write(maxProduct(a, n));
 
</script>

20

Complejidad de tiempo : O(N)