每日算法4_2020-06-10

最新推荐文章于 2024-06-22 21:53:36 发布

Yi-27

最新推荐文章于 2024-06-22 21:53:36 发布

阅读量131

点赞数

分类专栏：每日算法文章标签：算法 leetcode

本文链接：https://blog.csdn.net/qq_41456721/article/details/110051680

版权

每日算法专栏收录该内容

33 篇文章 0 订阅

订阅专栏

来源：题库 - 力扣 (LeetCode) (leetcode-cn.com)。侵删。

题目一

LCP 01. 猜数字

小A 和小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回小A 猜对了几次？

输入的guess数组为小A 每次的猜测，answer数组为小B 每次的选择。guess和answer的长度都等于3。

示例1：

输入：guess = [1,2,3], answer = [1,2,3]
输出：3
解释：小A 每次都猜对了。

示例2：

输入：guess = [2,2,3], answer = [3,2,1]
输出：1
解释：小A 只猜对了第二次。

限制：

guess的长度 = 3
answer的长度 = 3
guess的元素取值为 {1, 2, 3} 之一。
answer的元素取值为 {1, 2, 3} 之一。

我的解答

class Solution {
    public int game(int[] guess, int[] answer) {
        // int i = 0;
        // for(int j=0; j<guess.length; j++){
        //     if(guess[j] == answer[j]){
        //         i++;
        //     }
        // }
        // if(guess[0] == answer[0]){
        //         i++;
        // }
        // if(guess[1] == answer[1]){
        //         i++;
        // }
        // if(guess[2] == answer[2]){
        //         i++;
        // }
        // return i;
        return (guess[0]==answer[0]?1:0)+(guess[1]==answer[1]?1:0)+(guess[2]==answer[2]?1:0);
    }
}

题目二

771. 宝石与石头

给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。

J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。

示例1：

输入: J = "aA", S = "aAAbbbb"
输出: 3

示例2：

输入: J = "z", S = "ZZ"
输出: 0

注意：

S 和 J 最多含有50个字母。
J 中的字符不重复。

我的答案

class Solution {
    public int numJewelsInStones(String J, String S) {
        int n = 0;
        for(int i=0; i<S.length(); i++){
            for(int k=0; k<J.length(); k++){
                if(S.charAt(i) == J.charAt(k)){
                    n++;
                    break;
                }
            }
        }
        return n;
    }
}

其他答案

方法一：暴力法

class Solution {
    public int numJewelsInStones(String J, String S) {
        int ans = 0;
        for (char s: S.toCharArray()) // For each stone...
            for (char j: J.toCharArray()) // For each jewel...
                if (j == s) {  // If the stone is a jewel...
                    ans++;
                    break; // Stop searching whether this stone 's' is a jewel
                }
        return ans;
    }
}

复杂度分析

时间复杂度：O(J.length * S.length))。

空间复杂度：在 Python 实现中，空间复杂度为 O(1)。在 Java 实现中，空间复杂度为 O(J.length * S.length))。

方法二：哈希集合

使用哈希表，使用 2 个独立的 for 循环，第一个对 S 中的各个字母重复的数量进行统计，并放入哈希表中。第二个 for 循环，对 J 中字母进行循环，与哈希表中的 KEY 值匹配，得到结果并进行叠加。

class Solution {
    public int numJewelsInStones(String J, String S) {
        Set<Character> Jset = new HashSet();
        for (char j: J.toCharArray())
            Jset.add(j);

        int ans = 0;
        for (char s: S.toCharArray())
            if (Jset.contains(s))
                ans++;
        return ans;
    }
}

复杂度分析

时间复杂度：O(J.length + S.length))。O(J.length}) 这部分来自于创建 J，O(S.length)这部分来自于搜索 S。

空间复杂度：O(J.length)。

方法三：更高的空间性能

class Solution {
    public int numJewelsInStones(String J, String S) {
        if (S == null || S.isEmpty()) return 0;
        if (J == null || J.isEmpty()) return 0;

        byte[] arr = new byte[58]; // ASCII码中字母的跨度为65-122
        int count = 0;
        for (char ch : J.toCharArray()) {
            arr[ch - 65] = 1; // 将字符对应数组位置上的值设为1
        }
        for (char ch : S.toCharArray()) {
            if(arr[ch -65] == 1) { // 判断该字符在数组对应位置上的值是否为1
                count++;
            };
        }
        return count;
    }
}

题目三

1342. 将数字变成 0 的操作次数

给你一个非负整数 num ，请你返回将它变成 0 所需要的步数。如果当前数字是偶数，你需要把它除以 2 ；否则，减去 1 。

示例 1：

输入：num = 14
输出：6
解释：
步骤 1) 14 是偶数，除以 2 得到 7 。
步骤 2） 7 是奇数，减 1 得到 6 。
步骤 3） 6 是偶数，除以 2 得到 3 。
步骤 4） 3 是奇数，减 1 得到 2 。
步骤 5） 2 是偶数，除以 2 得到 1 。
步骤 6） 1 是奇数，减 1 得到 0 。

示例2：

输入：num = 8
输出：4
解释：
步骤 1） 8 是偶数，除以 2 得到 4 。
步骤 2） 4 是偶数，除以 2 得到 2 。
步骤 3） 2 是偶数，除以 2 得到 1 。
步骤 4） 1 是奇数，减 1 得到 0 。

示例 3：

输入：num = 123
输出：12

提示：

0 <= num <= 10^6

我的答案

class Solution {
    public int numberOfSteps (int num) {
        int n = 0;
        while(num!=0){
            n++;
            if(num%2 == 0){
                num /= 2;
            }else if(--num == 0){
                break;
            }
        }
        return n;
    }
}

其他答案

class Solution {
    public int numberOfSteps (int num) {
        int n = 0;
        while(num!=0){
            n++;
            if(num%2 == 0){
                num /= 2;
            }else if(--num == 0){
                break;
            }
        }
        return n;
    }
}

题目四

1281. 整数的各位积和之差

给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。

示例1：

输入：n = 234
输出：15 
解释：
各位数之积 = 2 * 3 * 4 = 24 
各位数之和 = 2 + 3 + 4 = 9 
结果 = 24 - 9 = 15

示例 2：

输入：n = 4421
输出：21
解释： 
各位数之积 = 4 * 4 * 2 * 1 = 32 
各位数之和 = 4 + 4 + 2 + 1 = 11 
结果 = 32 - 11 = 21

提示：

1 <= n <= 10^5

我的答案

class Solution {
    public int subtractProductAndSum(int n) {
        String s = String.valueOf(n); // 将int转换成String

        int ji = 1, he = 0;
        for(char ch : s.toCharArray()){ // 遍历字符串的字符
            ji *= (int)(ch - '0');
            he += (int)(ch - '0'); // ch - '0'再强转成整型
        }
        return ji - he;
    }
}

其他答案

没有Java的题解。很多都是取余、除这样子的。

题目五

1108. IP 地址无效化

给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。

所谓无效化 IP 地址，其实就是用 "[.]" 代替了每个 "."。

示例1：

输入：address = "1.1.1.1"
输出："1[.]1[.]1[.]1"

示例 2：

输入：address = "255.100.50.0"
输出："255[.]100[.]50[.]0"

提示：

给出的 address 是一个有效的 IPv4 地址

我的答案

class Solution {
    public String defangIPaddr(String address) {
        String[] four = address.split("\\."); // split 参数就是正则表达式，这里用\\.来转义这个.
        return String.join("[.]", four);
    }
}

其他答案

class Solution {
    public String defangIPaddr(String address) {
        return address.replace(".", "[.]"); // 替换所有字符串或字符
    }
}

这里的replace不同于正则表达式的replaceAll，所以不需要转义.

Yi-27

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
每日算法4_2020-06-10

来源：题库 - 力扣 (LeetCode) (leetcode-cn.com)。侵删。题目一LCP 01. 猜数字小A 和小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回小A 猜对了几次？输入的guess数组为小A 每次的猜测，answer数组为小B 每次的选择。guess和answer的长度都等于3。示例1：输入：guess = [1,2,3], answer = [1,2,3].
复制链接

扫一扫