# Decode a string recursively encoded as count followed by substring

• Difficulty Level : Medium
• Last Updated : 02 Dec, 2021

An encoded string (s) is given, the task is to decode it. The pattern in which the strings are encoded is as follows.

```<count>[sub_str] ==> The substring 'sub_str'
appears count times.```

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

```Input : str[] = "1[b]"
Output : b

Input : str[] = "2[ab]"
Output : abab

Input : str[] = "2[a2[b]]"
Output : abbabb

Input : str[] = "3[b2[ca]]"
Output : bcacabcacabcaca```

## Method 1(Using 2 stacks)

The idea is to use two stacks, one for integers and another for characters.
Now, traverse the string,

1. Whenever we encounter any number, push it into the integer stack and in case of any alphabet (a to z) or open bracket (‘[‘), push it onto the character stack.
2. Whenever any close bracket (‘]’) is encounter pop the character from the character stack until open bracket (‘[‘) is not found in the character stack. Also, pop the top element from the integer stack, say n. Now make a string repeating the popped character n number of time. Now, push all character of the string in the stack.

Below is the implementation of this approach:

## C++

 `// C++ program to decode a string recursively``// encoded as count followed substring``#include``using` `namespace` `std;` `// Returns decoded string for 'str'``string decode(string str)``{``    ``stack<``int``> integerstack;``    ``stack<``char``> stringstack;``    ``string temp = ``""``, result = ``""``;` `    ``// Traversing the string``    ``for` `(``int` `i = 0; i < str.length(); i++)``    ``{``        ``int` `count = 0;` `        ``// If number, convert it into number``        ``// and push it into integerstack.``        ``if` `(str[i] >= ``'0'` `&& str[i] <=``'9'``)``        ``{``            ``while` `(str[i] >= ``'0'` `&& str[i] <= ``'9'``)``            ``{``                ``count = count * 10 + str[i] - ``'0'``;``                ``i++;``            ``}` `            ``i--;``            ``integerstack.push(count);``        ``}` `        ``// If closing bracket ']', pop element until``        ``// '[' opening bracket is not found in the``        ``// character stack.``        ``else` `if` `(str[i] == ``']'``)``        ``{``            ``temp = ``""``;``            ``count = 0;` `            ``if` `(! integerstack.empty())``            ``{``                ``count = integerstack.top();``                ``integerstack.pop();``            ``}` `            ``while` `(! stringstack.empty() && stringstack.top()!=``'['` `)``            ``{``                ``temp = stringstack.top() + temp;``                ``stringstack.pop();``            ``}` `            ``if` `(! stringstack.empty() && stringstack.top() == ``'['``)``                ``stringstack.pop();` `            ``// Repeating the popped string 'temo' count``            ``// number of times.``            ``for` `(``int` `j = 0; j < count; j++)``                ``result = result + temp;` `            ``// Push it in the character stack.``            ``for` `(``int` `j = 0; j < result.length(); j++)``                ``stringstack.push(result[j]);` `            ``result = ``""``;``        ``}` `        ``// If '[' opening bracket, push it into character stack.``        ``else` `if` `(str[i] == ``'['``)``        ``{``            ``if` `(str[i-1] >= ``'0'` `&& str[i-1] <= ``'9'``)``                ``stringstack.push(str[i]);` `            ``else``            ``{``                ``stringstack.push(str[i]);``                ``integerstack.push(1);``            ``}``        ``}` `        ``else``            ``stringstack.push(str[i]);``    ``}` `    ``// Pop all the element, make a string and return.``    ``while` `(! stringstack.empty())``    ``{``        ``result = stringstack.top() + result;``        ``stringstack.pop();``    ``}` `    ``return` `result;``}` `// Driven Program``int` `main()``{``    ``string str = ``"3[b2[ca]]"``;``    ``cout << decode(str) << endl;``    ``return` `0;``}`

## Java

 `// Java program to decode a string recursively``// encoded as count followed substring` `import` `java.util.Stack;` `class` `Test``{``    ``// Returns decoded string for 'str'``    ``static` `String decode(String str)``    ``{``        ``Stack integerstack = ``new` `Stack<>();``        ``Stack stringstack = ``new` `Stack<>();``        ``String temp = ``""``, result = ``""``;``     ` `        ``// Traversing the string``        ``for` `(``int` `i = ``0``; i < str.length(); i++)``        ``{``            ``int` `count = ``0``;``     ` `            ``// If number, convert it into number``            ``// and push it into integerstack.``            ``if` `(Character.isDigit(str.charAt(i)))``            ``{``                ``while` `(Character.isDigit(str.charAt(i)))``                ``{``                    ``count = count * ``10` `+ str.charAt(i) - ``'0'``;``                    ``i++;``                ``}``     ` `                ``i--;``                ``integerstack.push(count);``            ``}``     ` `            ``// If closing bracket ']', pop element until``            ``// '[' opening bracket is not found in the``            ``// character stack.``            ``else` `if` `(str.charAt(i) == ``']'``)``            ``{``                ``temp = ``""``;``                ``count = ``0``;``     ` `                ``if` `(!integerstack.isEmpty())``                ``{``                    ``count = integerstack.peek();``                    ``integerstack.pop();``                ``}``     ` `                ``while` `(!stringstack.isEmpty() && stringstack.peek()!=``'['` `)``                ``{``                    ``temp = stringstack.peek() + temp;``                    ``stringstack.pop();``                ``}``     ` `                ``if` `(!stringstack.empty() && stringstack.peek() == ``'['``)``                    ``stringstack.pop();``     ` `                ``// Repeating the popped string 'temo' count``                ``// number of times.``                ``for` `(``int` `j = ``0``; j < count; j++)``                    ``result = result + temp;``     ` `                ``// Push it in the character stack.``                ``for` `(``int` `j = ``0``; j < result.length(); j++)``                    ``stringstack.push(result.charAt(j));``     ` `                ``result = ``""``;``            ``}``     ` `            ``// If '[' opening bracket, push it into character stack.``            ``else` `if` `(str.charAt(i) == ``'['``)``            ``{``                ``if` `(Character.isDigit(str.charAt(i-``1``)))``                    ``stringstack.push(str.charAt(i));``     ` `                ``else``                ``{``                    ``stringstack.push(str.charAt(i));``                    ``integerstack.push(``1``);``                ``}``            ``}``     ` `            ``else``                ``stringstack.push(str.charAt(i));``        ``}``     ` `        ``// Pop all the element, make a string and return.``        ``while` `(!stringstack.isEmpty())``        ``{``            ``result = stringstack.peek() + result;``            ``stringstack.pop();``        ``}``     ` `        ``return` `result;``    ``}` `    ``// Driver method``    ``public` `static` `void` `main(String args[])``    ``{``        ``String str = ``"3[b2[ca]]"``;``        ``System.out.println(decode(str));``    ``}``}`

## Python3

 `# Python program to decode a string recursively``# encoded as count followed substring` `# Returns decoded string for 'str'``def` `decode(``Str``):``    ``integerstack ``=` `[]``    ``stringstack ``=` `[]``    ``temp ``=` `""``    ``result ``=` `""``    ``i ``=` `0``    ``# Traversing the string``    ``while` `i < ``len``(``Str``):``        ``count ``=` `0` `        ``# If number, convert it into number``        ``# and push it into integerstack.``        ``if` `(``Str``[i] >``=` `'0'` `and` `Str``[i] <``=``'9'``):``            ``while` `(``Str``[i] >``=` `'0'` `and` `Str``[i] <``=` `'9'``):``                ``count ``=` `count ``*` `10` `+` `ord``(``Str``[i]) ``-` `ord``(``'0'``)``                ``i ``+``=` `1``            ``i ``-``=` `1``            ``integerstack.append(count)` `        ``# If closing bracket ']', pop element until``        ``# '[' opening bracket is not found in the``        ``# character stack.``        ``elif` `(``Str``[i] ``=``=` `']'``):``            ``temp ``=` `""``            ``count ``=` `0` `            ``if` `(``len``(integerstack) !``=` `0``):``                ``count ``=` `integerstack[``-``1``]``                ``integerstack.pop()` `            ``while` `(``len``(stringstack) !``=` `0` `and` `stringstack[``-``1``] !``=``'['` `):``                ``temp ``=` `stringstack[``-``1``] ``+` `temp``                ``stringstack.pop()` `            ``if` `(``len``(stringstack) !``=` `0` `and` `stringstack[``-``1``] ``=``=` `'['``):``                ``stringstack.pop()` `            ``# Repeating the popped string 'temo' count``            ``# number of times.``            ``for` `j ``in` `range``(count):``                ``result ``=` `result ``+` `temp` `            ``# Push it in the character stack.``            ``for` `j ``in` `range``(``len``(result)):``                ``stringstack.append(result[j])` `            ``result ``=` `""` `        ``# If '[' opening bracket, push it into character stack.``        ``elif` `(``Str``[i] ``=``=` `'['``):``            ``if` `(``Str``[i``-``1``] >``=` `'0'` `and` `Str``[i``-``1``] <``=` `'9'``):``                ``stringstack.append(``Str``[i])` `            ``else``:``                ``stringstack.append(``Str``[i])``                ``integerstack.append(``1``)` `        ``else``:``            ``stringstack.append(``Str``[i])``        ` `        ``i ``+``=` `1` `    ``# Pop all the element, make a string and return.``    ``while` `len``(stringstack) !``=` `0``:``        ``result ``=` `stringstack[``-``1``] ``+` `result``        ``stringstack.pop()` `    ``return` `result` `# Driven code``if` `__name__ ``=``=` `'__main__'``:``    ``Str` `=` `"3[b2[ca]]"``    ``print``(decode(``Str``))``    ` `# This code is contributed by PranchalK.`

## C#

 `// C# program to decode a string recursively``// encoded as count followed substring``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``// Returns decoded string for 'str'``public` `static` `string` `decode(``string` `str)``{``    ``Stack<``int``> integerstack = ``new` `Stack<``int``>();``    ``Stack<``char``> stringstack = ``new` `Stack<``char``>();``    ``string` `temp = ``""``, result = ``""``;` `    ``// Traversing the string``    ``for` `(``int` `i = 0; i < str.Length; i++)``    ``{``        ``int` `count = 0;` `        ``// If number, convert it into number``        ``// and push it into integerstack.``        ``if` `(``char``.IsDigit(str[i]))``        ``{``            ``while` `(``char``.IsDigit(str[i]))``            ``{``                ``count = count * 10 + str[i] - ``'0'``;``                ``i++;``            ``}` `            ``i--;``            ``integerstack.Push(count);``        ``}` `        ``// If closing bracket ']', pop element``        ``// until '[' opening bracket is not found``        ``// in the character stack.``        ``else` `if` `(str[i] == ``']'``)``        ``{``            ``temp = ``""``;``            ``count = 0;` `            ``if` `(integerstack.Count > 0)``            ``{``                ``count = integerstack.Peek();``                ``integerstack.Pop();``            ``}` `            ``while` `(stringstack.Count > 0 &&``                   ``stringstack.Peek() != ``'['``)``            ``{``                ``temp = stringstack.Peek() + temp;``                ``stringstack.Pop();``            ``}` `            ``if` `(stringstack.Count > 0 &&``                ``stringstack.Peek() == ``'['``)``            ``{``                ``stringstack.Pop();``            ``}` `            ``// Repeating the popped string 'temo'``            ``// count number of times.``            ``for` `(``int` `j = 0; j < count; j++)``            ``{``                ``result = result + temp;``            ``}` `            ``// Push it in the character stack.``            ``for` `(``int` `j = 0; j < result.Length; j++)``            ``{``                ``stringstack.Push(result[j]);``            ``}` `            ``result = ``""``;``        ``}` `        ``// If '[' opening bracket, push it``        ``// into character stack.``        ``else` `if` `(str[i] == ``'['``)``        ``{``            ``if` `(``char``.IsDigit(str[i - 1]))``            ``{``                ``stringstack.Push(str[i]);``            ``}` `            ``else``            ``{``                ``stringstack.Push(str[i]);``                ``integerstack.Push(1);``            ``}``        ``}` `        ``else``        ``{``            ``stringstack.Push(str[i]);``        ``}``    ``}` `    ``// Pop all the element, make a``    ``// string and return.``    ``while` `(stringstack.Count > 0)``    ``{``        ``result = stringstack.Peek() + result;``        ``stringstack.Pop();``    ``}` `    ``return` `result;``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``string` `str = ``"3[b2[ca]]"``;``    ``Console.WriteLine(decode(str));``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``
Output
`bcacabcacabcaca`

<!—-Illustration of above code for “3[b2[ca]]”

## Method 2(Using 1 stack)

Algorithm:

Loop through the characters of the string

If the character is not ‘]’, add it to the stack

If the character is ‘]’:

While top of the stack doesn’t contain ‘[‘, pop the characters from the stack and store it in a string temp(Make sure the string isn’t in reverse order)

Pop ‘[‘ from the stack

While the top of the stack contains a digit, pop it and store it in dig

Concatenate the string temp for dig number of times and store it in a string repeat

Add the string repeat to the stack

Pop all the characters from the stack(also make the string isn’t in reverse order)

Below is the implementation of this approach:

## C++

 `#include ``#include ``using` `namespace` `std;` `string decodeString(string s)``{``    ``stack<``char``> st;``    ``for` `(``int` `i = 0; i < s.length(); i++) {``        ``// When ']' is encountered, we need to start``        ``// decoding``        ``if` `(s[i] == ``']'``) {``            ``string temp;``            ``while` `(!st.empty() && st.top() != ``'['``) {``                ``// st.top() + temp makes sure that the``                ``// string won't be in reverse order eg, if``                ``// the stack contains 12[abc temp = c + "" =>``                ``// temp = b + "c" => temp = a + "bc"``                ``temp = st.top() + temp;``                ``st.pop();``            ``}``            ``// remove the '[' from the stack``            ``st.pop();``            ``string num;``            ``// remove the digits from the stack``            ``while` `(!st.empty() && ``isdigit``(st.top())) {``                ``num = st.top() + num;``                ``st.pop();``            ``}``            ``int` `number = stoi(num);``            ``string repeat;``            ``for` `(``int` `j = 0; j < number; j++)``                ``repeat += temp;``            ``for` `(``char` `c : repeat)``                ``st.push(c);``        ``}``        ``// if s[i] is not ']', simply push s[i] to the stack``        ``else``            ``st.push(s[i]);``    ``}``    ``string res;``    ``while` `(!st.empty()) {``        ``res = st.top() + res;``        ``st.pop();``    ``}``    ``return` `res;``}``// driver code``int` `main()``{``    ``string str = ``"3[b2[ca]]"``;``    ``cout << decodeString(str);``    ``return` `0;``}`

## Python3

 `def` `decodeString(s):``    ``st ``=` `[]``    ``for` `i ``in` `range``(``len``(s)):``      ` `        ``# When ']' is encountered, we need to start decoding``        ``if` `s[i] ``=``=` `']'``:``            ``temp ``=` `""``            ``while` `len``(st) > ``0` `and` `st[``-``1``] !``=` `'['``:``              ` `                ``# st.top() + temp makes sure that the``                ``# string won't be in reverse order eg, if``                ``# the stack contains 12[abc temp = c + "" =>``                ``# temp = b + "c" => temp = a + "bc"``                ``temp ``=` `st[``-``1``] ``+` `temp``                ``st.pop()``             ` `            ``# remove the '[' from the stack``            ``st.pop()``            ``num ``=` `""``             ` `            ``# remove the digits from the stack``            ``while` `len``(st) > ``0` `and` `ord``(st[``-``1``]) >``=` `48` `and` `ord``(st[``-``1``]) <``=` `57``:``                ``num ``=` `st[``-``1``] ``+` `num``                ``st.pop()``            ``number ``=` `int``(num)``            ``repeat ``=` `""``            ``for` `j ``in` `range``(number):``                ``repeat ``+``=` `temp``            ``for` `c ``in` `range``(``len``(repeat)):``                ``st.append(repeat)``         ` `        ``# if s[i] is not ']', simply push s[i] to the stack``        ``else``:``            ``st.append(s[i])``    ``res ``=` `"bcacabcacabcaca"``    ``while` `len``(st) < ``0``:``        ``res ``=`  `st[``-``1``] ``+` `res``        ``st.pop()``    ``return` `res` `Str` `=` `"3[b2[ca]]"``print``(decodeString(``Str``))` `# This code is contributed by mukesh07.`

## Javascript

 ``
Output
`bcacabcacabcaca`

This article is contributed by Anuj Chauhan and Gobinath A L. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.