Longitud máxima del subarreglo tal que todos los elementos sean iguales en el subarreglo

Dado un arreglo arr[] de N enteros, la tarea es encontrar el subarreglo de longitud máxima que contiene elementos similares.
Ejemplos: 
 

Entrada: arr[] = {1, 2, 3, 4, 5, 5, 5, 5, 5, 2, 2, 1, 1} 
Salida: 5 
Explicación: 
El subarreglo {5, 5, 5, 5, 5 } tiene una longitud máxima de 5 con elementos idénticos.
Entrada: arr[] = {1, 2, 3, 4} 
Salida: 1 
Explicación: 
Todos los subarreglos de elementos idénticos son {1}, {2}, {3} y {4}, que tienen una longitud de 1. 
 

Enfoque: la idea es atravesar el arreglo y almacenar la longitud máxima y la longitud actual del subarreglo que tiene los mismos elementos. A continuación se muestran los pasos: 
 

1. Recorra la array y verifique si el elemento actual es igual al siguiente elemento, luego aumente el valor de la variable de longitud actual.
2. Ahora, compare la longitud actual con la longitud máxima para actualizar la longitud máxima del subarreglo.
3. Si el elemento actual no es igual al siguiente elemento, restablezca la longitud a 1 y continúe con todos los elementos de la array.

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

// C++ program for the above approach
 
#include <iostream>
using namespace std;
 
// Function to find the longest
// subarray with same element
int longest_subarray(int arr[], int d)
{
 
    int i = 0, j = 1, e = 0;
 
    for (i = 0; i < d - 1; i++) {
 
        // Check if the elements
        // are same then we can
        // increment the length
        if (arr[i] == arr[i + 1]) {
            j = j + 1;
        }
        else {
 
            // Reinitialize j
            j = 1;
        }
 
        // Compare the maximum
        // length e with j
        if (e < j) {
            e = j;
        }
    }
 
    // Return max length
    return e;
}
 
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 2, 3, 4 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << longest_subarray(arr, N);
}

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to find the longest
// subarray with same element
static int longest_subarray(int arr[], int d)
{
    int i = 0, j = 1, e = 0;
 
    for(i = 0; i < d - 1; i++)
    {
         
       // Check if the elements
       // are same then we can
       // increment the length
       if (arr[i] == arr[i + 1])
       {
           j = j + 1;
       }
       else
       {
            
           // Reinitialize j
           j = 1;
       }
        
       // Compare the maximum
       // length e with j
       if (e < j)
       {
           e = j;
       }
    }
 
    // Return max length
    return e;
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given array arr[]
    int arr[] = { 1, 2, 3, 4 };
    int N = arr.length;
 
    // Function Call
    System.out.print(longest_subarray(arr, N));
}
}
 
// This code is contributed by 29AjayKumar

# Python3 program for the above approach
 
# Function to find the longest
# subarray with same element
def longest_subarray(arr, d):
     
    (i, j, e) = (0, 1, 0)
     
    for i in range(d - 1):
         
        # Check if the elements
        # are same then we can
        # increment the length
        if arr[i] == arr[i + 1]:
            j += 1
        else:
             
            # Reinitialize j
            j = 1
         
        # Compare the maximum
        # length e with j
        if e < j:
            e = j
     
    # Return max length
    return e
 
# Driver code
 
# Given list arr[]
arr = [ 1, 2, 3, 4 ]
N = len(arr)
 
# Function call
print(longest_subarray(arr, N))
 
# This code is contributed by rutvik_56

// C# program for the above approach
using System;
 
class GFG{
  
// Function to find the longest
// subarray with same element
static int longest_subarray(int []arr, int d)
{
    int i = 0, j = 1, e = 0;
  
    for(i = 0; i < d - 1; i++)
    {
          
       // Check if the elements
       // are same then we can
       // increment the length
       if (arr[i] == arr[i + 1])
       {
           j = j + 1;
       }
       else
       {
             
           // Reinitialize j
           j = 1;
       }
         
       // Compare the maximum
       // length e with j
       if (e < j)
       {
           e = j;
       }
    }
  
    // Return max length
    return e;
}
  
// Driver Code
public static void Main(String[] args)
{
      
    // Given array []arr
    int []arr = { 1, 2, 3, 4 };
    int N = arr.Length;
  
    // Function Call
    Console.Write(longest_subarray(arr, N));
}
}
 
// This code is contributed by 29AjayKumar

<script>
// javascript program for the above approach
 
    // Function to find the longest
    // subarray with same element
    function longest_subarray(arr , d)
    {
        var i = 0, j = 1, e = 0;
 
        for (i = 0; i < d - 1; i++)
        {
 
            // Check if the elements
            // are same then we can
            // increment the length
            if (arr[i] == arr[i + 1])
            {
                j = j + 1;
            }
            else
            {
 
                // Reinitialize j
                j = 1;
            }
 
            // Compare the maximum
            // length e with j
            if (e < j) {
                e = j;
            }
        }
 
        // Return max length
        return e;
    }
 
    // Driver Code
     
        // Given array arr
        var arr = [ 1, 2, 3, 4 ];
        var N = arr.length;
 
        // Function Call
        document.write(longest_subarray(arr, N));
 
// This code is contributed by todaysgaurav
</script>

1

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