Open in App
Not now

Reduce the string by removing K consecutive identical characters

• Difficulty Level : Medium
• Last Updated : 31 Mar, 2023

Given a string str and an integer K, the task is to reduce the string by applying the following operation any number of times until it is no longer possible:

Choose a group of K consecutive identical characters and remove them from the string.

Finally, print the reduced string.

Examples:

Input: K = 2, str = “geeksforgeeks”
Output: gksforgks
Explanation: After removal of both occurrences of the substring “ee”, the string reduces to “gksforgks”.

Input: K = 3, str = “qddxxxd”
Output:
Explanation:
Removal of “xxx” modifies the string to “qddd”.
Again, removal of “ddd”modifies the string to “q”.

Recommended Practice

Approach: This problem can be solved using the Stack data structure. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

C++

 `// CPP program for the above approach` `#include ` `#include ` `using` `namespace` `std;`   `// Basic Approach is to create a Stack that store the` `// Character and its continuous repetition number This is` `// done using pair Further we check at each` `// iteration, whether the character matches the top of stack` `// if it does then check for number of repetitions` `// else add to top of stack with count 1`   `class` `Solution {` `public``:` `    ``string remove_k_char(``int` `k, string s)` `    ``{`   `        ``// Base Case` `        ``// If k=1 then all characters` `        ``// can be removed at each` `        ``// instance` `        ``if` `(k == 1)` `            ``return` `""``;` `        ``// initialize string` `        ``string output = ``""``;`   `        ``// create a stack using pair<> for storing each` `        ``// character and corresponding` `        ``// repetition` `        ``stack > stk;`   `        ``// iterate through the string` `        ``for` `(``int` `i = 0; i < s.length(); i++) {`   `            ``// if stack is empty then simply add the` `            ``// character with count 1 else check if` `            ``// character is same as top of stack` `            ``if` `(stk.empty() == ``true``) {` `                ``stk.push(make_pair(s[i], 1));` `            ``}` `            ``else` `{`   `                ``// if character at top of stack is same as` `                ``// current character increase the number of` `                ``// repetitions in the top of stack by 1` `                ``if` `(s[i] == (stk.top()).first) {` `                    ``pair<``char``, ``int``> P = stk.top();` `                    ``stk.pop();` `                    ``P.second++;` `                    ``if` `(P.second == k)` `                        ``continue``;` `                    ``else` `                        ``stk.push(P);` `                ``}` `                ``else` `{`   `                    ``// if character at top of stack is not` `                    ``// same as current character push the` `                    ``// character along with count 1 into the` `                    ``// top of stack` `                    ``stk.push(make_pair(s[i], 1));` `                ``}` `            ``}` `        ``}`   `        ``// Iterate through the stack` `        ``// Use string(int,char) in order to replicate the` `        ``// character multiple times and convert into string` `        ``// then add in front of output string` `        ``while` `(!stk.empty()) {` `            ``if` `(stk.top().second > 1) {` `                ``// if Frequency of current character greater` `                ``// than 1(let m),then append that character` `                ``// m times in output string` `                ``int` `count = stk.top().second;` `                ``while` `(count--)` `                    ``output += stk.top().first;` `            ``}` `            ``else` `{` `                ``output += stk.top().first;` `            ``}` `            ``stk.pop();` `        ``}` `        ``reverse(output.begin(), output.end());` `        ``return` `output;` `    ``}` `};`   `// Driver Code` `int` `main()` `{`   `    ``string s = ``"geeksforgeeks"``;` `    ``int` `k = 2;` `    ``Solution obj;` `    ``cout << obj.remove_k_char(k, s) << ``"\n"``;`   `    ``return` `0;` `}`   `// This Code has been contributed by shubhamm050402`

