Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count of distinct possible strings after performing given operations

  • Difficulty Level : Hard
  • Last Updated : 22 Mar, 2022

Given a numeric string S consisting of only three types of characters 0, 1, and 2 initially and following two operations:  

  • The occurrence of two consecutive 1 can be replaced by 3.
  • The occurrence of two consecutive 2 can be replaced by 4.

The given task is to find the total number of different strings that can be formed by using the operations.
Examples: 
 

Input: S = “0110000022” 
Output: 4 
Explanation: 
There can be four different formed by using the operations, the four strings are 
“0110000022”, “030000022”, “03000004”, “011000004”
Input: S = “111” 
Output: 3 
 

Approach: 
In order to solve this problem, we are using a dynamic programming approach. We define an array dp to store the count of possible strings of length equal to its respective indices. 

  • Initialize dp[0] = dp[1] = 1.
  • For any index i between [1, N-1], if the character at that index is ‘1’ or ‘2’ and is equal to that of its previous index, add the possible strings that can be formed of length i-1 and i-2. Otherwise, it is the same as that of length i-1.

dp[i + 1] = dp[i] + dp[i-1] if S[i] == S[i-1] where S[i] is either ‘1’ or ‘2’. 
dp[i + 1] = dp[i] otherwise. 
 

  • Return dp[n] as the count of different strings possible.

Below is the implementation of the above approach:
 

C++




// C++ implementation of
// the above approach
#include
using namespace std;
 
// Function that prints the
// number of different strings
// that can be formed
void differentStrings(string s)
{
    // Computing the length of
    // the given string
    int n = s.length();
 
    vector dp(n + 1);
 
    // Base case
    dp[0] = dp[1] = 1;
 
    // Traverse the given string
    for (int i = 1; i < n; i++) {
 
        // If two consecutive 1's
        // or 2's are present
        if (s[i] == s[i - 1]
            && (s[i] == '1'
                || s[i] == '2'))
 
            dp[i + 1]
                = dp[i] + dp[i - 1];
 
        // Otherwise take
        // the previous value
        else
            dp[i + 1] = dp[i];
    }
 
    cout << dp[n] << "\n";
}
 
// Driver Code
int main()
{
    string S = "0111022110";
 
    differentStrings(S);
 
    return 0;
}
C



#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void differentStrings(char* s)
{
   
    // Computing the length of
    // the given string
    int n = strlen(s);
 
    int dp[n + 1];
 
    // Base case
    dp[0] = dp[1] = 1;
 
    // Traverse the given string
    for (int i = 1; i < n; i++) {
 
        // If two consecutive 1's
        // or 2's are present
        if (s[i] == s[i - 1]
            && (s[i] == '1'
                || s[i] == '2'))
 
            dp[i + 1]  = dp[i] + dp[i - 1];
 
        // Otherwise take
        // the previous value
        else
            dp[i + 1] = dp[i];
    }
 
    printf("%d\n", dp[n]);
}
 
// Driver Code
int main()
{
    char S[] = "0111022110";
 
    differentStrings(S);
 
    return 0;
}
 
// This code is contributed by phalashi.
Java



// Java implementation of the above approach
import java.io.*;
 
class GFG{
 
// Function that prints the
// number of different strings
// that can be formed
static void differentStrings(String s)
{
     
    // Computing the length of
    // the given string
    int n = s.length();
 
    int[] dp = new int[n + 1];
 
    // Base case
    dp[0] = dp[1] = 1;
 
    // Traverse the given string
    for(int i = 1; i < n; i++)
    {
        
       // If two consecutive 1's
       // or 2's are present
       if (s.charAt(i) == s.charAt(i - 1) &&
          (s.charAt(i) == '1' ||
           s.charAt(i) == '2'))
           dp[i + 1] = dp[i] + dp[i - 1];
            
       // Otherwise take the
       // previous value
       else
           dp[i + 1] = dp[i];
    }
    System.out.println(dp[n]);
}
 
// Driver code
public static void main(String[] args)
{
    String S = "0111022110";
 
    differentStrings(S);
}
}
 
// This code is contributed by offbeat
Python3



# Python3 implementation of
# the above approach
 
# Function that prints the
# number of different strings
# that can be formed
def differentStrings(s):
 
    # Computing the length of
    # the given string
    n = len(s)
 
    dp = [0] * (n + 1)
 
    # Base case
    dp[0] = dp[1] = 1
 
    # Traverse the given string
    for i in range (1, n):
 
        # If two consecutive 1's
        # or 2's are present
        if (s[i] == s[i - 1] and
           (s[i] == '1' or
            s[i] == '2')):
 
            dp[i + 1] = dp[i] + dp[i - 1]
 
        # Otherwise take
        # the previous value
        else:
            dp[i + 1] = dp[i]
    
    print (dp[n])
 
