GeeksforGeeks App
Open App
Browser
Continue

# Reduce the string by removing K consecutive identical characters

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`

## C

 `#include ``#include ``#include ` `typedef` `struct` `{``    ``char` `ch;``    ``int` `freq;``} Pair;` `Pair createPair(``char` `ch, ``int` `freq)``{``    ``Pair p;``    ``p.ch = ch;``    ``p.freq = freq;``    ``return` `p;``}` `void` `push(Pair* stack, ``int``* top, ``char` `ch, ``int` `freq)``{``    ``Pair p = createPair(ch, freq);``    ``stack[++(*top)] = p;``}` `Pair pop(Pair* stack, ``int``* top) { ``return` `stack[(*top)--]; }` `char``* remove_k_char(``int` `k, ``char``* s)``{``    ``if` `(k == 1)``        ``return` `""``;` `    ``Pair stack[``strlen``(s)];``    ``int` `top = -1;` `    ``for` `(``int` `i = 0; i < ``strlen``(s); i++) {``        ``if` `(top == -1 || stack[top].ch != s[i])``            ``push(stack, &top, s[i], 1);``        ``else` `{``            ``stack[top].freq++;``            ``if` `(stack[top].freq == k)``                ``pop(stack, &top);``        ``}``    ``}` `    ``int` `resultLength = top + 1;``    ``char``* result``        ``= (``char``*)``malloc``((resultLength + 1) * ``sizeof``(``char``));` `    ``for` `(``int` `i = 0; i < resultLength; i++)``        ``result[i] = stack[i].ch;` `    ``result[resultLength] = ``'\0'``;``    ``return` `result;``}` `int` `main()``{``    ``char` `s[] = ``"geeksforgeeks"``;``    ``int` `k = 2;` `    ``char``* result = remove_k_char(k, s);``    ``printf``(``"%s\n"``, result);` `    ``free``(result);` `    ``return` `0;``}`

## 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:

## C++

 `#include ``using` `namespace` `std;` `string reduced_String(``int` `k, string s) {``    ``stack<``char``> stk;``    ``int` `i = 0;``    ``while` `(i < s.length()) {``        ``char` `ch = s[i++];``        ``stk.push(ch);``        ``int` `count = 0;``        ``while` `(!stk.empty() && stk.top() == ch) {``            ``count++;``            ``stk.pop();``        ``}``        ``if` `(count == k)``            ``continue``;``        ``else` `{``            ``while` `(count > 0) {``                ``stk.push(ch);``                ``count--;``            ``}``        ``}``    ``}``    ``string result = ``""``;``    ``while` `(!stk.empty()) {``        ``result = stk.top() + result;``        ``stk.pop();``    ``}``    ``return` `result;``}` `int` `main() {``    ``int` `k = 2;``    ``string st = ``"geeksforgeeks"``;``    ``string ans = reduced_String(k, st);``    ``cout << ans << endl;``    ``return` `0;``}`

## C

 `#include ``#include ``#include ` `#define MAX_SIZE 100` `// Function to remove k consecutive characters from the``// string``char``* reduced_String(``int` `k, ``char``* s)``{``    ``char` `stk[MAX_SIZE]; ``// Stack to store characters``    ``int` `top = -1; ``// Top index of stack``    ``int` `i = 0;` `    ``while` `(s[i] != ``'\0'``) {``        ``char` `ch = s[i++];``        ``stk[++top] = ch;` `        ``int` `count = 0;``        ``while` `(top >= k - 1 && stk[top] == ch) {``            ``count++;``            ``top--;``        ``}` `        ``if` `(count == k)``            ``continue``;``        ``else` `{``            ``while` `(count > 0) {``                ``stk[++top] = ch;``                ``count--;``            ``}``        ``}``    ``}` `    ``char``* result = (``char``*)``malloc``(``        ``(top + 2)``        ``* ``sizeof``(``char``)); ``// Allocate memory for the result` `    ``int` `resultIndex = 0;``    ``while` `(top >= 0) {``        ``result[resultIndex++] = stk[top];``        ``top--;``    ``}``    ``result[resultIndex]``        ``= ``'\0'``; ``// Null-terminate the result string` `    ``return` `result;``}` `// Driver code``int` `main()``{``    ``int` `k = 2;``    ``char` `st[] = ``"skgrofskg"``;` `    ``char``* ans = reduced_String(k, st);``    ``printf``(``"%s\n"``, ans);` `    ``free``(ans); ``// Free the memory allocated for the result` `    ``return` `0;``}`

## 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`

## C#

 `// Importing required libraries``using` `System;``using` `System.Collections.Generic;` `class` `Program {` `    ``// Function to reduce the string``    ``static` `string` `ReducedString(``int` `k, ``string` `s)``    ``{` `        ``// Creating an empty stack``        ``// to hold characters``        ``Stack<``char``> stk = ``new` `Stack<``char``>();``        ``int` `i = 0;` `        ``// Loop through each character``        ``// of the input string``        ``while` `(i < s.Length) {``            ``char` `ch = s[i++];``            ``stk.Push(ch);` `            ``int` `count = 0;` `            ``// Count the number of consecutive``            ``// occurrences of  current character``            ``while` `(stk.Count > 0 && stk.Peek() == ch) {``                ``count++;``                ``stk.Pop();``            ``}` `            ``// If the count is equal to k,``            ``// skip to the next character``            ``if` `(count == k)``                ``continue``;``            ``else` `{` `                ``// Otherwise, push back the``                ``// characters that were popped``                ``while` `(count > 0) {``                    ``stk.Push(ch);``                    ``count--;``                ``}``            ``}``        ``}` `        ``// Build the final reduced string``        ``// by popping all characters``        ``// from the stack``        ``string` `result = ``""``;``        ``while` `(stk.Count > 0) {``            ``result = stk.Pop() + result;``        ``}` `        ``return` `result;``    ``}` `    ``// Driver Code``    ``static` `void` `Main(``string``[] args)``    ``{``        ``int` `k = 2;``        ``string` `st = ``"geeksforgeeks"``;` `        ``string` `ans = ReducedString(k, st);` `        ``Console.WriteLine(ans);``    ``}``}`

## Javascript

 `// Function to reduce the string``function` `reducedString(k, s) {``// Creating an empty stack to hold characters``  ``const stk = [];``  ``let i = 0;` `// Loop through each character of the input string``   ``while` `(i < s.length) {``   ``const ch = s[i++];``   ``stk.push(ch);` `   ``let count = 0;` `// Count the number of consecutive occurrences of current character``while` `(stk.length > 0 && stk[stk.length - 1] === ch) {``  ``count++;``  ``stk.pop();``}` `// If the count is equal to k, skip to the next character``if` `(count === k) {``  ``continue``;``} ``else` `{``  ``// Otherwise, push back the characters that were popped``  ``while` `(count > 0) {``    ``stk.push(ch);``    ``count--;``  ``}``}``}` `// Build the final reduced string by popping all characters from the stack`` ``let result = ``""``;`` ``while` `(stk.length > 0) {`` ``result = stk.pop() + result;``}` `return` `result;``}` `// Driver Code``const k = 2;``const st = ``"geeksforgeeks"``;``const ans = reducedString(k, st);``console.log(ans);`

Output

`gksforgks`

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

My Personal Notes arrow_drop_up