Java

 `// Java implementation of the approach` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find the reduced string` `    ``public` `static` `String reduced_String(``int` `k, String s)` `    ``{`   `        ``// Base Case` `        ``if` `(k == ``1``) {` `            ``// all elements remove,send empty string` `            ``return` `""``;` `        ``}`   `        ``// Creating a stack of type Pair` `        ``Stack st = ``new` `Stack();`   `        ``// Length of the string S` `        ``int` `l = s.length();` `        ``int` `ctr = ``0``;`   `        ``// iterate through the string` `        ``for` `(``int` `i = ``0``; i < l; i++) {` `            ``// if stack is empty then simply add the` `            ``// character with count 1 else check if` `            ``// character is same as top of stack` `            ``if` `(st.size() == ``0``) {` `                ``st.push(``new` `Pair(s.charAt(i), ``1``));` `                ``continue``;` `            ``}`   `            ``// if character at top of stack is same as` `            ``// current character increase the number of` `            ``// repetitions in the top of stack by 1` `            ``if` `(st.peek().c == s.charAt(i)) {` `                ``Pair p = st.peek();` `                ``st.pop();` `                ``p.ctr += ``1``;` `                ``if` `(p.ctr == k) {` `                    ``continue``;` `                ``}` `                ``else` `{` `                    ``st.push(p);` `                ``}` `            ``}` `            ``else` `{` `                ``st.push(``new` `Pair(s.charAt(i), ``1``));` `            ``}` `        ``}`   `        ``// iterate through the stack` `        ``// append characters in String`   `        ``StringBuilder output = ``new` `StringBuilder();`   `        ``while` `(st.size() > ``0``) {` `            ``char` `c = st.peek().c;` `            ``int` `cnt = st.peek().ctr;` `            ``// If frequency of a character is cnt, then` `            ``// append that character to cnt times in String` `            ``while` `(cnt-- > ``0``)` `                ``output.append(String.valueOf(c));` `            ``st.pop();` `        ``}` `        ``output.reverse();` `        ``return` `output.toString();` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `k = ``2``;` `        ``String st = ``"geeksforgeeks"``;` `        ``String ans = reduced_String(k, st);` `        ``System.out.println(ans);` `    ``}`   `    ``// Pair Class` `    ``static` `class` `Pair {` `        ``char` `c;` `        ``int` `ctr;` `        ``Pair(``char` `c, ``int` `ctr)` `        ``{` `            ``this``.c = c;` `            ``this``.ctr = ctr;` `        ``}` `    ``}` `}`   `// This Code has been contributed by shubhamm050402`

Python3

 `# Python3 implementation of the approach`   `# Pair class to store character and freq` `class` `Pair:` `    ``def` `__init__(``self``,c ,ctr):` `        ``self``.c``=` `c` `        ``self``.ctr ``=` `ctr`   `class` `Solution:` `    `  `    ``# Function to find the reduced string` `    ``def` `reduced_String(``self` `, k , s):` `        `  `        ``#Base Case` `        ``if` `(k ``=``=` `1``):` `            ``return` `""`   `        ``# Creating a stack of type Pair` `        ``st ``=` `[]` `    `  `        ``# iterate through given string` `        ``for` `i ``in` `range``(``len``(s)):` `            `  `            ``# if stack is empty then simply add the` `            ``# character with count 1 else check if` `            ``# character is same as top of stack` `            ``if` `(``len``(st) ``=``=` `0``):` `                ``st.append((Pair(s[i] , ``1``)))` `                ``continue` `                `  `            `  `            ``# if character at top of stack is same as` `            ``# current character increase the number of` `            ``# repetitions in the top of stack by 1` `            ``if` `(st[``-``1``].c ``=``=` `s[i]):` `                `  `                ``pair ``=` `st.pop()` `                ``pair.ctr ``+``=``1` `                `  `                ``if` `(pair.ctr ``=``=` `k):` `                    ``continue` `                `  `                ``else``:` `                    ``st.append(pair)` `    `  `            `  `            ``else``:` `                `  `                ``# if character at top of stack is not` `                ``# same as current character push the` `                ``# character along with count 1 into the` `                ``# top of stack` `                ``st.append((Pair(s[i] , ``1``)))` `    `  `    `  `        ``# Iterate through the stack` `        ``# Use string(int,char) in order to replicate the` `        ``# character multiple times and convert into string` `        ``# then add in front of output string` `        ``ans ``=` `""` `        ``while``(``len``(st) > ``0``):` `            `  `            ``c ``=` `st[``-``1``].c` `            ``cnt ``=` `st[``-``1``].ctr` `            `  `            ``while``(cnt >``0``):` `                ``ans  ``=` `c ``+` `ans` `                ``cnt ``-``=` `1` `            `  `            ``st.pop()` `        `  `        ``return` `(ans)`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    `  `    ``k ``=` `2` `    ``s ``=` `"geeksforgeeks"` `    ``obj ``=` `Solution()` `    ``print``(obj.reduced_String(k,s))`   `    ``# This code is contributed by chantya17.`

C#

 `// C# implementation of the above approach` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `GFG {`   `    ``// Function to find the reduced string` `    ``public` `static` `String reduced_String(``int` `k, String s)` `    ``{` `        ``// Base Case` `        ``if` `(k == 1) {` `            `  `            ``return` `""``;` `        ``}`   `        ``// Creating a stack of type Pair` `        ``Stack st = ``new` `Stack();`   `        ``// Length of the string S` `        ``int` `l = s.Length;` `     `  `        ``// iterate through the string` `        ``for` `(``int` `i = 0; i < l; i++) {`   `            ``// if stack is empty then simply add the` `            ``// character with count 1 else check if` `            ``// character is same as top of stack` `            ``if` `(st.Count == 0) {` `                ``st.Push(``new` `Pair(s[i], 1));` `                ``continue``;` `            ``}`   `            ``// if character at top of stack is same as` `            ``// current character increase the number of` `            ``// repetitions in the top of stack by 1` `            ``if` `(st.Peek().c == s[i]) {` `                ``Pair p = st.Peek();` `                ``st.Pop();` `                ``p.ctr += 1;` `                ``if` `(p.ctr == k) {` `                    ``continue``;` `                ``}` `                ``else` `{` `                    ``st.Push(p);` `                ``}` `            ``}` `            ``else` `{`   `                ``// if character at top of stack is not` `                ``// same as current character push the` `                ``// character along with count 1 into the` `                ``// top of stack` `                ``st.Push(``new` `Pair(s[i], 1));` `            ``}` `        ``}`   `        ``// iterate through the stack` `        ``// Use string(int,char) in order to replicate the` `        ``// character multiple times and convert into string` `        ``// then add in front of output string` `        ``String ans = ``""``;` `        ``while` `(st.Count > 0) {` `            ``char` `c = st.Peek().c;` `            ``int` `cnt = st.Peek().ctr;` `            ``while` `(cnt-- > 0)` `                ``ans = c + ans;` `            ``st.Pop();` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int` `k = 2;` `        ``String st = ``"geeksforgeeks"``;` `        ``String ans = reduced_String(k, st);` `        ``Console.Write(ans);` `    ``}`   `    ``public` `class` `Pair {` `        ``public` `char` `c;` `        ``public` `int` `ctr;` `        ``public` `Pair(``char` `c, ``int` `ctr)` `        ``{` `            ``this``.c = c;` `            ``this``.ctr = ctr;` `        ``}` `    ``}` `}` `// This code has been contributed by 29AjayKumar`

