# Count of distinct possible strings after performing given operations

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:4Explanation:

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)*