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

# 1869. Longer Contiguous Segments of Ones than Zeros

## Level

Easy

## Description

Given a binary string `s`

, return `true`

*if the longest contiguous segment of 1s is strictly longer than the longest contiguous segment of 0s in s. Return false otherwise*.

- For example, in
`s = "110100010"`

the longest contiguous segment of`1`

s has length`2`

, and the longest contiguous segment of`0`

s has length`3`

.

Note that if there are no `0`

s, then the longest contiguous segment of `0`

s is considered to have length `0`

. The same applies if there are no `1`

s.

**Example 1:**

**Input:** s = “1101”

**Output:** true

**Explanation:**

The longest contiguous segment of 1s has length 2: “1101”

The longest contiguous segment of 0s has length 1: “1101”

The segment of 1s is longer, so return true.

**Example 2:**

**Input:** s = “111000”

**Output:** false

**Explanation:**

The longest contiguous segment of 1s has length 3: “111000”

The longest contiguous segment of 0s has length 3: “111000”

The segment of 1s is not longer, so return false.

**Example 3:**

**Input:** s = “110100010”

**Output:** false

**Explanation:**

The longest contiguous segment of 1s has length 2: “110100010”

The longest contiguous segment of 0s has length 3: “110100010”

The segment of 1s is not longer, so return false.

**Constraints:**

`1 <= s.length <= 100`

`s[i]`

is either`'0'`

or`'1'`

.

## Solution

Loop over `s`

and calculate the lengths of the longest contiguous segment of 0’s and the longest contiguous segment of 1’s. Then compare the two lengths and return `true`

if the longest contiguous segment of 0’s is strictly greater, or `false`

otherwise.

```
class Solution {
public boolean checkZeroOnes(String s) {
int length = s.length();
int maxZeros = 0, maxOnes = 0;
int zeros = 0, ones = 0;
char prev = '2';
for (int i = 0; i < length; i++) {
char curr = s.charAt(i);
if (curr == '0') {
if (curr == prev) {
zeros++;
maxZeros = Math.max(maxZeros, zeros);
} else {
zeros = 1;
maxZeros = Math.max(maxZeros, zeros);
}
} else {
if (curr == prev) {
ones++;
maxOnes = Math.max(maxOnes, ones);
} else {
ones = 1;
maxOnes = Math.max(maxOnes, ones);
}
}
prev = curr;
}
return maxOnes > maxZeros;
}
}
```