Javascript

 ``

Output

`gksforgks`

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

ANOTHER METHOD:

APPROACH:

1. First we declare a Stack<Character> to store each character of the string.
2. Then we iterate over the string.
3. While iterating we keep a counter variable and keep pushing the character in the stack and poping simultaneously until we get a counter equals k, that implies we have got the sequence of character to remove from the string.
4. At last we declare a String Builder to concatenate the characters from the stack.

Implementation:

Java

 `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {` `  ``public` `static` `String reduced_String(``int` `k, String s)` `  ``{` `      ``// Your code goes here` `      ``Stack stk = ``new` `Stack();` `      ``int` `i = ``0``;` `      ``while` `(i < s.length()) {` `          ``char` `ch = s.charAt(i++);` `          ``stk.push(ch);` `          ``int` `count = ``0``;` `          ``while` `((stk.size() > ``0``) && (stk.peek() == ch)) {` `              ``count++;` `              ``stk.pop();` `          ``}` `          ``if` `(count == k)` `              ``continue``;` `          ``else` `{` `              ``while` `(count > ``0``) {` `                  ``stk.push(ch);` `                  ``count--;` `              ``}` `          ``}` `      ``}` `      ``StringBuilder sb = ``new` `StringBuilder();` `      ``for` `(``char` `ch : stk)` `          ``sb = sb.append(ch);` `      ``return` `sb.toString();` `  ``}` `      ``public` `static` `void` `main(String[] args)` `      ``{` `          ``int` `k = ``2``;` `          ``String st = ``"geeksforgeeks"``;` `          ``String ans = reduced_String(k, st);` `          ``System.out.println(ans);` `      ``}` `  ``}` `//This code is contributed by Raunak Singh`

Output

`gksforgks`

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

My Personal Notes arrow_drop_up
Related Articles