20240719 力扣
（侵权立马删）
一：数学
12469 温度转换
class Solution {
public double[] convertTemperature(double celsius) {
double Kelvin= celsius+273.15;
double Fahrenheit=celsius*1.80+32.00;
double ans []= {Kelvin,Fahrenheit};
return ans;
}
}
2235 两整数相加
class Solution {
public int sum(int num1, int num2) {
int sum1=num1+num2;
return sum1;
}
}
2413 最小偶倍数
我的暴力解法（有点蠢）
class Solution {
public int smallestEvenMultiple(int n) {
int result=0;
for(int i=1;i<99999;i++){
if(i%2==0&&i%n==0){
result=i;
break;
}
}
return result;
}
}
题解：先判断奇偶数，偶数为本身，奇直接*
class Solution {
public int smallestEvenMultiple(int n) {
return n % 2 == 0 ? n : 2 * n;
}
}
2160 差分四位相加最小
class Solution {
public int minimumSum(int num) {//2932
int [] nums=new int[4];
for(int i=0;i<nums.length;i++){
nums [i]=num%10;
num = num/10;
}
Arrays.sort(nums);//从小到大排序，2239
int result=nums[0]*10+nums[3] +nums[1]*10+nums[2];
return result;
}
}
2520 统计能整除数字的位数
class Solution {
public int countDigits(int num) {
int count = 0;
int originalNum = num; // 保存原始的 num 以便于使用
while (num > 0) {
int digit = num % 10; // 获取当前的最后一位数字
if (digit != 0 && originalNum % digit == 0) { // 避免除以零
count++;
}
num = num / 10; // 移除最后一位数字
}
return count;
}
}
其他大佬：
class Solution {
public int countDigits(int num) {
int t = num;
int res = 0;
while (t != 0) {
if (num % (t % 10) == 0) {
res++;
}
t /= 10;
}
return res;
}
}
1688. 比赛中的配对次数
class Solution {
public int numberOfMatches(int n) {
int a=0;
while(n>1){
if(n%2==0){
a=a+n/2;
n=n/2;
} else{
a=a+(n-1)/2;
n=(n-1)/2+1;
}
}
return a;
}
}
大佬的：
class Solution {
public int numberOfMatches(int n) {
int ans = 0;
while (n > 1) {
if (n % 2 == 0) {
ans += n / 2;
n /= 2;
} else {
ans += (n - 1) / 2;
n = (n - 1) / 2 + 1;
}
}
return ans;
}
}
1281 整数的各位积和之差
两个特牛的思路：
class Solution {
public int subtractProductAndSum(int n) {
int m = 1, s = 0;
while (n != 0) {
int x = n % 10;
n /= 10;
m *= x;
s += x;
}
return m - s;
}
}
字符串：
class Solution {
public int subtractProductAndSum(int n) {
String s = String.valueOf(n);
int ans = 1;
int res = 0;
for(int i = 0; i < s.length(); i++){
ans *= s.charAt(i) - '0';
res += s.charAt(i) - '0';
}
return ans - res;
}
}
2427 公因子的数目
大佬：
class Solution {
public int commonFactors(int a, int b) {
int ans = 0;
for (int x = 1; x <= Math.min(a, b); ++x) {
if (a % x == 0 && b % x == 0) {
++ans;
}
}
return ans;
}
}
使用gcd，这个使用了迭代的方式
class Solution {
public int commonFactors(int a, int b) {
int c = gcd(a, b), ans = 0;
for (int x = 1; x * x <= c; ++x) {
if (c % x == 0) {
++ans;
if (x * x != c) {
++ans;
}
}
}
return ans;
}
public int gcd(int a, int b) {
while (b != 0) {
a %= b;
a ^= b;
b ^= a;
a ^= b;
}
return a;
}
}
单独拿出来说：
public int gcd(int a, int b) {
while (b != 0) {
a %= b;
a ^= b;
b ^= a;
a ^= b;
}
return a;
}
假设我们要计算 gcd(48, 18)：
初始值：a = 48, b = 18
计算余数：a % b = 48 % 18 = 12，所以 a = 12
交换：a 变成 18, b 变成 12
再次计算余数：18 % 12 = 6，所以 a = 6
交换：a 变成 12, b 变成 6
再次计算余数：12 % 6 = 0，所以 a = 0
b 变成 0，a 是最大公约数，即 6
728 自除数
class Solution {
public List<Integer> selfDividingNumbers(int left, int right) {
List<Integer> ans = new ArrayList<Integer>();
for (int i = left; i <= right; i++) {
if (isSelfDividing(i)) {
ans.add(i);
}
}
return ans;
}
public boolean isSelfDividing(int num) {
int temp = num;
while (temp > 0) {
int digit = temp % 10;
if (digit == 0 || num % digit != 0) {
return false;
}
temp /= 10;
}
return true;
}
}
2119 啊？？？反转两次的数字
class Solution {
public:
bool isSameAfterReversals(int num) {
return num == 0 || num % 10 != 0;
}
};
二、总结：
虽然是简单的题目，有些能做出来，有些对我的难度还是有点高，不停的学习！！太依赖自动生成了，很多简单的都不会敲（ System.out.println();）
1. 数组
静态初始化（在定义数组时初始化元素）：
int[] myArray = {1, 2, 3, 4, 5};
String[] myStrArray = {"hello", "world", "java"};
动态初始化（在定义数组时不初始化元素）：
int[] myArray = new int[5]; // 创建一个整型数组，长度为5
String[] myStrArray = new String[3]; // 创建一个字符串数组，长度为3
动态初始化并立刻赋值（在创建数组和阅读数据之后初始化元素）：
int[] myArray = new int[]{1, 2, 3, 4, 5};
String[] myStrArray = new String[]{"hello", "world", "java"};
1.1 Arrays.sort(nums);
整理数组中的所有的数，升序：
```bash
class Solution {
public int minimumSum(int num) {//2932
int [] nums=new int[4];
for(int i=0;i<nums.length;i++){
nums [i]=num%10;
num = num/10;
}
Arrays.sort(nums);//从小到大排序，2239
int result=nums[0]*10+nums[3] +nums[1]*10+nums[2];
return result;
}
}
其他应用场景
int[] nums = {4, 2, 7, 1};
Arrays.sort(nums); // 结果: [1, 2, 4, 7]
浮点数组：按升序排列。
double[] nums = {4.5, 2.3, 7.8, 1.2};
Arrays.sort(nums); // 结果: [1.2, 2.3, 4.5, 7.8]
字符串数组：按字典顺序排列。
String[] names = {"John", "Alice", "Bob"};
Arrays.sort(names); // 结果: [Alice, Bob, John]
2. for循环
for(int i = 0; i < ans.length; i++) {//注意是;
// 循环体
}
3. while 循环如果不知
while 是一个在编程中常用的循环控制结构，用于在满足指定条件时重复执行一段代码。它的基本语法如下：
while 条件:
# 执行的代码块
在 while 循环中，代码块会不断执行，直到条件不再满足为止。如果条件一开始就是 False，代码块将不会执行一次。
示例
基础示例
count = 0
while count < 5:
print(count)
count += 1
这个示例中，while 循环会打印出 0 到 4 的数字。每次循环后，count 的值会增加 1，直到 count 达到 5，条件 count < 5 不再满足，循环结束。
无限循环
while True:
print("这会无限打印")
# 注意：这里需要有一种方式来打破循环，否则会导致程序陷入无限循环
在这个示例中，由于条件总是 True，所以这将是一个无限循环。通常，这样的循环需要在循环体内部使用 break 语句来退出。
带 else 的 while 循环
count = 0
while count < 5:
print(count)
count += 1
else:
print("循环结束")
这个示例中，else 块会在 while 循环正常结束后执行（即当条件不再满足时）。如果循环是因为 break 被提前中断的，else 块将不会执行。
注意事项
确保循环条件最终会变为 False，否则可能会导致无限循环。
可以在循环体内使用 break 来提前退出循环，使用 continue 来跳过当前迭代并继续下一次循环。
4. for和while的使用场景：
while 和 for 都是用于循环的控制结构，但它们在不同情况下有各自的优势和适用场景。下面是它们的区别及使用建议：
while 循环
适用场景：
条件驱动的循环：当你不确定循环会执行多少次时，while 循环很有用。它依赖于一个条件表达式来控制循环的继续与否。
动态终止条件：条件可能会在每次迭代中变化，或者你需要在满足某种条件时退出循环。
示例：
例如，读取用户输入，直到用户输入“退出”
user_input = ""
while user_input != "退出":
user_input = input("请输入（退出以结束）：")
print(f"你输入了: {user_input}")
for 循环
适用场景：
固定次数的循环：当你知道循环次数时，for 循环非常方便。它通常用于遍历序列（如列表、元组、字符串）或生成的序列。
遍历集合：for 循环适用于遍历集合中的每一个元素，比如列表或字典。
示例：
遍历一个列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
print(fruit)
使用 range 生成固定次数的循环
for i in range(5):
print(i)
总结对比
循环次数已知时：使用 for 循环（例如，遍历列表或使用 range）。
循环次数未知或基于某个条件时：使用 while 循环（例如，读取用户输入直到满足某个条件）。
在实际编程中，选择 while 还是 for 循环主要取决于你的具体需求和问题背景。有时两者都是可行的，但某些情况可能更适合其中一个。
5. 数学运算符号
在编程中，这些操作符用于数学运算、逻辑运算以及对变量进行增减等。这些操作符适用于整数、浮点数（如 double、float）和某些编程语言中的其他数据类型。它们通常用于基本数学计算、循环控制和数据结构管理等方面。
以下是这些操作符的一般含义和用法：
- a++ 和 ++a
这两个操作符都是为了使 a 的值增加 1，但它们的区别在于它们的副作用。
a++：后置递增操作符。这意味着在表达式中的计算完成之后，a 的值才会被增加。a++ 总是返回表达式中 a 操作前的值。
int a = 5;
int b = a++; // 执行后 a = 6, b = 5
++a：前置递增操作符。这意味着 a 的值在表达式中被计算之前会被增加。++a 总是返回 a 操作后的新值。
int a = 5;
int b = ++a; // 执行后 a = 6, b = 6
- a-- 和 --a
这两个操作符是为了使 a 的值减少 1，它们与 a++ 和 ++a 类似，只是效果相反。
a–：后置递减操作符，类似 a++。a-- 在表达式计算完成后减少 a 的值。
int a = 5;
int b = a--; // 执行后 a = 4, b = 5
–a：前置递减操作符，类似 ++a。–a 在表达式被计算之前减少 a 的值。
int a = 5;
int b = --a; // 执行后 a = 4, b = 4
- a +=
这是一个复合赋值操作符，它将两个值相加，并将结果赋给第一个值。它等价于 a = a + b。
int a = 5;
int b = 3;
a += b; // 等价于 a = a + b, 最终 a = 8, b = 3
- a /=
这是一个除法复合赋值操作符，它将第一个值除以第二个值，并赋给第一个值。它等价于 a = a / b。
int a = 10;
int b = 2;
a /= b; // 等价于 a = a / b, 最终 a = 5, b = 2
a*=也是一样的
这些操作符通常在赋值运算符和数学运算符中使用，用于将数字变量值增加、减少一定的值，或者用于将一个操作的结果赋给另一个变量。在实际编程中，它们可以减少代码量，并使表达式更加简洁。不同的编程语言可能有不同的语法规则和行为。
这个就是实际运用：
class Solution {
public int subtractProductAndSum(int n) {
int m = 1, s = 0;
while (n != 0) {
int x = n % 10;
n /= 10;
m *= x;
s += x;
}
return m - s;
}
}
6. 条件运算符
条件 ? 值1 : 值2
条件：这是一个布尔表达式，结果是 true 或 false。
值1：如果条件为 true，则整个表达式的值是 值1。
值2：如果条件为 false，则整个表达式的值是 值2。
示例
int n1 = 4;
int result1 = n1 % 2 == 0 ? n1 : 2 * n1;
// n1 是偶数，所以 result1 的值是 4
int n2 = 5;
int result2 = n2 % 2 == 0 ? n2 : 2 * n2;
// n2 是奇数，所以 result2 的值是 10