力扣题数学按照学习顺序前十道题的总结的答案,包括数组的基础,for、while玄幻、数学运算符号(a++)、条件运算符。主要的是大佬们的思路。
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
原文地址:https://blog.csdn.net/f552126506/article/details/140557064
免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!