# Driver Code
if __name__ == "__main__": 
    S = "0111022110"
    differentStrings(S)
     
# This code is contributed by Chitranayal
C#



// C# implementation of the above approach
using System;
class GFG{
 
// Function that prints the
// number of different strings
// that can be formed
static void differentStrings(string s)
{
     
    // Computing the length of
    // the given string
    int n = s.Length;
 
    int[] dp = new int[n + 1];
 
    // Base case
    dp[0] = dp[1] = 1;
 
    // Traverse the given string
    for(int i = 1; i < n; i++)
    {
 
       // If two consecutive 1's
       // or 2's are present
       if (s[i] == s[i - 1] &&
          (s[i] == '1' ||
           s[i] == '2'))
           dp[i + 1] = dp[i] + dp[i - 1];
        
       // Otherwise take the
       // previous value
       else
           dp[i + 1] = dp[i];
    }
    Console.Write(dp[n]);
}
 
// Driver code
public static void Main()
{
    string S = "0111022110";
 
    differentStrings(S);
}
}
 
// This code is contributed by Code_Mech
Javascript



<script>
 
// JavaScript implementation of
// the above approach
 
// Function that prints the
// number of different strings
// that can be formed
function differentStrings(s)
{
    // Computing the length of
    // the given string
    var n = s.length;
 
    var dp = Array(n + 1);
 
    // Base case
    dp[0] = dp[1] = 1;
 
    // Traverse the given string
    for (var i = 1; i < n; i++) {
 
        // If two consecutive 1's
        // or 2's are present
        if (s[i] == s[i - 1]
            && (s[i] == '1'
                || s[i] == '2'))
 
            dp[i + 1]
                = dp[i] + dp[i - 1];
 
        // Otherwise take
        // the previous value
        else
            dp[i + 1] = dp[i];
    }
 
    document.write( dp[n] + "<br>");
}
 
// Driver Code
var S = "0111022110";
differentStrings(S);
 
 
</script>
Output: 
12
 
Time Complexity: O(N) 

My Personal Notes
arrow_drop_up
Previous
Count subarrays with sum equal to its XOR value
Next

Split the number N by maximizing the count of subparts divisible by K
Recommended Articles
Page :
Average value of set bit count in given Binary string after performing all possible choices of K operations
20, Sep 21
Count of distinct strings that can be obtained after performing exactly one swap
27, Dec 21
Count of distinct groups of strings formed after performing equivalent operation
30, Sep 21
Maximum score possible after performing given operations on an Array
05, Apr 20
Maximum Possible Product in Array after performing given Operations
01, Oct 18
Maximum count of equal numbers in an array after performing given operations
01, Nov 18
Maximum count of values of S modulo M lying in a range [L, R] after performing given operations on the array
08, Sep 20
Maximum sum possible from given Matrix by performing given operations
03, Nov 20
Count of possible distinct Binary strings after replacing "11" with "0"
17, Mar 22
Count of each lowercase character after performing described operations for each prefix of length 1 to N
26, Dec 21
Count of distinct Strings possible by swapping prefixes of pairs of Strings from the Array
18, Aug 20
Final string after performing given operations
30, Nov 18
Minimum N-Digit number required to obtain largest N-digit number after performing given operations
19, Aug 20
Find the maximum occurring character after performing the given operations
14, Sep 20
Maximum sum of all elements of array after performing given operations
10, Dec 18
Lexicographically smallest string possible by performing K operations on a given string
24, Jan 21
Maximum possible array sum after performing the given operation
27, Nov 19
Number of array elements derivable from D after performing certain operations
27, Dec 18
Count of Distinct strings possible by inserting K characters in the original string
28, Jul 20
Count distinct strings possible by replacing each character by its Morse code
31, Oct 20
Count of operations to make all elements of array a[] equal to its min element by performing a[i] – b[i]
19, May 20
Distinct strings such that they contains given strings as sub-sequences
11, Jul 19
Maximum value obtained by performing given operations in an Array
03, Jan 20
Modify a string by performing given shift operations
01, Mar 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
nitinkr8991
@nitinkr8991
Vote for difficulty
Current difficulty :
Hard





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

Start Your Coding Journey Now!