Open In App

Find number of contiguous Substrings with repeated patterns

Improve
Improve
Like Article
Like
Save
Share
Report

Given a string str consisting of digits, the task is to find the number of contiguous substrings such that the substring can be rearranged into a repetition of some string twice.

Examples:

Input:  str=”15512212″
Output: 6
Explanation: Possible 6 substrings are : 

  • “1551” can be rearranged to “1515
  • “155122” can be rearranged to “152152
  • “551221” can be rearranged to “512512
  • “1221” can be rearranged to “1212
  • “55” can be  rearranged to “55
  • “22” can be rearranged to “22

Input:  str=”590025995299005″
Output: 14

Approach: This can be solved with the following idea:

The approach used in the code is based on the observation that if a substring can be rearranged into a repetition of some string twice, then toggling any subset of its digits an even number of times will also result in a substring. This observation is used to efficiently compute the count of substrings using bitwise operations and maps.

Steps to implement the above approach:

  • Initialize a map m with key-value pair (0, 1).
  • Read the input string str.
  • Initialize a variable bb to 0.
  • Initialize a variable ret to 0.
  • For each character c in str, do the following:
    •  Convert the character c to integer v by subtracting the ASCII value of ‘0‘ from it.
    • Update bb by toggling the v-th bit in bb using the bitwise XOR operation.
    • If m[bb] exists, increment ret by m[bb].
    • Increment m[bb] by 1.
  • Print the value of ret, which is the count of required contiguous substrings.

Below is the implementation of the above approach:

C++




// C++ code of the above approach:
#include <bits/stdc++.h>
using namespace std;
 
// Defining the solve function
void solve(string str)
{
 
    // Initializing a map to keep track
    // of the number of substrings found
    map<int, int> m;
 
    // Reading the input string
 
    // Initializing a variable to keep
    // track of the number of times each
    // digit appears in the current
    // substring
    int bb = 0;
 
    // Inserting an initial key-value
    // pair of (0, 1) into the map
    m[0]++;
 
    // Initializing a variable to keep
    // track of the count of contiguous
    // substrings found so far
    int ret = 0;
 
    // Iterating through the input string
    for (int i = 0; i < str.size(); i++) {
 
        // Converting the current character
        // to an integer
        int v = str[i] - '0';
 
        // Toggling the v-th bit in bb
        // using the bitwise XOR operation
        bb ^= (1 << v);
 
        // If the current substring is a
        // repetition of some string
        // twice, increment ret by the
        // number of occurrences of the
        // substring in the map
        if (m.count(bb))
            ret += m[bb];
 
        // Incrementing the count of the
        // current substring in the map
        m[bb]++;
    }
 
    // Printing the count of required
    // substrings found
    cout << ret << endl;
}
 
// Driver code
int main()
{
    string str = "15512212";
 
    // Function call
    solve(str);
    return 0;
}


Java




/*package whatever //do not write package name here */
import java.io.*;
import java.util.*;
 
class GFG {
    // Defining the solve function
    public static void solve(String str)
    {
 
        // Initializing a map to keep track
        // of the number of substrings found
        Map<Integer, Integer> m
            = new HashMap<Integer, Integer>();
 
        // Initializing a variable to keep
        // track of the number of times each
        // digit appears in the current
        // substring
        int bb = 0;
 
        // Inserting an initial key-value
        // pair of (0, 1) into the map
        m.put(0, 1);
 
        // Initializing a variable to keep
        // track of the count of contiguous
        // substrings found so far
        int ret = 0;
 
        // Iterating through the input string
        for (int i = 0; i < str.length(); i++) {
 
            // Converting the current character
            // to an integer
            int v = str.charAt(i) - '0';
 
            // Toggling the v-th bit in bb
            // using the bitwise XOR operation
            bb ^= (1 << v);
 
            // If the current substring is a
            // repetition of some string
            // twice, increment ret by the
            // number of occurrences of the
            // substring in the map
            if (m.containsKey(bb))
                ret += m.get(bb);
 
            // Incrementing the count of the
            // current substring in the map
            m.put(bb, m.getOrDefault(bb, 0) + 1);
        }
 
        // Printing the count of required
        // substrings found
        System.out.println(ret);
    }
 
    // Driver code
    public static void main(String[] args)
    {
        String str = "15512212";
 
        // Function call
        solve(str);
    }
    // This Code is Contributed by Vikas Bishnoi
}


Python3




# Defining the solve function
def solve(s: str) -> None:
    # Initializing a dictionary to keep track
    # of the number of substrings found
    m = {}
 
    # Initializing a variable to keep
    # track of the number of times each
    # digit appears in the current
    # substring
    bb = 0
 
    # Inserting an initial key-value
    # pair of (0, 1) into the dictionary
    m[0] = 1
 
    # Initializing a variable to keep
    # track of the count of contiguous
    # substrings found so far
    ret = 0
 
    # Iterating through the input string
    for i in range(len(s)):
        # Converting the current character
        # to an integer
        v = int(s[i])
 
        # Toggling the v-th bit in bb
        # using the bitwise XOR operation
        bb ^= (1 << v)
 
        # If the current substring is a
        # repetition of some string
        # twice, increment ret by the
        # number of occurrences of the
        # substring in the dictionary
        if bb in m:
            ret += m[bb]
 
        # Incrementing the count of the
        # current substring in the dictionary
        if bb not in m:
            m[bb] = 0
        m[bb] += 1
 
    # Printing the count of required
    # substrings found
    print(ret)
   
# Driver code
if __name__ == '__main__':
    s = "15512212"
 
    # Function call
    solve(s)
# akashish__


C#




using System;
using System.Collections.Generic;
 
class GFG
{
    // Defining the solve function
    static void Solve(string str)
    {
        // Initializing a dictionary to keep track
        // of the number of substrings found
        Dictionary<int, int> m = new Dictionary<int, int>();
 
        // Initializing a variable to keep
        // track of the number of times each
        // digit appears in the current
        // substring
        int bb = 0;
 
        // Inserting an initial key-value
        // pair of (0, 1) into the dictionary
        m[0] = 1;
 
        // Initializing a variable to keep
        // track of the count of contiguous
        // substrings found so far
        int ret = 0;
 
        // Iterating through the input string
        for (int i = 0; i < str.Length; i++)
        {
            // Converting the current character
            // to an integer
            int v = str[i] - '0';
 
            // Toggling the v-th bit in bb
            // using the bitwise XOR operation
            bb ^= (1 << v);
 
            // If the current substring is a
            // repetition of some string
            // twice, increment ret by the
            // number of occurrences of the
            // substring in the dictionary
            if (m.ContainsKey(bb))
                ret += m[bb];
 
            // Incrementing the count of the
            // current substring in the dictionary
            if (m.ContainsKey(bb))
                m[bb]++;
            else
                m.Add(bb, 1);
        }
 
        // Printing the count of required
        // substrings found
        Console.WriteLine(ret);
    }
 
    // Driver code
    static void Main(string[] args)
    {
        string str = "15512212";
 
        // Function call
        Solve(str);
    }
}
//This code is contributed by Aditi Tyagi


Javascript




function solve(str) {
  // Initializing a map to keep track
  // of the number of substrings found
  const m = new Map();
 
  // Initializing a variable to keep
  // track of the number of times each
  // digit appears in the current
  // substring
  let bb = 0;
 
  // Inserting an initial key-value
  // pair of (0, 1) into the map
  m.set(0, 1);
 
  // Initializing a variable to keep
  // track of the count of contiguous
  // substrings found so far
  let ret = 0;
 
  // Iterating through the input string
  for (let i = 0; i < str.length; i++) {
    // Converting the current character
    // to an integer
    const v = parseInt(str[i]);
 
    // Toggling the v-th bit in bb
    // using the bitwise XOR operation
    bb ^= (1 << v);
 
    // If the current substring is a
    // repetition of some string
    // twice, increment ret by the
    // number of occurrences of the
    // substring in the map
    if (m.has(bb)) {
      ret += m.get(bb);
    }
 
    // Incrementing the count of the
    // current substring in the map
    m.set(bb, (m.get(bb) || 0) + 1);
  }
 
  // Printing the count of required
  // substrings found
  console.log(ret);
}
 
// Driver code
const str = "15512212";
 
// Function call
solve(str);
 
//This code is contributed by Tushar Rokade


Output

6

Time Complexity: O(n*log(m))
Auxilairy Space: O(m)

Related articles:



Last Updated : 22 Aug, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads