Skip to content
Related Articles

Related Articles

Improve Article

Length of the longest substring with every character appearing even number of times

  • Difficulty Level : Medium
  • Last Updated : 14 May, 2021

Given a numerical string S of length N, the task is to find the length of the longest substring of S where each element occurs even number of times.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: S = “324425”
Output: 4
Explanation: Two substrings consisting of even frequent elements only are “44” and “2442”. Since “2442” is the longer of the two, print 4 as the required answer.



Input: S = “223015150”
Output: 6
Explanation: Three substrings consisting of even frequent elements only are “22”, “1515” and “015150”. Since “015150” is the longest among the three, print 4 as the required answer.

Naive Approach: The simplest approach is to generate all possible substrings of even length from the given string and for each substring, check if it contains characters with even frequencies only or not. Print the length of the longest of all such substrings.

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

Efficient Approach: To optimize the above approach the idea is to use Bit Masking. Follow the steps below to solve the problem:

  1. Traverse the string from left to right.
  2. While traversing, use a bitmask variable, say mask, to keep track of the occurrence of each element from index 0 to the current index, whether it is even or odd. The ith (0 ≤ i ≤ 9) bit in the mask is 0 if the digit i has occurred even number of times up to the current index, and 1 if it has occurred an odd number of times.
  3. Use a variable val to store the value of digit present at the current index.
  4. To update the occurrence of val, take Bitwise XOR of mask with 1 << val.
  5. Use a Hash table ind to keep track of the index of each bitmask.
  6. After updating the value of mask at the current index, check if it is present in ind or not:
    1. If the value of the mask is already present in ind, it means that each element from index ind[mask] + 1 to current index occurs even number of times. Therefore, update the answer if the length of this segment from index ind[mask] + 1 to the current index is greater than the answer.
    2. Otherwise, assign the value of the current index to ind[mask].
  7. Finally, print the length of the required substring after completing the above steps.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find length of the
// longest substring with each element
// occurring even number of times
int lenOfLongestReqSubstr(string s, int N)
{
    // Initialize unordered_map
    unordered_map<int, int> ind;
 
    int mask = 0;
    ind[0] = -1;
 
    // Stores the length of the
    // longest required substring
    int ans = 0;
 
    // Traverse the string
    for (int i = 0; i < N; i++) {
 
        // Stores the value of the
        // digit present at current index
        int val = s[i] - '0';
 
        // Bitwise XOR of the mask with
        // 1 left-shifted by val
        mask ^= (1 << val);
 
        // Check if the value of mask is
        // already present in ind or not
        if (ind.find(mask) != ind.end()) {
 
            // Update the final answer
            ans = max(ans, i - ind[mask]);
        }
 
        // Otherwise
        else
            ind[mask] = i;
    }
 
    // Return the answer
    return ans;
}
 
// Driver Code
int main()
{
    // Given string
    string s = "223015150";
 
    // Length of the given string
    int N = s.length();
 
    // Function Call
    cout << lenOfLongestReqSubstr(s, N);
 
    return 0;
}
Java



// Java program for the
// above approach
import java.util.*;
class GFG{
 
// Function to find length of the
// longest subString with each element
// occurring even number of times
static int lenOfLongestReqSubstr(String s,
                                 int N)
{
  // Initialize unordered_map
  HashMap<Integer,
          Integer> ind =
          new HashMap<>();
 
  int mask = 0;
  ind.put(0, -1);
 
  // Stores the length of the
  // longest required subString
  int ans = 0;
 
  // Traverse the String
  for (int i = 0; i < N; i++)
  {
    // Stores the value of the
    // digit present at current
    // index
    int val = s.charAt(i) - '0';
 
    // Bitwise XOR of the mask
    // with 1 left-shifted by val
    mask ^= (1 << val);
 
    // Check if the value of mask is
    // already present in ind or not
    if (ind.containsKey(mask))
    {
      // Update the final answer
      ans = Math.max(ans,
                     i - ind.get(mask));
    }
 
    // Otherwise
    else
      ind.put(mask, i);
  }
 
  // Return the answer
  return ans;
}
 
// Driver Code
public static void main(String[] args)
{
  // Given String
  String s = "223015150";
 
  // Length of the given String
  int N = s.length();
 
  // Function Call
  System.out.print(
  lenOfLongestReqSubstr(s, N));
}
}
 
// This code is contributed by Rajput-Ji
Python3



# Python3 program for the
# above approach
 
# Function to find length of
# the longest substring with
# each element occurring even
# number of times
def lenOfLongestReqSubstr(s, N):
 
    # Initialize unordered_map
    ind = {}
 
    mask = 0
    ind[0] = -1
 
    # Stores the length of the
    # longest required substring
    ans = 0
 
    # Traverse the string
    for i in range(N):
 
        # Stores the value of the
        # digit present at current
        # index
        val = ord(s[i]) - ord('0')
 
        # Bitwise XOR of the mask
        # with 1 left-shifted by val
        mask ^= (1 << val)
 
        # Check if the value of mask
        # is already present in ind
        # or not
        if (mask in ind):
           
            # Update the final answer
            ans = max(ans,
                      i - ind[mask])
 
        # Otherwise
        else:
            ind[mask] = i
 
    # Return the answer
    return ans
 
