1. 逆序输出
如：abcd1234，逆序输出：4321dcba
出处：
https://edu.csdn.net/practice/23719458
代码：
class ReverseString { public static void main(String[] args) { String input = "abcd1234"; char[] try1 = input.toCharArray(); for (int i = try1.length - 1; i >= 0; i--) System.out.print(try1[i]); System.out.println(); } }
输出：
4321dcba
2. 删除有序数组中的重复项
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝 int len = removeDuplicates(nums); // 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。 for (int i = 0; i < len; i++) { print(nums[i]); }
示例 1：
输入：nums = [1,1,2]
输出：2, nums = [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]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
提示：
0 <= nums.length <= 3 * 10^4
-10^4 <= nums[i] <= 10^4
nums 已按升序排列
出处：
https://edu.csdn.net/practice/23719459
代码：
public class removeDuplicates { public static class Solution { public int removeDuplicates(int[] nums) { if (nums == null || nums.length == 0) { return 0; } int a = 0; for (int b = 1; b < nums.length; b++) { if (nums[a] != nums[b]) { a++; nums[a] = nums[b]; } } return a + 1; } } public static void main(String[] args) { Solution s = new Solution(); int[] nums = {1,1,2}; System.out.println(s.removeDuplicates(nums)); int[] nums1 = {0,0,1,1,1,2,2,3,3,4}; System.out.println(s.removeDuplicates(nums1)); } }
Java每日一练(20230325)
Hann Yang 
于 2023-03-25 06:45:00 发布 
258 
分类专栏： # Java每日一练 刷题专栏 文章标签： java
70 篇文章 40 订阅
568 篇文章 36 订阅
目录
1. 逆序输出 🌟
3. 直线上最多的点数 🌟🌟🌟
1. 逆序输出
如：abcd1234，逆序输出：4321dcba
出处：
https://edu.csdn.net/practice/23719458
代码：
1. class ReverseString { 2. public static void main(String[] args) { 3. String input = "abcd1234"; 4. char[] try1 = input.toCharArray(); 5. for (int i = try1.length - 1; i >= 0; i--) 6. System.out.print(try1[i]); 7. System.out.println(); 8. } 9. }
输出：
4321dcba
2. 删除有序数组中的重复项
给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。 for (int i = 0; i < len; i++) { print(nums[i]); }
示例 1：
输入：nums = [1,1,2]
输出：2, nums = [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]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
提示：
0 <= nums.length <= 3 * 10^4-10^4 <= nums[i] <= 10^4nums已按升序排列
出处：
https://edu.csdn.net/practice/23719459
代码：
1. public class removeDuplicates { 2. public static class Solution { 3. public int removeDuplicates(int[] nums) { 4. if (nums == null || nums.length == 0) { 5. return 0; 6. } 7. int a = 0; 8. for (int b = 1; b < nums.length; b++) { 9. if (nums[a] != nums[b]) { 10. a++; 11. nums[a] = nums[b]; 12. } 13. } 14. return a + 1; 15. } 16. } 17. public static void main(String[] args) { 18. Solution s = new Solution(); 19. int[] nums = {1,1,2}; 20. System.out.println(s.removeDuplicates(nums)); 21. 22. int[] nums1 = {0,0,1,1,1,2,2,3,3,4}; 23. System.out.println(s.removeDuplicates(nums1)); 24. } 25. }
输出：
2
5
3. 直线上最多的点数
给你一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点。求最多有多少个点在同一条直线上。
示例 1：
输入：points = [[1,1],[2,2],[3,3]]
输出：3
示例 2：
输入：points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出：4
提示：
1 <= points.length <= 300
points[i].length == 2
-10^4 <= xi, yi <= 10^4
points 中的所有点 互不相同
出处：
https://edu.csdn.net/practice/23719460
代码：
import java.util.HashMap; import java.util.Map; public class maxPoints { public static class Solution { public int maxPoints(int[][] points) { int n = points.length; if (n == 0) return 0; if (n == 1) return 1; int res = 0; for (int i = 0; i < n - 1; i++) { Map<String, Integer> slope = new HashMap<>(); int repeat = 0; int tmp_max = 0; for (int j = i + 1; j < n; j++) { int dy = points[i][1] - points[j][1]; int dx = points[i][0] - points[j][0]; if (dy == 0 && dx == 0) { repeat++; continue; } int g = gcd(dy, dx); if (g != 0) { dy /= g; dx /= g; } String tmp = String.valueOf(dy) + "/" + String.valueOf(dx); slope.put(tmp, slope.getOrDefault(tmp, 0) + 1); tmp_max = Math.max(tmp_max, slope.get(tmp)); } res = Math.max(res, repeat + tmp_max + 1); } return res; } private int gcd(int dy, int dx) { if (dx == 0) return dy; else return gcd(dx, dy % dx); } } public static void main(String[] args) { Solution s = new Solution(); int[][] points = {{1,1},{2,2},{3,3}}; System.out.println(s.maxPoints(points)); int[][] points1 = {{1,1},{3,2},{5,3},{4,1},{2,3},{1,4}}; System.out.println(s.maxPoints(points1)); } }
输出：
3
4
最大公约数 gcd(a, b)
辗转相除法
递归：
private int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
迭代：
private int gcd(int a, int b) { while(b != 0) { int temp = b; b = a % b; a = temp; } return a; }
