GCD máximo de todos los subarreglos de longitud de al menos 2

Dada una array arr[] de N números. La tarea es encontrar el GCD máximo de todos los subarreglos de tamaño mayor que 1. 
Ejemplos: 
 

Entrada: arr[] = { 3, 18, 9, 9, 5, 15, 8, 7, 6, 9 } 
Salida: 9 
Explicación: 
GCD del subarreglo {18, 9, 9} es el máximo, que es 9.
Entrada : arr[] = { 4, 8, 12, 16, 20, 24 } 
Salida: 4 
Explicación: 
GCD del subarreglo {4, 18, 12, 16, 20, 24} es el máximo, que es 4. 
 

Enfoque ingenuo: la idea es generar todo el subarreglo de tamaño mayor que 1 y luego encontrar el máximo de mcd de todos los subarreglo formados. 
Complejidad temporal: O(N ² )  
Enfoque eficiente: Sea g CD de dos números . Ahora, si tomamos gcd de g con cualquier tercer número, digamos c , entonces gcd disminuirá o permanecerá igual, pero nunca aumentará. La idea es encontrar el mcd de cada par consecutivo en el arr[] y el máximo de mcd de todos los pares formados es el resultado deseado. A continuación se muestra la implementación del enfoque anterior: 

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find GCD
int gcd(int a, int b)
{
    if (b == 0) {
        return a;
    }
    return gcd(b, a % b);
}
 
void findMaxGCD(int arr[], int n)
{
 
    // To store the maximum GCD
    int maxGCD = 0;
 
    // Traverse the array
    for (int i = 0; i < n - 1; i++) {
 
        // Find GCD of the consecutive
        // element
        int val = gcd(arr[i], arr[i + 1]);
 
        // If calculated GCD > maxGCD
        // then update it
        if (val > maxGCD) {
            maxGCD = val;
        }
    }
 
    // Print the maximum GCD
    cout << maxGCD << endl;
}
 
// Driver Code
int main()
{
    int arr[] = { 3, 18, 9, 9, 5,
                  15, 8, 7, 6, 9 };
 
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    findMaxGCD(arr, n);
    return 0;
}

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to find GCD
static int gcd(int a, int b)
{
    if (b == 0)
    {
        return a;
    }
    return gcd(b, a % b);
}
 
static void findMaxGCD(int arr[], int n)
{
 
    // To store the maximum GCD
    int maxGCD = 0;
 
    // Traverse the array
    for(int i = 0; i < n - 1; i++)
    {
         
       // Find GCD of the consecutive
       // element
       int val = gcd(arr[i], arr[i + 1]);
        
       // If calculated GCD > maxGCD
       // then update it
       if (val > maxGCD)
       {
           maxGCD = val;
       }
    }
 
    // Print the maximum GCD
    System.out.print(maxGCD + "\n");
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 3, 18, 9, 9, 5,
                  15, 8, 7, 6, 9 };
    int n = arr.length;
 
    // Function call
    findMaxGCD(arr, n);
}
}
 
// This code is contributed by amal kumar choubey

# Python3 program for the above approach
 
# Function to find GCD
def gcd(a, b):
     
    if (b == 0):
        return a;
    return gcd(b, a % b);
 
def findMaxGCD(arr, n):
     
    # To store the maximum GCD
    maxGCD = 0;
 
    # Traverse the array
    for i in range(0, n - 1):
 
        # Find GCD of the consecutive
        # element
        val = gcd(arr[i], arr[i + 1]);
 
        # If calculated GCD > maxGCD
        # then update it
        if (val > maxGCD):
            maxGCD = val;
 
    # Print the maximum GCD
    print(maxGCD);
 
# Driver Code
if __name__ == '__main__':
     
    arr = [ 3, 18, 9, 9, 5,
            15, 8, 7, 6, 9 ];
    n = len(arr);
 
    # Function call
    findMaxGCD(arr, n);
 
# This code is contributed by 29AjayKumar

// C# program for the above approach
using System;
 
class GFG{
 
// Function to find GCD
static int gcd(int a, int b)
{
    if (b == 0)
    {
        return a;
    }
    return gcd(b, a % b);
}
 
static void findMaxGCD(int []arr, int n)
{
 
    // To store the maximum GCD
    int maxGCD = 0;
 
    // Traverse the array
    for(int i = 0; i < n - 1; i++)
    {
         
        // Find GCD of the consecutive
        // element
        int val = gcd(arr[i], arr[i + 1]);
             
        // If calculated GCD > maxGCD
        // then update it
        if (val > maxGCD)
        {
            maxGCD = val;
        }
    }
 
    // Print the maximum GCD
    Console.Write(maxGCD + "\n");
}
 
// Driver Code
public static void Main()
{
    int []arr = { 3, 18, 9, 9, 5,
                 15, 8, 7, 6, 9 };
    int n = arr.Length;
 
    // Function call
    findMaxGCD(arr, n);
}
}
 
// This code is contributed by Code_Mech

<script>
 
// Javascript program for the above approach
 
// Function to find GCD
function gcd(a, b)
{
    if (b == 0) {
        return a;
    }
    return gcd(b, a % b);
}
 
function findMaxGCD(arr, n)
{
 
    // To store the maximum GCD
    let maxGCD = 0;
 
    // Traverse the array
    for (let i = 0; i < n - 1; i++) {
 
        // Find GCD of the consecutive
        // element
        let val = gcd(arr[i], arr[i + 1]);
 
        // If calculated GCD > maxGCD
        // then update it
        if (val > maxGCD) {
            maxGCD = val;
        }
    }
 
    // Print the maximum GCD
    document.write(maxGCD + "<br>");
}
 
// Driver Code
  
    let arr = [ 3, 18, 9, 9, 5,
                15, 8, 7, 6, 9 ];
 
    let n = arr.length;
 
    // Function Call
    findMaxGCD(arr, n);
 
// This code is contributed by Mayank Tyagi
 
</script>

9

Complejidad de tiempo: O(N) , donde N es la longitud de la array.

Espacio auxiliar: O(log(max(a, b)))