JavaScript Program to FindNumber of Flips to make Binary String Alternate

Last Updated : 29 Aug, 2024

In this problem, we aim to determine the minimum number of flips needed to transform a binary string into an alternating sequence of '0's and '1's. A flip refers to changing a '0' to '1' or a '1' to '0'. The objective is to find the most efficient way to achieve this alternating pattern.

Examples:

Input : binaryStr = “101”
Output : 0
Minimum number of flips required = 0
We cannot flip 

Input : binaryStr = “111000111”
Output : 3
Minimum number of flips required = 3

Approach:

We can approach this problem by exploring all potential outcomes. Since we aim to achieve an alternating string, there are only two possibilities:

One where the alternate string starts with '0' and the other with '1'. We'll examine both scenarios and select the one that demands the fewest flips as our ultimate solution. To assess a scenario, it necessitates O(n) time, during which we'll traverse through all the characters in the given string.
If the current character aligns with the expected character for alternation, no action is taken; otherwise, we increment the flip count by 1. Following the examination of strings commencing with '0' and those beginning with '1', we will opt for the string with the minimal flip count.

Syntax:

function calculateMinimumFlips(str,startingChar) {
      // Implementation  
      return flipCount;  
}

Example: Below is the implementation of the above approach

JavaScript

// Function to invert a character
function invertCharacter(ch) {
    return ch === '0' ? '1' : '0';
}

/* Function to compute the minimum flips when
   forming an alternating string with 
   the given starting character 
*/
function calculateMinimumFlipsStartingFrom(str, startingChar) {
    let flipCount = 0;
    for (let i = 0; i < str.length; i++) {
        if (str.charAt(i) !== startingChar) 
        {
            flipCount++;
        }
        
        // Toggle the expected character in each iteration
        startingChar =
            invertCharacter(startingChar);
    }
    return flipCount;
}

/* Function to determine the minimum 
    number of flips required to make a binary 
*/
function findMinimumFlipsForStringAlternation(str) {
    return Math
        .min(calculateMinimumFlipsStartingFrom(str, '0'),
            calculateMinimumFlipsStartingFrom(str, '1'));
}

// Driver code to test the above method
let binaryStr = "111000111";
console.log(
    findMinimumFlipsForStringAlternation(binaryStr));

Output

Time Complexity: O(N)

Auxiliary Space: O(1)

Using a single iteration

This approach iterates through the binary string and calculates the flip count required for two scenarios: one where the string starts with '0' and the other where it starts with '1'. For each character position, it checks whether the expected character ('0' for even positions and '1' for odd positions) matches the actual character. If not, it increments the corresponding flip count. Finally, it returns the minimum of the two flip counts as the result.

JavaScript

function findMinimumFlipsForStringAlternation(str) {
    let flipCountStartWith0 = 0;
    let flipCountStartWith1 = 0;

    // Iterate through the string
    for (let i = 0; i < str.length; i++) {
        // If index is even, expected character should be '0'
        if (i % 2 === 0) {
    
            if (str[i] !== '0') {
                flipCountStartWith0++;
            }
     
            if (str[i] !== '1') {
                flipCountStartWith1++;
            }
        }
     
        else {
       
            if (str[i] !== '1') {
                flipCountStartWith0++;
            }
      
            if (str[i] !== '0') {
                flipCountStartWith1++;
            }
        }
    }

    // Return the minimum of the two flip counts
    return Math.min(flipCountStartWith0, flipCountStartWith1);
}


let binaryStr = "111000111";
console.log(findMinimumFlipsForStringAlternation(binaryStr)); // Output: 3

Output

Approach: Bitwise Pattern Matching

Idea: Utilize bitwise operations to compute the number of flips needed to match both possible alternating patterns. This approach is a variation of the initial method but focuses on utilizing bit manipulation to streamline the solution.

Steps:

Generate Two Patterns: We generate two possible alternating patterns for comparison:
- Pattern 1 starts with '0': "010101..." (repeating)
- Pattern 2 starts with '1': "101010..." (repeating)
Count Flips for Both Patterns: Compare the input string against both patterns and count the number of mismatches (flips) required for each pattern.
Return Minimum Flips: The result is the minimum number of flips required between the two patterns.

Example:

JavaScript

function countFlipsToMatchPattern(str, pattern) {
    let flipCount = 0;
    for (let i = 0; i < str.length; i++) {
        if (str[i] !== pattern[i]) {
            flipCount++;
        }
    }
    return flipCount;
}

function findMinimumFlipsForStringAlternation(str) {
    let n = str.length;
    let pattern1 = '';
    let pattern2 = '';
    for (let i = 0; i < n; i++) {
        pattern1 += i % 2 === 0 ? '0' : '1';
        pattern2 += i % 2 === 0 ? '1' : '0';
    }
    let flipsForPattern1 = countFlipsToMatchPattern(str, pattern1);
    let flipsForPattern2 = countFlipsToMatchPattern(str, pattern2);
    return Math.min(flipsForPattern1, flipsForPattern2);
}

let binaryStr = "111000111";
console.log(findMinimumFlipsForStringAlternation(binaryStr));

Output

JavaScript Program to FindNumber of Flips to make Binary String Alternate

anjugaeu01

Improve

Article Tags :

JavaScript Program to FindNumber of Flips to make Binary String Alternate

Approach:

Syntax:

Using a single iteration

Approach: Bitwise Pattern Matching

Similar Reads

Thank You!

What kind of Experience do you want to share?