Min Adjacent Swaps for Bracket Balancing

// Java program to count swaps required to balance string

public class GFG {
    
    // Function to calculate swaps required
    static int swapCount(String s) {
        
        //To store answer
        int ans = 0;
        
        //To store count of '['
        int count = 0;
        
        //Size of string
        int n = s.length();
        
        //Traverse over the string
        for (int i = 0; i < n; i++) {
            //When '[' encounters
            if (s.charAt(i) == '[')
                count++;
            //when ']' encounters
            else
                count--;
            //When count becomes less than 0
            if (count < 0) {
                //Start searching for '[' from (i+1)th index
                int j = i + 1;
                while (j < n) {
                    //When jth index contains '['
                    if (s.charAt(j) == '[')
                        break;
                    j++;
                }
                
                //Increment answer
                ans += j - i;
                
                //Set Count to 1 again
                count = 1;
                
                //Bring character at jth position to ith position
                //and shift all character from i to j-1 
                //towards right 
                char ch = s.charAt(j);
                StringBuilder newString = new StringBuilder(s);
                for (int k = j; k > i; k--) {
                    newString.setCharAt(k, s.charAt(k - 1));
                }
                newString.setCharAt(i, ch);
                s = newString.toString();
            }
        }

        return ans;
    }
    
    // Driver code
    public static void main(String[] args) {
        String s = "[]][][";
        System.out.println(swapCount(s));

        s = "[[][]]";
        System.out.println(swapCount(s));
    }
}

// Java program to count swaps 
// required to balance string
import java.util.*;

class GFG{
    
// Function to calculate swaps required
public static long swapCount(String s)
{
    
    // Keep track of '['
    Vector<Integer> pos = new Vector<Integer>(); 
    for(int i = 0; i < s.length(); ++i)
        if (s.charAt(i) == '[')
            pos.add(i);
            
    // To count number of encountered '['
    int count = 0; 
    
    // To track position of next '[' in pos
    int p = 0;  
    
    // To store result
    long sum = 0; 
    
    char[] S = s.toCharArray(); 
    
    for(int i = 0; i < s.length(); ++i)
    {
        
        // Increment count and move p 
        // to next position
        if (S[i] == '[')
        {
            ++count;
            ++p;
        }
        else if (S[i] == ']')
            --count;
 
        // We have encountered an 
        // unbalanced part of string
        if (count < 0)
        {
            
            // Increment sum by number of 
            // swaps required i.e. position 
            // of next '[' - current position
            sum += pos.get(p) - i;
            char temp = S[i];
            S[i] = S[pos.get(p)];
            S[pos.get(p)] = temp;
            ++p;
 
            // Reset count to 1
            count = 1;
        }
    }
    return sum;
}

// Driver code
public static void main(String[] args) 
{
    String s = "[]][][";
    System.out.println(swapCount(s));
 
    s = "[[][]]";
    System.out.println(swapCount(s));
}
}

// This code is contributed by divyesh072019

// Java Program to count swaps required to balance string
public class BalanceParan 
{
    
    static long swapCount(String s) 
    {
        char[] chars = s.toCharArray();
        
        // stores total number of Left and Right 
        // brackets encountered
        int countLeft = 0, countRight = 0; 
                // swap stores the number of swaps required
        //imbalance maintains the number of imbalance pair
        int swap = 0 , imbalance = 0; 
        
        for(int i =0; i< chars.length; i++) 
        {
            if(chars[i] == '[') 
            {
                // increment count of Left bracket
                countLeft++; 
                if(imbalance > 0) 
                {
                    // swaps count is last swap count + total 
                    // number imbalanced brackets
                    swap += imbalance; 
                    // imbalance decremented by 1 as it solved
                    // only one imbalance of Left and Right
                    imbalance--;     
                }
            } else if(chars[i] == ']' ) 
            {
                // increment count of Right bracket
                countRight++; 
                // imbalance is reset to current difference 
                // between Left and Right brackets
                imbalance = (countRight-countLeft); 
            }
        }
        return swap;
    }

// Driver code
    public static void main(String args[]) 
    {
        String s = "[]][][";
        System.out.println(swapCount(s) );

        s = "[[][]]";
        System.out.println(swapCount(s) );
        
    }
}
// This code is contributed by Janmejaya Das.