Skip to content

1758. Minimum Changes To Make Alternating Binary String

Description

You are given a string s consisting only of the characters '0' and '1'. In one operation, you can change any '0' to '1' or vice versa.

The string is called alternating if no two adjacent characters are equal. For example, the string "010" is alternating, while the string "0100" is not.

Return the minimum number of operations needed to make s alternating.

Β 

Example 1:

Input: s = "0100"
Output: 1
Explanation: If you change the last character to '1', s will be "0101", which is alternating.

Example 2:

Input: s = "10"
Output: 0
Explanation: s is already alternating.

Example 3:

Input: s = "1111"
Output: 2
Explanation: You need two operations to reach "0101" or "1010".

Β 

Constraints:

  • 1 <= s.length <= 104
  • s[i] is either '0' or '1'.

Solutions

Solution 1: Single Pass

According to the problem, if the number of operations needed to obtain the alternating string 01010101... is \(\textit{cnt}\), then the number of operations needed to obtain the alternating string 10101010... is \(n - \textit{cnt}\).

Therefore, we only need to traverse the string \(s\) once, count the value of \(\textit{cnt}\), and the answer is \(\min(\textit{cnt}, n - \textit{cnt})\).

The time complexity is \(O(n)\), where \(n\) is the length of the string \(s\). The space complexity is \(O(1)\).

1
2
3
4
class Solution:
    def minOperations(self, s: str) -> int:
        cnt = sum(c != '01'[i & 1] for i, c in enumerate(s))
        return min(cnt, len(s) - cnt)

1
2
3
4
5
6
7
8
9
class Solution {
    public int minOperations(String s) {
        int cnt = 0, n = s.length();
        for (int i = 0; i < n; ++i) {
            cnt += (s.charAt(i) != "01".charAt(i & 1) ? 1 : 0);
        }
        return Math.min(cnt, n - cnt);
    }
}

1
2
3
4
5
6
7
8
class Solution {
public:
    int minOperations(string s) {
        int cnt = 0, n = s.size();
        for (int i = 0; i < n; ++i) cnt += s[i] != "01"[i & 1];
        return min(cnt, n - cnt);
    }
};

1
2
3
4
5
6
7
8
9
func minOperations(s string) int {
    cnt := 0
    for i, c := range s {
        if c != []rune("01")[i&1] {
            cnt++
        }
    }
    return min(cnt, len(s)-cnt)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
function minOperations(s: string): number {
    let cnt = 0;
    const n = s.length;
    for (let i = 0; i < n; ++i) {
        if (s[i] !== '01'[i & 1]) {
            ++cnt;
        }
    }
    return Math.min(cnt, n - cnt);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
impl Solution {
    pub fn min_operations(s: String) -> i32 {
        let mut cnt: i32 = 0;
        let n: i32 = s.len() as i32;
        let bytes = s.as_bytes();

        for i in 0..n as usize {
            if bytes[i] != b"01"[i & 1] {
                cnt += 1;
            }
        }

        cnt.min(n - cnt)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
int minOperations(char* s) {
    int cnt = 0;
    int n = strlen(s);
    for (int i = 0; i < n; ++i) {
        if (s[i] != "01"[i & 1]) {
            ++cnt;
        }
    }
    return cnt < (n - cnt) ? cnt : (n - cnt);
}

Comments