##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1758.html

# 1758. Minimum Changes To Make Alternating Binary String

Easy

## 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

Example 3:

Input: s = “1111”

Output: 2

Explanation: You need two operations to reach “0101” or “1010”.

Constraints:

• 1 <= s.length <= 10^4
• s[i] is either '0' or '1'.

## Solution

If the first character of an alternating string is determined, the whole string can be determined. The first character of an alternating string can be either '0' or '1'. Calculate the number of operations for both cases to make s alternating, and return the minimum number of operations.

• class Solution {
public int minOperations(String s) {
int op1 = 0, op2 = 0;
int length = s.length();
for (int i = 0; i < length; i++) {
char c = s.charAt(i);
if (i % 2 == 0) {
if (c == '1')
op1++;
else
op2++;
} else {
if (c == '1')
op2++;
else
op1++;
}
}
return Math.min(op1, op2);
}
}

############

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);
}
}

• 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)

############

# 1758. Minimum Changes To Make Alternating Binary String
# https://leetcode.com/problems/minimum-changes-to-make-alternating-binary-string

class Solution:
def minOperations(self, s: str) -> int:

n = len(s)

first, second = ["1"], ["0"]

for _ in range(n-1):
first.append(second[-1])
second.append(first[-2])

def diff(word):
return sum(a != b for a,b in zip(word, s))

return min(diff(first), diff(second))


• 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);
}
};

• 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)
}

func min(a, b int) int {
if a < b {
return a
}
return b
}

• function minOperations(s: string): number {
const n = s.length;
let count = 0;
for (let i = 0; i < n; i++) {
count += s[i] !== '01'[i & 1] ? 1 : 0;
}
return Math.min(count, n - count);
}


• impl Solution {
pub fn min_operations(s: String) -> i32 {
let n = s.len();
let s = s.as_bytes();
let cs = [b'0', b'1'];
let mut count = 0;
for i in 0..n {
count += if s[i] != cs[i & 1] { 1 } else { 0 };
}
count.min(n - count) as i32
}
}