力扣字符串题库

仅含1的子串数

内容

给你一个二进制字符串 s（仅由 ‘0’ 和 ‘1’ 组成的字符串）。
返回所有字符都为 1 的子字符串的数目。
由于答案可能很大，请你将它对 10^9 + 7 取模后返回。

示例

输入：s = “0110111”
输出：9
解释：共有 9 个子字符串仅由 ‘1’ 组成
“1” -> 5 次
“11” -> 3 次
“111” -> 1 次

代码

class Solution {
    public int numSub(String s) {
        final int MODULO = 1000000007; // 10^9 + 7 取模
        long total = 0;
        int length = s.length();
        long count = 0;
        for(int i = 0;i < length;i++){
            char c = s.charAt(i);
            if(c == '0'){   //遇到0时，count重计，直到遇到一组新的连续1
                total += count * (count + 1) / 2; //k*(k + 1)/2 连续1的情况
                total %= MODULO;    // 10^9 + 7 取模
                count = 0;    
            }else{
                count++;  //有几个连续1
            }
        }
        total += count * (count + 1) / 2;   //k * (k + 1) / 2   连续1的情况
        total %= MODULO;    // 10^9 + 7 取模
        return (int) total;
    }
}

复杂度

时间复杂度：O(n)，其中 nn 是字符串的长度。需要遍历字符串一次。
空间复杂度：O(1)，只需要维护有限的变量，空间复杂度是常数。

模糊坐标

内容

我们有一些二维坐标，如 “(1, 3)” 或 “(2, 0.5)”，然后我们移除所有逗号，小数点和空格，得到一个字符串S。返回所有可能的原始字符串到一个列表中。
原始的坐标表示法不会存在多余的零，所以不会出现类似于"00", “0.0”, “0.00”, “1.0”, “001”, "00.01"或一些其他更小的数来表示坐标。此外，一个小数点前至少存在一个数，所以也不会出现“.1”形式的数字。
最后返回的列表可以是任意顺序的。而且注意返回的两个数字中间（逗号之后）都有一个空格。

示例

示例 1:
输入: “(123)”
输出: ["(1, 23)", “(12, 3)”, “(1.2, 3)”, “(1, 2.3)”]

代码

class Solution { //aw
    public List<String> ambiguousCoordinates(String S) {
       List<String> ans = new ArrayList();  //将数据存放到ArrayList中
        for (int i = 2; i < S.length()-1; i++) { //从第二个元素开始
            for (String left: make(S, 1, i)){   //截取左边数的情况
                for (String right: make(S, i, S.length()-1)){   //截取右边数的情况
                    ans.add("(" + left + ", " + right + ")"); //逗号之后都有一个空格。
                }
                       }
    }
        return ans;
     
    }
    public List<String> make(String S, int i, int j) {
        // Make on S.substring(i, j)
        List<String> ans = new ArrayList();
        for (int d = 1; d <= j-i; ++d) {
            String left = S.substring(i, i+d);
            String right = S.substring(i+d, j);
            if ((!left.startsWith("0") || left.equals("0")) //0.0, 00, 0001 或 00.01 是不被允许的。
                    && !right.endsWith("0")){
                ans.add(left + (d < j-i ? "." : "") + right);   //添加小数点的情况
                    }
        }
        return ans;
}
}

复杂度

时间复杂度：O(N^3)其中 NN 是字符串 S 的长度。
空间复杂度：O(N^3)，用来存储所有合法的情况。

单词规律

内容

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。

示例

输入: pattern = “abba”, str = “dog cat cat dog”
输出: true

代码

class Solution {
    public boolean wordPattern(String pattern, String s) {
        /**
        情况：1、俩者长度不等返回false
        2、pattern与s的映射
        */
        //pattern作为key
        HashMap<Character,String> map = new HashMap<>();

        HashSet<String> set = new HashSet<>();
        //将s放入到数组中
        String[] arr = s.split(" ");
        //如果俩者长度不一样
        if(pattern.length() != arr.length){
            return false;
        }

        for(int i = 0;i < pattern.length();i++){
            //key
            char key = pattern.charAt(i);
            //如果key对应的value值存在
            if(map.containsKey(key)){
                //当前值和key对应的value是否相等
                if(!map.get(key).equals(arr[i])){
                    return false;
                }
            }else{
                //如果key对应的value值不存在
                //判断value中是否存在
                if(set.contains(arr[i])){
                    return false;
                }
                map.put(key,arr[i]);
                set.add(arr[i]);
            }
        }
        return true;
    }
}

复杂度