LeetCode-Algorithms #007 Reverse Integer, Database #182 Duplicate Emails

LeetCode-Algorithms #007 Reverse Integer

给定一个32位整数, 将其各位反转并返回, 如果结果超出取值范围就返回0

 1 class Solution {
 2     public int reverse(int x) {
 3         //对原数取绝对值
 4         int y = Math.abs(x);
 5         //将原数转换为字符串
 6         String s1 = Integer.toString(y);
 7         //将字符串转换为字符数组
 8         char[] arr = s1.toCharArray();
 9         //反转数组
10         for (int i = 0; i < arr.length / 2; i++) {
11             char temp = arr[i];
12             arr[i] = arr[arr.length - 1 - i];
13             arr[arr.length - 1 - i] = temp;
14         }
15         //将反转后的字符数组拼接为字符串
16         StringBuilder sb = new StringBuilder();
17         for (char c : arr) {
18             sb.append(c);
19         }
20         String s2 = sb.toString();
21         //将新获得的字符串转换为整数
22         int res;
23         try {
24             res = Integer.parseInt(s2);
25         } catch (NumberFormatException e) {
26             return 0; //如果值超出了要求的范围,就返回0
27         }
28         //依据原数的正负值返回结果
29         return x < 0 ? res * -1 : res;
30     }
31 }

我这里的方法显然是取巧了, 先转换成字符串, 再反转字符串, 最后再转换回整数

结果还可以, 但是这种野路子方法不值得提倡, 重新考虑一下正经路数:

 1 public int reverse(int x) {
 2     //创建一个整数变量存储结果
 3     int ans = 0;
 4     //当x不等于0时循环
 5     while(x != 0) {
 6         //获取x的最末尾
 7         int i = x % 10;
 8         //去掉最末尾
 9         x /= 10;
10         //把获取到的最末位添加到结果中
11         ans = ans * 10 + i;
12     }
13     return ans;
14 }

核心是这样的, 但是光这样写没有办法避免超出取值范围时的问题, 因此再在循环中加一个选择条件

 1 class Solution {
 2     public int reverse(int x) {
 3         //创建一个整数变量存储结果
 4         int ans = 0;
 5         //当x不等于0时循环
 6         while(x != 0) {
 7             //获取x的最末尾
 8             int i = x % 10;
 9             //去掉最末尾
10             x /= 10;
11             //如果ans已经大于取值范围的十分之一, 直接使ans再增加一位会超出取值范围, 直接返回0
12             if(ans > Integer.MAX_VALUE / 10 || ans < Integer.MIN_VALUE / 10)return 0;
13             //否则就把获取到的最末位添加到结果中
14             ans = ans * 10 + i;
15         }
16         return ans;
17     }
18 }

这种写法其实和第一种速度相差不大, 但是比较接近题目本身的意思. 原本以为可能会有个别临界值会绕过选择条件, 后来琢磨了一下应该是不存在的, 当然, 为了健壮性也可以写成官方答案这样:

 1 class Solution {
 2     public int reverse(int x) {
 3         int rev = 0;
 4         while (x != 0) {
 5             int pop = x % 10;
 6             x /= 10;
 7             if (rev > Integer.MAX_VALUE/10 || (rev == Integer.MAX_VALUE / 10 && pop > 7)) return 0;
 8             if (rev < Integer.MIN_VALUE/10 || (rev == Integer.MIN_VALUE / 10 && pop < -8)) return 0;
 9             rev = rev * 10 + pop;
10         }
11         return rev;
12     }
13 }

LeetCode-Database #182 Duplicate Emails

从给出的Person表中找出重复的Email

前几道数据库的题目基本都在用自联结解决, 习惯了之后总是第一时间想着用自联结:

SELECT DISTINCT p1.Email
FROM Person p1, Person p2
WHERE p1.Email = p2.Email
AND p1.Id <> p2.Id
;

但是这样实在是太慢了, 换一个思路, 用COUNT来做, 就快很多:

SELECT Email
FROM (
SELECT Email, COUNT(Email) AS num
FROM PERSON
GROUP BY Email
) AS res
WHERE num > 1
;

再看看别人写的:

SELECT Email
FROM Person
GROUP BY Email
HAVING COUNT(Email) > 1
;

为什么我感觉自己都没见过HAVING这个关键字??

原文地址：https://www.cnblogs.com/chang4/p/9755289.html