7. 整数反转
给出一个 32 位的有符号整数,你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123
输出: 321
示例 2:
输入: -123
输出: -321
示例 3:
输入: 120
输出: 21
注意:
假设我们的环境只能存储得下 32 位的有符号整数,则其数值范围为 [−231, 231 − 1]。请根据这个假设,如果反转后整数溢出那么就返回 0。
我的解答
public static int reverse(int x) {
//判断是否溢出
if(x<Integer.MAX_VALUE&&x>Integer.MIN_VALUE) {
//转化为字符串,进行进一步操作
String str = x+"";
String newStr ="";
//判断是否为负数
if(x<0) {
str = str.substring(1, str.length());
newStr = dofun(str);
newStr = "-"+newStr;
}else {
newStr = dofun(str);
}
//转换回整形
//判断反转后是否超出范围
double test = Double.parseDouble(newStr);
if(test>Integer.MAX_VALUE||test<Integer.MIN_VALUE) {
return 0;
}
int result = Integer.parseInt(newStr);
return result;
}
return 0;
}
public static String dofun(String str) {
String newStr = "";
//置换
for(int i=str.length();i>0;i--) {
newStr += str.charAt(i-1);
}
//判断最高位是否为0
while(newStr.charAt(0)==0) {
//是,无视该位
newStr = newStr.substring(1, str.length());
}
return newStr;
}
更优解答
public int reverse(int x) {
int rev = 0;
while (x != 0) {
int pop = x % 10;
x /= 10;
if (rev > Integer.MAX_VALUE/10 || (rev == Integer.MAX_VALUE / 10 && pop > 7)) return 0;
if (rev < Integer.MIN_VALUE/10 || (rev == Integer.MIN_VALUE / 10 && pop < -8)) return 0;
rev = rev * 10 + pop;
}
return rev;
}
196. 删除重复的电子邮箱
编写一个 SQL 查询,来删除 Person 表中所有重复的电子邮箱,重复的邮箱里只保留 Id 最小 的那个。
编写一个 SQL 查询,来删除 Person 表中所有重复的电子邮箱,重复的邮箱里只保留 Id 最小 的那个。
| Id | Email
| 1 | john@example.com
| 2 | bob@example.com
| 3 | john@example.com
Id 是这个表的主键。
例如,在运行你的查询语句之后,上面的 Person 表应返回以下几行:
| Id | Email
| 1 | john@example.com
| 2 | bob@example.com
我的解答
DELETE p2 FROM Person p1, Person p2 WHERE p1.Email=p2.Email AND p1.id<p2.id
349. 两个数组的交集
给定两个数组,编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]
示例 2:
输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4]
说明:
输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。
我的解答
class Solution {
public static int[] intersection(int[] nums1, int[] nums2) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < nums1.length; i++) {
for (int j = 0; j < nums2.length; j++) {
if (nums1[i] == nums2[j]) {
list.add(nums1[i]);
}
}
}
//根据需求决定去重
list = removeRepeat(list);
int[] result = new int[list.size()];
for (int k = 0; k < list.size(); k++) {
result[k] = list.get(k);
}
return result;
}
//去重
public static List<Integer> removeRepeat(List<Integer> list) {
List<Integer> listNew=new ArrayList<>();
for (Integer str:list) {
if(!listNew.contains(str)){
listNew.add(str);
}
}
return listNew;
}
}
更优解答
class Solution {
public int[] intersection(int[] nums1, int[] nums2) {
Set<Integer> set1 = new HashSet<>();
Set<Integer> set2 = new HashSet<>();
for (int num : nums1) {
set1.add(num);
}
for (int num : nums2) {
if (set1.contains(num)) {
set2.add(num);
}
}
int[] ret = new int[set2.size()];
int i = 0;
for (int num : set2) {
ret[i++] = num;
}
return ret;
}
}
14. 最长公共前缀
编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀,返回空字符串 “”。
示例 1:
输入: [“flower”,“flow”,“flight”]
输出: “fl”
示例 2:
输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。
说明:
所有输入只包含小写字母 a-z 。
我的解答
public static String longestCommonPrefix(String[] strs) {
if (strs == null || strs.length == 0) return "";
//由于最后采用substring方法,所以这里先指定一个字符串用于表示结果
String result = strs[0];
for (int i = 0; i < strs.length; i++) {
int j = 0;
for (j = 0; j < result.length(); j++) {
if (result.charAt(j) != strs[i].charAt(j))
break;
}
result = result.substring(0, j);
}
return result;
}
更优解答
class Solution {
public String longestCommonPrefix(String[] strs){ if(strs == null || strs.length==0) return "";
String prifex = strs[0]; // 默认将第一个认为是最长共同
for(int i=1;i<strs.length;i++){ // 将当前最长共同字符串和当前数组中的对比,把小的那个作为长度
int len = prifex.length()>strs[i].length() ? strs[i].length():prifex.length();
int j=0;
for(j=0;j<len;j++){ // 逐个字符比较,不等的时候退出
if(prifex.charAt(j)!=strs[i].charAt(j))
break;
} // 退出的j即当前的最小,整个遍历结束后就是整个的最小了
prifex = prifex.substring(0,j);
}
return prifex;
}
}
26. 删除排序数组中的重复项
给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度。
不要使用额外的数组空间,你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。
我的解答
public int removeDuplicates(int[] nums) {
if (nums.length == 0) return 0;
int i = 0;
for (int j = 1; j < nums.length; j++) {
if (nums[j] != nums[i]) {
i++;
nums[i] = nums[j];
}
}
return i + 1;
}
更优解答 (速度更快)
class Solution {
public int removeDuplicates(int[] nums) {
if(nums == null || nums.length == 0){
return 0;
}
//1、标记重复数据
final int mark = nums[0];
int index = 1 , _index =1,num =0;
while(index<nums.length){
_index = index;
while(++_index<nums.length && nums[_index]!= mark && nums[index] == nums[_index]){
nums[_index] = mark;
}
index ++;
}
index = _index = 1;
while (_index <nums.length && index <nums.length) {
while (_index<nums.length && nums[_index]==mark) {
num++;
_index++;
}
if(_index<nums.length){
nums[index]=nums[_index];
_index++;
}
index++;
}
return nums.length-num;
}
}
20. 有效的括号
给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效。
有效字符串需满足:
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1:
输入: “()”
输出: true
示例 2:
输入: “()[]{}”
输出: true
示例 3:
输入: “(]”
输出: false
示例 4:
输入: “([)]”
输出: false
示例 5:
输入: “{[]}”
输出: true
我的代码
public static boolean isValid2(String s) {
//排除项数是奇数的情况
if(s.length()%2!=0)
return false;
int count = 0;
int length = s.length();
while(count<length/2){
s = s.replace("{}","").replace("[]","").replace("()","");
System.out.println(s);
count++;
}
if(s.length()>0){
return false;
}
else{
return true;
}
}
更优解答
class Solution {
public boolean isValid(String s) {
Stack<Character> stack = new Stack<Character>();
for (char c : s.toCharArray()) {
if (c == '(')
stack.push(')');
else if (c == '[')
stack.push(']');
else if (c == '{')
stack.push('}');
else if (stack.isEmpty() || stack.pop() != c)
return false;
}
return stack.isEmpty();
}
}
495. 提莫攻击
在《英雄联盟》的世界中,有一个叫 “提莫” 的英雄,他的攻击可以让敌方英雄艾希(编者注:寒冰射手)进入中毒状态。现在,给出提莫对艾希的攻击时间序列和提莫攻击的中毒持续时间,你需要输出艾希的中毒状态总时长。
你可以认为提莫在给定的时间点进行攻击,并立即使艾希处于中毒状态。
示例1:
输入: [1,4], 2
输出: 4
原因: 在第 1 秒开始时,提莫开始对艾希进行攻击并使其立即中毒。中毒状态会维持 2 秒钟,直到第 2 秒钟结束。
在第 4 秒开始时,提莫再次攻击艾希,使得艾希获得另外 2 秒的中毒时间。
所以最终输出 4 秒。
示例2:
输入: [1,2], 2
输出: 3
原因: 在第 1 秒开始时,提莫开始对艾希进行攻击并使其立即中毒。中毒状态会维持 2 秒钟,直到第 2 秒钟结束。
但是在第 2 秒开始时,提莫再次攻击了已经处于中毒状态的艾希。
由于中毒状态不可叠加,提莫在第 2 秒开始时的这次攻击会在第 3 秒钟结束。
所以最终输出 3。
我的解答
class Solution {
public static int findPoisonedDuration(int[] timeSeries, int duration) {
if(timeSeries.length==0) return 0;
//中毒时间
int poisoning = 0;
for(int i=0;i<timeSeries.length-1;i++) {
//gap表示时间点小于duration的情况
int gap = timeSeries[i+1]-timeSeries[i];
if(gap>=duration) {
poisoning += duration;
}else {
poisoning += gap;
}
}
//提莫最后一次攻击后的中毒时间
poisoning += duration;
return poisoning;
}
}
更优解答
class Solution {
public int findPoisonedDuration(int[] timeSeries, int duration) {
if (timeSeries.length == 0) {
return 0;
}
int res = 0;
int startTime = timeSeries[0];
for (int i = 1; i < timeSeries.length; ++i) {
int preEndTime = timeSeries[i - 1] + duration;
if (timeSeries[i] >= preEndTime) {
res += preEndTime - startTime;
startTime = timeSeries[i];
}
}
res += timeSeries[timeSeries.length - 1] + duration - startTime;
return res;
}
}