每日一练＜4＞

每日一练

大家好呀！我是小笙，接下来分享下11-12月份每日一题的解题思路~

1822. 数组元素积的符号

给定一个数组，将数组中的每个值乘积起来如果等于 0 则返回 0；如果大于 0 则返回 1；如果小于 0 则返回 -1

例子

输入：nums = [41,65,14,80,20,10,55,58,24,56,28,86,96,10,3,84,4,41,13,32,42,43,83,78,82,70,15,-41]、
输出：-1
注意：会超出 int 类型的范围
1
2
3

暴力破解，但是注意不能直接累积的方式判断，因为会超出 int 数据范围

class Solution {
    public int arraySign(int[] nums) {
        int res = 0;
        for(int num:nums){
            if(num == 0){
                return 0;
            }else if(num < 0){
                res++;
            }
        }
        return res%2 == 1?-1:1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

---

1662. 检查两个字符串数组是否相等

给你两个字符串数组 word1 和 word2 。如果两个数组表示的字符串相同，返回 true ；否则，返回 false

例子

输入：word1 = ["ab", "c"], word2 = ["a", "bc"]
输出：true
解释：
word1 表示的字符串为 "ab" + "c" -> "abc"
word2 表示的字符串为 "a" + "bc" -> "abc"
两个字符串相同，返回 true
-------------------------------------------
输入：word1 = ["a", "cb"], word2 = ["ab", "c"]
输出：false
1
2
3
4
5
6
7
8
9

代码实现

暴力解法：首先记录下一组字符串的字符和，然后去和另外一个数组进行比较；但是需要注意的是两者字符串总长度大小的两种情况

class Solution {
    public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
        StringBuilder sb = new StringBuilder("");
        for(String word:word1){
            sb.append(word);
        }
        int index = 0;
        String str = sb.toString();
        for(String word:word2){
            for(int i=0;i<word.length();i++){
                // 防止第一个字符串长度小于第二个字符串的长度
                if(index >= str.length()){
                    return false;
                }
                if(str.charAt(index++) != word.charAt(i)){
                    return false;
                }
            }
        }
        // 防止第一个字符串长度大于第二个字符串的长度
        if(index != str.length()){
            return false;
        }
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

优化：通过下标的方式直接累积两者字符串，然后直接比较就可以啦

class Solution {
    public boolean arrayStringsAreEqual(String[] word1, String[] word2) {
        StringBuilder sb = new StringBuilder("");
        StringBuilder sb2 = new StringBuilder("");
        int index1 = 0,index2 = 0;
        while(index1 < word1.length || index2 < word2.length){
            if(index1 < word1.length){
                sb.append(word1[index1++]);
            }
            if(index2 < word2.length){
                sb2.append(word2[index2++]);
            }
        }
        return sb.toString().equals(sb2.toString());
    }
}

// 执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户
// 内存消耗：39.2 MB, 在所有 Java 提交中击败了76.54%的用户
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

---

1668.最大重复子字符串

给你一个字符串 sequence ，如果字符串 word 连续重复 k 次形成的字符串是 sequence 的一个子字符串，那么单词 word 的 重复值为 k 。单词 word 的 最大重复值是单词 word 在 sequence 中最大的重复值。如果 word 不是 sequence 的子串，那么重复值 k 为 0

例子

输入：sequence = "aaabaaaabaaabaaaabaaaabaaaabaaaaba", word = "aaaba"
输出：5
解释：注意是连续重复最大值
1
2
3

解题思路：使用 String 包含的方法来查找连续重复最大值

class Solution {
    public int maxRepeating(String sequence, String word) {
        int res = 0;
        StringBuilder sb = new StringBuilder(word);
        while(sequence.contains(sb.toString())){
            res++;
            sb.append(word);
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11

---

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

示例 ：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1]
1
2
3

代码实现

解题思路：就是边放便查询，为啥不会漏放呢，我们查询的都是成对出现的，也就是说我们把第一个就直接放进去，那查第二个数字 （target - 第一个数字） 一定会返回

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map = new HashMap<>();
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(target - nums[i])){
                return new int[]{map.get(target - nums[i]),i};
            }
            map.put(nums[i],i);
        }
        return new int[]{-1,-1};
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

---

1796.字符串中第二大的数字

给你一个混合字符串（由小写英文字母和数字组成） s ，请你返回 s 中 第二大 的数字，如果不存在第二大的数字，请你返回 -1

示例：

输入：s = "dfa12321afd"
输出：2
解释：出现在 s 中的数字包括 [1, 2, 3] 。第二大的数字是 2
1
2
3

代码实现：

解题思路：统计字符串有哪些数字，并收集不重复的数字；如果最后长度小于2 返回-1，反之排序返回第二大的数字

class Solution {
    public int secondHighest(String s) {
        Set<Integer> set = new HashSet<>();
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<s.length();i++){
            char ch = s.charAt(i);
            if(ch >= 48 && ch <= 58 && !set.contains(ch-48)){
                list.add(ch-48);
                set.add(ch-48);
            }
        }
        if(list.size() < 2){
            return -1;
        }
        Collections.sort(list);
        return list.get(list.size()-2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18