# Driver Code
if __name__ == "__main__":
 
    # Given string
    s = "223015150"
 
    #:Length of the given
    # string
    N = len(s)
 
    # Function Call
    print(lenOfLongestReqSubstr(s, N))
     
# This code is contributed by Chitranayal
C#



// C# program for the
// above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Function to find length of the
// longest subString with each element
// occurring even number of times
static int lenOflongestReqSubstr(String s,
                                 int N)
{
  // Initialize unordered_map
  Dictionary<int,
             int> ind =
             new Dictionary<int,
                            int>();
 
  int mask = 0;
  ind.Add(0, -1);
 
  // Stores the length of the
  // longest required subString
  int ans = 0;
 
  // Traverse the String
  for (int i = 0; i < N; i++)
  {
    // Stores the value of the
    // digit present at current
    // index
    int val = s[i] - '0';
 
    // Bitwise XOR of the mask
    // with 1 left-shifted by val
    mask ^= (1 << val);
 
    // Check if the value of mask is
    // already present in ind or not
    if (ind.ContainsKey(mask))
    {
      // Update the readonly answer
      ans = Math.Max(ans,
                     i - ind[mask]);
    }
 
    // Otherwise
    else
      ind.Add(mask, i);
  }
 
  // Return the answer
  return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given String
  String s = "223015150";
 
  // Length of the given String
  int N = s.Length;
 
  // Function Call
  Console.Write(
  lenOflongestReqSubstr(s, N));
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to find length of the
// longest substring with each element
// occurring even number of times
function lenOfLongestReqSubstr(s, N)
{
     
    // Initialize unordered_map
    var ind = new Map();
 
    var mask = 0;
    ind[0] = -1;
 
    // Stores the length of the
    // longest required substring
    var ans = 0;
 
    // Traverse the string
    for(var i = 0; i < N; i++)
    {
         
        // Stores the value of the
        // digit present at current index
        var val = s[i].charCodeAt(0) -
                   '0'.charCodeAt(0);
 
        // Bitwise XOR of the mask with
        // 1 left-shifted by val
        mask ^= (1 << val);
 
        // Check if the value of mask is
        // already present in ind or not
        if (ind.has(mask))
        {
             
            // Update the final answer
            ans = Math.max(ans, i - ind.get(mask));
        }
         
        // Otherwise
        else
            ind.set(mask, i);
    }
 
    // Return the answer
    return ans;
}
 
// Driver Code
 
// Given string
var s = "223015150";
 
// Length of the given string
var N = s.length;
 
// Function Call
document.write(lenOfLongestReqSubstr(s, N));
 
// This code is contributed by rutvik_56
 
</script>
Output: 
6
 
Time Complexity: O(N)
Auxiliary Space: O(N)



My Personal Notes
arrow_drop_up
Next

Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Recommended Articles
Page :
Longest subsequence with at least one character appearing in every string
18, Jul 19
Find the elements appearing even number of times in an Array
27, Aug 20
Replace every character of string by character whose ASCII value is K times more than it
01, Aug 18
Longest subsequence where every character appears at-least k times
03, Sep 17
Count of numbers appearing in the given ranges at-least K times
31, Aug 18
Print all array elements appearing more than N / K times
11, Dec 20
Length of the largest substring which have character with frequency greater than or equal to half of the substring
29, May 19
Length of the longest substring that contains even number of vowels
17, Jun 21
Minimum K such that every substring of length atleast K contains a character c
25, Dec 18
Minimum K such that every substring of length at least K contains a character c | Set-2
05, Jul 21
Minimum number of characters required to be removed such that every character occurs same number of times
22, Mar 21
Longest Even Length Substring such that Sum of First and Second Half is same
19, Dec 14
Generate all binary strings of length n with sub-string "01" appearing exactly twice
02, Apr 19
Maximize the number of times a character can be removed from substring 01 from given Binary String
21, Jun 21
Generate an N-length string having longest palindromic substring of length K
14, Dec 20
Sum of all numbers formed having 4 atmost X times, 5 atmost Y times and 6 atmost Z times
09, Jan 20
Find if a given string can be represented from a substring by iterating the substring “n” times
12, Jan 15
Number of substrings with each character occurring even times
21, Apr 21
Find character at Kth index by appending S1 (M) times and S2 (M+1) times
30, Jul 21
Count occurrences of substring X before every occurrence of substring Y in a given string
16, May 21
Length of longest Palindromic Subsequence of even length with no two adjacent characters same
04, Feb 20
Longest substring where all the characters appear at least K times | Set 3
10, Feb 21
Kth character after replacing each character of String by its frequency exactly X times
05, Jul 21
Repeat last occurrence of each alphanumeric character to their position in character family times
24, Aug 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
kundudinesh007
@kundudinesh007
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox