Skip to content
Related Articles

Related Articles

Improve Article

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 <iostream>
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[0]
        == 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[0])
                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[0])
                    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[0])
                        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[0] == 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[0])
                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[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)
            {
                Console.Write("Yes, ");
 
                // Print the sequence
                for(int i = 0; i < n; i++)
                {
                    if (str[i] == str[0])
                        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




<script>
 
        // JavaScript program for the above approach;
// Function to check if the given
// string can be converted to a
// balanced bracket sequence or not
function balBracketSequence(str)
{
    let n = str.length;
 
    // Check if the first and
    // last characters are equal
    if (str[0]
        == str[n - 1])
 
    {
        document.write( "No");
    }
    else {
 
        // Initialize two variables to store
        // the count of open and closed brackets
        let cntForOpen = 0, cntForClose = 0;
        let check = 1;
        for (let i = 0; i < n; i++) {
 
            // If the current character is
            // same as the first character
            if (str[i] == str[0])
                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) {
            document.write("Yes, ");
 
            // Print the new string
            for (let i = 0; i < n; i++) {
                if (str[i] == str[n - 1])
                    document.write(')');
                else
                    document.write('(');
            }
            return;
        }
        else {
            for (let i = 0; i < n; i++) {
 
                // If the current character is
                // same as the first character
                if (str[i] == str[0])
                    cntForClose++;
                else
                    cntForClose--;
 
                // If bracket sequence
                // is not balanced
                if (cntForClose
                    < 0) {
                    check = 0;
                    break;
                }
            }
 
            // Check for unbalanced
            // bracket sequence
            if (check
                && cntForClose
                       == 0) {
                document.write("Yes, ");
 
                // Print the sequence
                for (let i = 0; i < n;
                     i++) {
                    if (str[i] == str[0])
                        document.write('(');
                    else
                        document.write(')');
                }
                return;
            }
        }
       document.write("NO") ;
    }
}
 
// Driver Code
 
    // Given Input
    let str = "123122";
 
    // Function Call
    balBracketSequence(str);
    
   // This code is contributed by Potta Lokesh
    </script>
Output: 
Yes, ()(())

 

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

 

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :