哪种连续子字符串更长

1869. 哪种连续子字符串更长

难度简单8收藏分享切换为英文接收动态反馈

https://leetcode-cn.com/problems/longer-contiguous-segments-of-ones-than-zeros/

给你一个二进制字符串 s 。如果字符串中由 1 组成的 最长 连续子字符串 严格长于 由 0 组成的 最长 连续子字符串，返回 true ；否则，返回 false 。

• 例如，s = "110100010" 中，由 1 组成的最长连续子字符串的长度是 2 ，由 0 组成的最长连续子字符串的长度是 3 。

注意，如果字符串中不存在 0 ，此时认为由 0 组成的最长连续子字符串的长度是 0 。字符串中不存在 1 的情况也适用此规则。

 

示例 1：

输入：s = "1101"
输出：true
解释：
由 1 组成的最长连续子字符串的长度是 2："1101"
由 0 组成的最长连续子字符串的长度是 1："1101"
由 1 组成的子字符串更长，故返回 true 。

示例 2：

输入：s = "111000"
输出：false
解释：
由 1 组成的最长连续子字符串的长度是 3："111000"
由 0 组成的最长连续子字符串的长度是 3："111000"
由 1 组成的子字符串不比由 0 组成的子字符串长，故返回 false 。

示例 3：

输入：s = "110100010"
输出：false
解释：
由 1 组成的最长连续子字符串的长度是 2："110100010"
由 0 组成的最长连续子字符串的长度是 3："110100010"
由 1 组成的子字符串不比由 0 组成的子字符串长，故返回 false 。

 

提示：

• 1 <= s.length <= 100
• s[i] 不是 '0' 就是 '1'

 

package per.zhangyh.leetcode.simple;

/**
 *@author：zhangyonghui;
 *@date: 2021/6/20; 9:17
 *@Describe：
 * 1869. 哪种连续子字符串更长
 * 给你一个二进制字符串 s 。如果字符串中由 1 组成的 最长 连续子字符串 严格长于 由 0 组成的 最长 连续子字符串，返回 true ；否则，返回 false 。
 *
 * 例如，s = "110100010" 中，由 1 组成的最长连续子字符串的长度是 2 ，由 0 组成的最长连续子字符串的长度是 3 。
 * 注意，如果字符串中不存在 0 ，此时认为由 0 组成的最长连续子字符串的长度是 0 。字符串中不存在 1 的情况也适用此规则。
 *
 *
 *
 * 示例 1：
 *
 * 输入：s = "1101"
 * 输出：true
 * 解释：
 * 由 1 组成的最长连续子字符串的长度是 2："1101"
 * 由 0 组成的最长连续子字符串的长度是 1："1101"
 * 由 1 组成的子字符串更长，故返回 true 。
 * 示例 2：
 *
 * 输入：s = "111000"
 * 输出：false
 * 解释：
 * 由 1 组成的最长连续子字符串的长度是 3："111000"
 * 由 0 组成的最长连续子字符串的长度是 3："111000"
 * 由 1 组成的子字符串不比由 0 组成的子字符串长，故返回 false 。
 * 示例 3：
 *
 * 输入：s = "110100010"
 * 输出：false
 * 解释：
 * 由 1 组成的最长连续子字符串的长度是 2："110100010"
 * 由 0 组成的最长连续子字符串的长度是 3："110100010"
 * 由 1 组成的子字符串不比由 0 组成的子字符串长，故返回 false 。
 *
 *
 * 提示：
 *
 * 1 <= s.length <= 100
 * s[i] 不是 '0' 就是 '1'
 */
public class Test1869 {
    public static void main(String[] args) {
        System.out.println("输出结果 = " + checkZeroOnes("011000111"));
    }

    /**
     * 哪种连续子字符串更长    eg:s = "110100010"  s="1"  s="10"  s="011000111"
     "1101"    "111000"
     * @param s
     * @return
     */
    public static boolean checkZeroOnes(String s) {
        Boolean out = false;
        int sLength = s.length();
        int sum1 = 1;
        int sum0 = 1;
        int sum1Temp = 1;
        int sum0Temp = 1;
        if (sLength == 1 && s.equals("1")) {
            out = true;
        }
        for (int i = 1; i < sLength; i++) {
            char c = s.charAt(i - 1); //防止数组越界，使用i+1会导致数组越界；
            if (Character.toString(c).equals("1") && Character.toString(s.charAt(i)).equals("1")) {
                sum1++;
            } else if (Character.toString(c).equals("0") && Character.toString(s.charAt(i)).equals("0")) {
                sum0++;
            } else {
                if (sum1 > sum1Temp) {
                    sum1Temp = sum1;
                }
                if (sum0 > sum0Temp) {
                    sum0Temp = sum0;
                }
                sum1 = 1;
                sum0 = 1;
            }
        }
        if (sum1 > sum1Temp) {
            sum1Temp = sum1;
        }
        if (sum0 > sum0Temp) {
            sum0Temp = sum0;
        }
        if (sum1Temp > sum0Temp) {
            out = true;
        }
        return out;
    }

    /**
     * 稍微高级一点的写法，原理和上边那个基本一样，只不过使用了Math.max()方法和三目运算符；
     * @param s
     * @return
     */
    public static boolean checkZeroOnes2(String s) {
        Boolean out = false;
        int sLength = s.length();
        int sum1 = 0;
        int sum0 = 0;
        int sum1Final = 0;
        int sum0Final = 0;

        for (int i = 0; i < sLength; i++) {
            char c = s.charAt(i);
            if (Character.toString(c).equals("1")) {
                sum1++;
                sum0 = 0;
                sum1Final = Math.max(sum1, sum1Final);
            }
            if (Character.toString(c).equals("0")) {
                sum0++;
                sum1 = 0;
                sum0Final = Math.max(sum0, sum0Final);
            }
        }
        out = sum1Final > sum0Final ? true : false;
        return out;
    }
}