Open In App

Maximum length of the sub-array whose first and last elements are same

Improve
Improve
Like Article
Like
Save
Share
Report

Given a character array arr[] containing only lowercase English alphabets, the task is to print the maximum length of the subarray such that the first and the last element of the sub-array are same.
Examples: 
 

Input: arr[] = {‘g’, ‘e’, ‘e’, ‘k’, ‘s’} 
Output:
{‘e’, ‘e’} is the maximum length sub-array satisfying the given condition.
Input: arr[] = {‘a’, ‘b’, ‘c’, ‘d’, ‘a’} 
Output:
{‘a’, ‘b’, ‘c’, ‘d’, ‘a’} is the required sub-array 
 

 

Approach: For every element of the array ch, store it’s first and last occurrence. Then the maximum length of the sub-array that starts and ends with the same element ch will be lastOccurrence(ch) – firstOccurrence(ch) + 1. The maximum of this value among all the elements is the required answer.
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Class that represents a single element
// of the given array and stores it's first
// and the last occurrence in the array
class Element
{
public:
    int firstOcc, lastOcc;
    Element();
    void updateOccurence(int);
};
 
Element::Element()
{
    firstOcc = lastOcc = -1;
}
 
// Function to update the occurrence
// of a particular character in the array
void Element::updateOccurence(int index)
{
    // If first occurrence is set to something
    // other than -1 then it doesn't need updating
    if (firstOcc == -1)
        firstOcc = index;
 
    // Last occurrence will be updated everytime
    // the character appears in the array
    lastOcc = index;
}
 
// Function to return the maximum length of the
// sub-array that starts and ends with the same element
int maxLenSubArr(string arr, int n)
{
    Element elements[26];
 
    for (int i = 0; i < n; i++)
    {
        int ch = arr[i] - 'a';
 
        // Update current character's occurrence
        elements[ch].updateOccurence(i);
    }
 
    int maxLen = 0;
    for (int i = 0; i < 26; i++)
    {
        // Length of the longest sub-array that starts
        // and ends with the same element
        int len = elements[i].lastOcc -
                  elements[i].firstOcc + 1;
        maxLen = max(maxLen, len);
    }
 
    // Return the maximum length of
    // the required sub-array
    return maxLen;
}
 
// Driver Code
int main()
{
    string arr = "geeks";
    int n = arr.length();
 
    cout << maxLenSubArr(arr, n) << endl;
 
    return 0;
}
 
// This code is contributed by
// sanjeev2552


Java




// Java implementation of the approach
 
// Class that represents a single element
// of the given array and stores it's first
// and the last occurrence in the array
class Element {
    int firstOcc, lastOcc;
 
    public Element()
    {
        firstOcc = lastOcc = -1;
    }
 
    // Function to update the occurrence
    // of a particular character in the array
    public void updateOccurrence(int index)
    {
 
        // If first occurrence is set to something
        // other than -1 then it doesn't need updating
        if (firstOcc == -1)
            firstOcc = index;
 
        // Last occurrence will be updated everytime
        // the character appears in the array
        lastOcc = index;
    }
}
 
class GFG {
 
    // Function to return the maximum length of the
    // sub-array that starts and ends with the same element
    public static int maxLenSubArr(char arr[], int n)
    {
 
        Element elements[] = new Element[26];
        for (int i = 0; i < n; i++) {
            int ch = arr[i] - 'a';
 
            // Initialize the current character
            // if haven't already
            if (elements[ch] == null)
                elements[ch] = new Element();
 
            // Update current character's occurrence
            elements[ch].updateOccurrence(i);
        }
 
        int maxLen = 0;
        for (int i = 0; i < 26; i++) {
 
            // If current character appears in the given array
            if (elements[i] != null) {
 
                // Length of the longest sub-array that starts
                // and ends with the same element
                int len = elements[i].lastOcc - elements[i].firstOcc + 1;
                maxLen = Math.max(maxLen, len);
            }
        }
 
        // Return the maximum length of
        // the required sub-array
        return maxLen;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        char arr[] = { 'g', 'e', 'e', 'k', 's' };
        int n = arr.length;
 
        System.out.print(maxLenSubArr(arr, n));
    }
}


Python3




# Python3 implementation of the approach
 
# Class that represents a single element
# of the given array and stores it's first
# and the last occurrence in the array
class Element:
     
    def __init__(self):
        self.firstOcc = -1
        self.lastOcc = -1
 
    # Function to update the occurrence
    # of a particular character in the array
    def updateOccurrence(self, index):
 
        # If first occurrence is set to
        # something other than -1 then it
        # doesn't need updating
        if self.firstOcc == -1:
            self.firstOcc = index
 
        # Last occurrence will be updated
        # everytime the character appears
        # in the array
        self.lastOcc = index
 
# Function to return the maximum length
# of the sub-array that starts and ends
# with the same element
def maxLenSubArr(arr, n):
 
    elements = [None] * 26
    for i in range(0, n):
        ch = ord(arr[i]) - ord('a')
 
        # Initialize the current character
        # if haven't already
        if elements[ch] == None:
            elements[ch] = Element()
 
        # Update current character's occurrence
        elements[ch].updateOccurrence(i)
         
    maxLen = 0
    for i in range(0, 26):
 
        # If current character appears in
        # the given array
        if elements[i] != None:
 
            # Length of the longest sub-array that
            # starts and ends with the same element
            length = (elements[i].lastOcc -
                      elements[i].firstOcc + 1)
            maxLen = max(maxLen, length)
             
    # Return the maximum length of
    # the required sub-array
    return maxLen
     
# Driver code
if __name__ == "__main__":
     
    arr = ['g', 'e', 'e', 'k', 's']
    n = len(arr)
 
    print(maxLenSubArr(arr, n))
     
# This code is contributed by Rituraj Jain


C#




// C# implementation of the above approach
using System;
 
// Class that represents a single element
// of the given array and stores it's first
// and the last occurrence in the array
public class Element
{
     
    public int firstOcc, lastOcc;
 
    public Element()
    {
        firstOcc = lastOcc = -1;
    }
 
    // Function to update the occurrence
    // of a particular character in the array
    public void updateOccurrence(int index)
    {
 
        // If first occurrence is set to something
        // other than -1 then it doesn't need updating
        if (firstOcc == -1)
            firstOcc = index;
 
        // Last occurrence will be updated everytime
        // the character appears in the array
        lastOcc = index;
    }
}
 
class GFG
{
 
    // Function to return the maximum
    // length of the sub-array that
    //  starts and ends with the same element
    public static int maxLenSubArr(char []arr, int n)
    {
 
        Element []elements = new Element[26];
        for (int i = 0; i < n; i++)
        {
            int ch = arr[i] - 'a';
 
            // Initialize the current character
            // if haven't already
            if (elements[ch] == null)
                elements[ch] = new Element();
 
            // Update current character's occurrence
            elements[ch].updateOccurrence(i);
        }
 
        int maxLen = 0;
        for (int i = 0; i < 26; i++)
        {
 
            // If current character appears
            // in the given array
            if (elements[i] != null)
            {
 
                // Length of the longest sub-array that starts
                // and ends with the same element
                int len = elements[i].lastOcc - elements[i].firstOcc + 1;
                maxLen = Math.Max(maxLen, len);
            }
        }
 
        // Return the maximum length of
        // the required sub-array
        return maxLen;
    }
 
    // Driver code
    public static void Main()
    {
        char []arr = { 'g', 'e', 'e', 'k', 's' };
        int n = arr.Length;
 
        Console.WriteLine(maxLenSubArr(arr, n));
    }
}
 
// This code is contributed by Ryuga


Javascript




<script>
 
// Javascript implementation of the approach
 
//Class that represents a single element
//of the given array and stores it's first
//and the last occurrence in the array
class Element
{   
    constructor()
    {
        this.firstOcc = -1;
        this.lastOcc = -1;
    }
 
    // Function to update the occurrence
    //of a particular character in the array
    updateOccurrence(index){
 
        // If first occurrence is set to
        //something other than -1 then it
        //doesn't need updating
        if (this.firstOcc == -1)
            this.firstOcc = index;
 
        // Last occurrence will be updated
        // everytime the character appears
        // in the array
        this.lastOcc = index;
     
    }
}
    // Function to return the maximum length
// of the sub-array that starts and ends
// with the same element
function maxLenSubArr(arr, n)
{
   let elements = new Array(26);
    
   for(let i=0;i<26;i++)
   {
       elements[i] = new Element();
   }
 
    for(let i=0;i<n;i++)
       {
           let ch = arr[i].charCodeAt(0) - 'a'.charCodeAt(0);
 
        // Update current character's occurrence
        elements[ch].updateOccurrence(i);
        }
    let maxLen = 0;
    for(let i=0;i<26;i++)
    {
        // Length of the longest sub-array that starts
        // and ends with the same element
        let len = elements[i].lastOcc -
                  elements[i].firstOcc + 1;
        maxLen = Math.max(maxLen, len);
     
    }
    // Return the maximum length of
    // the required sub-array
    return maxLen;
}
// Driver code
 
let arr = "geeks";
let n = arr.length;
 
console.log(maxLenSubArr(arr, n));
 
// This code is contributed by akashish__
 
</script>


Output: 

2

 

Time Complexity: O(N) 
Auxiliary Space: O(N)

Related Topic: Subarrays, Subsequences, and Subsets in Array



Last Updated : 06 Oct, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads