# Modify a numeric string to a balanced parentheses by replacements

• Last Updated : 08 Sep, 2021

Given a numeric string S made up of characters ‘1’, ‘2’ and ‘3’ only, the task is to replace characters with either an open bracket ( ‘(‘ ) or a closed bracket ( ‘)’ ) such that the newly formed string becomes a balanced bracket sequence.

Note: All occurrences of a character must be replaced by the same parentheses.

Examples:

Input: S = “1123”
Output: Yes, (())
Explanation: Replacing occurrences of character ‘1’ with ‘(‘, ‘2’ with ‘)’ and ‘3’ with ‘)’. Therefore, the obtained bracket sequence is “(())”, which is balanced.

Input: S = “1121”
Output: No

Approach: The given problem can be solved based on the following observations:

• For a balanced bracket sequence, it is necessary for the first and last characters to be open and closed brackets respectively. Therefore, the first and the last characters should be different.
• If the first and the last characters of a string are the same, then it is impossible to obtain a balanced bracket sequence.
• If the first and last characters of a string are different, then they are replaced by open and closed brackets respectively. The third character is replaced either by open or closed brackets.
• Check for both ways of replacements one by one for the remaining third character.
• If both replacements of the third remaining character can’t make a balanced bracket sequence, then it is impossible to make a balanced bracket sequence.

Follow the steps below to solve the given problem:

• Check if the first and last characters of the string S are equal or not. If found to be true, then print “No” and return.
• Initialize two variables, say cntforOpen and cntforClose, to store the count of open and closed brackets.
• Iterate over the characters of the string and perform the following operations:
• If the current character is the same as the first character of the string, increment cntforOpen.
• If the current character is the same as the last character of the string, decrement cntforOpen.
• For the remaining third character, increment cntforOpen, i.e. replacing that character with ‘(‘.
• If at any instant, cntforOpen is found to be negative, then a balanced bracket sequence cannot be obtained.
• Similarly, check using cntforClose variable, i.e. replacing the third character with ‘)’.
• If none of the above two methods generates a balanced bracket sequence, then print “No”. Otherwise, print “Yes”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to check if the given``// string can be converted to a``// balanced bracket sequence or not``void` `balBracketSequence(string str)``{``    ``int` `n = str.size();` `    ``// Check if the first and``    ``// last characters are equal``    ``if` `(str``        ``== str[n - 1])` `    ``{``        ``cout << ``"No"` `<< endl;``    ``}``    ``else` `{` `        ``// Initialize two variables to store``        ``// the count of open and closed brackets``        ``int` `cntForOpen = 0, cntForClose = 0;``        ``int` `check = 1;``        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// If the current character is``            ``// same as the first character``            ``if` `(str[i] == str)``                ``cntForOpen++;` `            ``// If the current character is``            ``// same as the last character``            ``else` `if` `(str[i] == str[n - 1])``                ``cntForOpen--;``            ``else``                ``cntForOpen++;` `            ``// If count of open brackets``            ``// becomes less than 0``            ``if` `(cntForOpen < 0) {``                ``check = 0;``                ``break``;``            ``}``        ``}``        ``if` `(check && cntForOpen == 0) {``            ``cout << ``"Yes, "``;` `            ``// Print the new string``            ``for` `(``int` `i = 0; i < n; i++) {``                ``if` `(str[i] == str[n - 1])``                    ``cout << ``')'``;``                ``else``                    ``cout << ``'('``;``            ``}``            ``return``;``        ``}``        ``else` `{``            ``for` `(``int` `i = 0; i < n; i++) {` `                ``// If the current character is``                ``// same as the first character``                ``if` `(str[i] == str)``                    ``cntForClose++;``                ``else``                    ``cntForClose--;` `                ``// If bracket sequence``                ``// is not balanced``                ``if` `(cntForClose``                    ``< 0) {``                    ``check = 0;``                    ``break``;``                ``}``            ``}` `            ``// Check for unbalanced``            ``// bracket sequence``            ``if` `(check``                ``&& cntForClose``                       ``== 0) {``                ``cout << ``"Yes, "``;` `                ``// Print the sequence``                ``for` `(``int` `i = 0; i < n;``                     ``i++) {``                    ``if` `(str[i] == str)``                        ``cout << ``'('``;``                    ``else``                        ``cout << ``')'``;``                ``}``                ``return``;``            ``}``        ``}``        ``cout << ``"No"``;``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``string str = ``"123122"``;` `    ``// Function Call``    ``balBracketSequence(str);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to check if the given``// string can be converted to a``// balanced bracket sequence or not``static` `void` `balBracketSequence(String str)``{``    ``int` `n = str.length();` `    ``// Check if the first and``    ``// last characters are equal``    ``if` `(str.charAt(``0``)``        ``== str.charAt(n - ``1``))` `    ``{``        ``System.out.println(``"No"``);``    ``}``    ``else` `{` `        ``// Initialize two variables to store``        ``// the count of open and closed brackets``        ``int` `cntForOpen = ``0``, cntForClose = ``0``;``        ``int` `check = ``1``;``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// If the current character is``            ``// same as the first character``            ``if` `(str.charAt(i) == str.charAt(``0``))``                ``cntForOpen++;` `            ``// If the current character is``            ``// same as the last character``            ``else` `if` `(str.charAt(i) == str.charAt(n - ``1``))``                ``cntForOpen -= ``1``;``            ``else``                ``cntForOpen += ``1``;` `            ``// If count of open brackets``            ``// becomes less than 0``            ``if` `(cntForOpen < ``0``) {``                ``check = ``0``;``                ``break``;``            ``}``        ``}``        ``if` `(check != ``0` `&& cntForOpen == ``0``) {``            ``System.out.print(``"Yes, "``);` `            ``// Print the new string``            ``for` `(``int` `i = ``0``; i < n; i++) {``                ``if` `(str.charAt(i) == str.charAt(n - ``1``))``                    ``System.out.print(``')'``);``                ``else``                   ``System.out.print(``'('``);``            ``}``            ``return``;``        ``}``        ``else` `{``            ``for` `(``int` `i = ``0``; i < n; i++) {` `                ``// If the current character is``                ``// same as the first character``                ``if` `(str.charAt(i) == str.charAt(``0``))``                    ``cntForClose++;``                ``else``                    ``cntForClose--;` `                ``// If bracket sequence``                ``// is not balanced``                ``if` `(cntForClose``                    ``< ``0``) {``                    ``check = ``0``;``                    ``break``;``                ``}``            ``}` `            ``// Check for unbalanced``            ``// bracket sequence``            ``if` `(check != ``0``                ``&& cntForClose``                       ``== ``0``) {``                ``System.out.print(``"Yes, "``);` `                ``// Print the sequence``                ``for` `(``int` `i = ``0``; i < n;``                     ``i++) {``                    ``if` `(str.charAt(i) == str.charAt(``0``))``                       ``System.out.print(``'('``);``                    ``else``                        ``System.out.print(``')'``);``                ``}``                ``return``;``            ``}``        ``}``        ``System.out.print(``"No"``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``// Given Input``    ``String str = ``"123122"``;` `    ``// Function Call``    ``balBracketSequence(str);``}``}` `// This code is contributed by ipg2016107.`

## Python3

 `# Python program for the above approach;``# Function to check if the given``# string can be converted to a``# balanced bracket sequence or not``def` `balBracketSequence(``str``):``    ``n ``=` `len``(``str``)` `    ``# Check if the first and``    ``# last characters are equal``    ``if` `(``str``[``0``] ``=``=` `str``[n ``-` `1``]):``        ``print``(``"No"``, end``=``"")``    ``else``:` `        ``# Initialize two variables to store``        ``# the count of open and closed brackets``        ``cntForOpen ``=` `0``        ``cntForClose ``=` `0``        ``check ``=` `1` `        ``for` `i ``in` `range``(n):` `            ``# If the current character is``            ``# same as the first character``            ``if` `(``str``[i] ``=``=` `str``[``0``]):``                ``cntForOpen ``+``=` `1` `            ``# If the current character is``            ``# same as the last character``            ``elif` `str``[i] ``=``=` `str``[n ``-` `1``] :``                ``cntForOpen ``-``=` `1``            ``else``:``                ``cntForOpen ``+``=` `1` `            ``# If count of open brackets``            ``# becomes less than 0``            ``if` `(cntForOpen < ``0``):``                ``check ``=` `0``                ``break``            ` `        ` `        ``if` `(check ``and` `cntForOpen ``=``=` `0``):``            ``print``(``"Yes, "``, end``=``"")` `            ``# Print the new string``            ``for` `i ``in` `range``(n):``                ``if` `(``str``[i] ``=``=` `str``[n ``-` `1``]):``                    ``print``(``')'``, end``=``"")``                ``else``:``                    ``print``(``'('``, end``=``"")``            ` `            ``return``        ` `        ``else``:``            ``for` `i ``in` `range``(n):` `                ``# If the current character is``                ``# same as the first character``                ``if` `(``str``[i] ``=``=` `str``[``0``]):``                    ``cntForClose ``+``=` `1``                ``else``:``                    ``cntForClose ``-``=` `1` `                ``# If bracket sequence``                ``# is not balanced``                ``if` `(cntForClose < ``0``):``                    ``check ``=` `0``                    ``break``                ` `            `  `            ``# Check for unbalanced``            ``# bracket sequence``            ``if` `(check ``and` `cntForClose ``=``=` `0``):``                ``print``(``"Yes, "``, end``=``"")` `                ``# Print the sequence``                ``for` `i ``in` `range``(n):``                    ``if` `(``str``[i] ``=``=` `str``[``0``]):``                        ``print``(``'('``, end``=``"") ``                    ``else``:``                        ``print``(``')'``, end``=``"")``                ` `                ``return``            ` `        ` `        ``print``(``"NO"``, end``=``"")``    `   `# Driver Code` `# Given Input``str` `=` `"123122"` `# Function Call``balBracketSequence(``str``)` `# This code is contributed by gfgking`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to check if the given``// string can be converted to a``// balanced bracket sequence or not``static` `void` `balBracketSequence(``string` `str)``{``    ``int` `n = str.Length;``    ` `    ``// Check if the first and``    ``// last characters are equal``    ``if` `(str == str[n - 1])``    ``{``        ``Console.Write(``"No"``);``    ``}``    ``else``    ``{``        ` `        ``// Initialize two variables to store``        ``// the count of open and closed brackets``        ``int` `cntForOpen = 0, cntForClose = 0;``        ``int` `check = 1;``        ` `        ``for``(``int` `i = 0; i < n; i++)``        ``{``            ` `            ``// If the current character is``            ``// same as the first character``            ``if` `(str[i] == str)``                ``cntForOpen++;` `            ``// If the current character is``            ``// same as the last character``            ``else` `if` `(str[i] == str[n - 1])``                ``cntForOpen--;``            ``else``                ``cntForOpen++;` `            ``// If count of open brackets``            ``// becomes less than 0``            ``if` `(cntForOpen < 0)``            ``{``                ``check = 0;``                ``break``;``            ``}``        ``}``        ``if` `(check != 0 && cntForOpen == 0)``        ``{``            ``Console.Write(``"Yes, "``);` `            ``// Print the new string``            ``for``(``int` `i = 0; i < n; i++)``            ``{``                ``if` `(str[i] == str[n - 1])``                    ``Console.Write(``')'``);``                ``else``                    ``Console.Write(``'('``);``            ``}``            ``return``;``        ``}``        ``else``        ``{``            ``for``(``int` `i = 0; i < n; i++)``            ``{``                ` `                ``// If the current character is``                ``// same as the first character``                ``if` `(str[i] == str)``                    ``cntForClose++;``                ``else``                    ``cntForClose--;` `                ``// If bracket sequence``                ``// is not balanced``                ``if` `(cntForClose < 0)``                ``{``                    ``check = 0;``                    ``break``;``                ``}``            ``}` `            ``// Check for unbalanced``            ``// bracket sequence``            ``if` `(check != 0 && cntForClose == 0)``            ``{``                ``Console.Write(``"Yes, "``);` `                ``// Print the sequence``                ``for``(``int` `i = 0; i < n; i++)``                ``{``                    ``if` `(str[i] == str)``                        ``Console.Write(``'('``);``                    ``else``                        ``Console.Write(``')'``);``                ``}``                ``return``;``            ``}``        ``}``        ``Console.Write(``"No"``);``    ``}``}` `// Driver Code``public` `static` `void` `Main()``{``    ` `    ``// Given Input``    ``string` `str = ``"123122"``;` `    ``// Function Call``    ``balBracketSequence(str);``}``}` `// This code is contributed by sanjoy_62`

## Javascript

 ``

Output:

`Yes, ()(())`

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

My Personal Notes arrow_drop_up