Longer Contiguous Segments of Ones than Zeros

• Initialize maxOnes and maxZeros to 0.
• Use a nested loop structure to iterate through all possible start (i) and end (j) indices of substrings.
• For each substring defined by i and j, use a third loop (k) to verify if it's composed entirely of '1's or '0's.
• If a substring from i to j is all '1's, update maxOnes = Math.max(maxOnes, j - i + 1).
• If it's all '0's, update maxZeros = Math.max(maxZeros, j - i + 1).
• After all substrings have been checked, return the result of maxOnes > maxZeros.

The brute-force method systematically explores all substrings of the input string s. It uses two nested loops to define the boundaries of a substring, with the outer loop for the starting index i and the inner loop for the ending index j. For each substring s[i...j], a third loop is used to iterate through its characters to determine if it's a homogeneous segment of '1's or '0's. Two variables, maxOnes and maxZeros, are maintained to store the maximum lengths encountered. If a valid segment is found, its length is compared with the current maximum, and the maximum is updated if necessary. Finally, after examining all O(n^2) substrings, the method returns whether the longest segment of '1's is strictly longer than the longest segment of '0's.

1class Solution {2    public boolean checkOnesSegment(String s) {3        int maxOnes = 0;4        int maxZeros = 0;5        int n = s.length();6 7        for (int i = 0; i < n; i++) {8            for (int j = i; j < n; j++) {9                // Check segment from i to j10                boolean allOnes = true;11                boolean allZeros = true;12                for (int k = i; k <= j; k++) {13                    if (s.charAt(k) == '0') {14                        allOnes = false;15                    }16                    if (s.charAt(k) == '1') {17                        allZeros = false;18                    }19                }20                if (allOnes) {21                    maxOnes = Math.max(maxOnes, j - i + 1);22                }23                if (allZeros) {24                    maxZeros = Math.max(maxZeros, j - i + 1);25                }26            }27        }28        return maxOnes > maxZeros;29    }30}

• Initialize four integer variables: maxOnes = 0, maxZeros = 0, currentOnes = 0, currentZeros = 0.
• Iterate through the input string s character by character.
• If the current character is '1':
  • Increment currentOnes.
  • Reset currentZeros to 0.
• If the current character is '0':
  • Increment currentZeros.
  • Reset currentOnes to 0.
• After processing each character, update the maximums: maxOnes = Math.max(maxOnes, currentOnes) and maxZeros = Math.max(maxZeros, currentZeros).
• After the loop completes, return the boolean result of maxOnes > maxZeros.

This optimal approach involves a single linear scan of the string. We use two variables, currentOnes and currentZeros, to keep track of the length of the current contiguous segment of '1's and '0's, respectively. We also use two other variables, maxOnes and maxZeros, to store the maximum length found so far for each digit.

As we iterate through the string, if we encounter a '1', we increment currentOnes and reset currentZeros to zero, because any ongoing segment of '0's is now broken. Conversely, if we see a '0', we increment currentZeros and reset currentOnes. After each character, we update maxOnes and maxZeros to ensure they hold the largest segment lengths seen up to that point. After the single pass is complete, a simple comparison of maxOnes and maxZeros gives the answer.

1class Solution {2    public boolean checkOnesSegment(String s) {3        int maxOnes = 0;4        int maxZeros = 0;5        int currentOnes = 0;6        int currentZeros = 0;7 8        for (char c : s.toCharArray()) {9            if (c == '1') {10                currentOnes++;11                currentZeros = 0; // Reset the count for the other digit12            } else { // c == '0'13                currentZeros++;14                currentOnes = 0; // Reset the count for the other digit15            }16            maxOnes = Math.max(maxOnes, currentOnes);17            maxZeros = Math.max(maxZeros, currentZeros);18        }19 20        return maxOnes > maxZeros;21    }22}