力扣21-30题(数学的简单的结束和数组的前几道)
20240721
1.题和解析
693. 交替位二进制数
简单
给定一个正整数，检查它的二进制表示是否总是 0、1 交替出现：换句话说，就是二进制表示中相邻两位的数字永不相同。
class Solution {
public boolean hasAlternatingBits(int n) {
int prev = 2;
while (n != 0) {
int cur = n % 2;
if (cur == prev) {
return false;
}
prev = cur;
n /= 2;
}
return true;
}
}
使用位运算：
class Solution {
public boolean hasAlternatingBits(int n) {
int a = n ^ (n >> 1);
return (a & (a + 1)) == 0;
}
}
分析：
假设 n 的二进制表示为 101010：
n >> 1 的结果是 010101。
n ^ (n >> 1) 的结果是 111111。
a = 111111，a + 1 = 1000000。
a & (a + 1) = 111111 & 1000000 = 0，符合条件。
因此，(a & (a + 1)) == 0 为 true，说明 n 的位是交替的。
1010
0101
----
1111
405. 数字转换为十六进制数
都是位运算
官解：
class Solution {
public String toHex(int num) {
if (num == 0) {
return "0";
}
StringBuffer sb = new StringBuffer();
for (int i = 7; i >= 0; i --) {
int val = (num >> (4 * i)) & 0xf;
if (sb.length() > 0 || val > 0) {
char digit = val < 10 ? (char) ('0' + val) : (char) ('a' + val - 10);
sb.append(digit);
}
}
return sb.toString();
}
}
其他的：
class Solution {
public String toHex(int num) {
// 负数 a 取反加上 a 的绝对值后，答案的二进制为32位1，在 long 中代表 (long)Math.pow(2, 32) - 1
// 因此 负数 a 取反后加一的二进制和 (long)Math.pow(2, 32) 一样，16进制固然也一样
if (num == 0) {
return "0";
}
long a = num >= 0 ? num : (long)Math.pow(2, 32) + num;
StringBuilder sb = new StringBuilder();
while (a != 0) {
int mod = (int)(a % 16);
if (mod > 9) {
sb.append((char)('a' + mod - 10));
} else {
sb.append(mod);
}
a = a / 16;
}
return sb.reverse().toString();
}
}
171 excel 表序列号
class Solution {
public int titleToNumber(String columnTitle) {
int n = columnTitle.length(); // 获取列标题的长度
int ans = 0; // 初始化结果变量
for(int i = 0; i < n; i++) { // 遍历列标题中的每个字符
ans = ans * 26 + (columnTitle.charAt(i) - 'A' + 1); // 将当前字符转换为数字并累加到结果中,.charAt(i)拿到第i个字符，通过ASCII码也行
}
return ans; // 返回最终的列号
}
}
ASCII：
// 获取索引为 1 的字符
char ch = str.charAt(1);
// 获取该字符的 ASCII 码
int asciiCode = (int) ch;
从这之后的是数组了
2011. 执行操作后的变量值
存在一种仅支持 4 种操作和 1 个变量 X 的编程语言：
++X 和 X++ 使变量 X 的值 加 1
–X 和 X-- 使变量 X 的值 减 1
最初，X 的值是 0
给你一个字符串数组 operations ，这是由操作组成的一个列表，返回执行所有操作后， X 的 最终值 。
终于和官解一样了！！
class Solution {
public int finalValueAfterOperations(String[] operations) {
int sum=0;
for(String op:operations){
if(op.equals("X++")||op.equals("++X")){
sum++;
}else{
sum--;
}
}
return sum;
}
}
1929. 数组串联
给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标 从 0 开始计数 ，对于所有 0 <= i < n 的 i ，满足下述所有要求：
ans[i] == nums[i]
ans[i + n] == nums[i]
具体而言，ans 由两个 nums 数组 串联 形成。
返回数组 ans 。
官解：
class Solution {
public int[] getConcatenation(int[] nums) {
int length = nums.length;
int[] ans = new int[length << 1];
for (int i = 0; i < length; i++) {
ans[i + length]= ans[i] = nums[i];
}
return ans;
}
}
1720. 解码异或后的数组
未知 整数数组 arr 由 n 个非负整数组成。
经编码后变为长度为 n - 1 的另一个整数数组 encoded ，其中 encoded[i] = arr[i] XOR arr[i + 1] 。例如，arr = [1,0,2,1] 经编码后得到 encoded = [1,2,3] 。
给你编码后的数组 encoded 和原数组 arr 的第一个元素 first（arr[0]）。
请解码返回原数组 arr 。可以证明答案存在并且是唯一的。
class Solution {
public int[] decode(int[] encoded, int first) {
int n = encoded.length + 1;//首先先拿到原数组的长度
int[] arr = new int[n];//定义一个原数组长度的数组
arr[0] = first;//把第一个元素放进去
for (int i = 1; i < n; i++) {
arr[i] = arr[i - 1] ^ encoded[i - 1];//这个就是带公式
}
return arr;
}
}
异或解析：
OR（异或）是一种二进制逻辑运算，其符号通常为 ^。XOR 运算的规则是：如果两个相应的二进制位相同，则结果为 0，如果不同，则结果为 1。
下面是如何进行 XOR 运算的步骤：
按位运算：XOR 是按位进行的运算，这意味着你需要将两个数字转换为二进制形式，并对每一位分别进行 XOR 运算。
运算规则：
0 XOR 0 = 0
0 XOR 1 = 1
1 XOR 0 = 1
1 XOR 1 = 0
结果组合：将每一位的 XOR 运算结果组合起来，形成最终的二进制结果，然后可以将其转换回十进制。
示例
假设我们要计算 5 XOR 3：
转换为二进制：
5 的二进制是 101
3 的二进制是 011
按位进行 XOR 运算：
第一位（从右向左数）：1 XOR 1 = 0
第二位：0 XOR 1 = 1
第三位：1 XOR 0 = 1
组合结果：
得到的二进制结果是 110
转换回十进制：
110 在二进制中对应的十进制数是 6
所以，5 XOR 3 的结果是 6。
在编程中，你可以使用编程语言提供的 XOR 运算符（通常是 ^）来直接进行 XOR 运算，而不需要手动转换和执行每一位的运算。例如，在 Python 中，你可以这样计算：
result = 5 ^ 3
print(result) # 输出将是 6
2574. 左右元素和的差值
给你一个下标从 0 开始的整数数组 nums ，请你找出一个下标从 0 开始的整数数组 answer ，其中：
answer.length == nums.length
answer[i] = |leftSum[i] - rightSum[i]|
其中：
leftSum[i] 是数组 nums 中下标 i 左侧元素之和。如果不存在对应的元素，leftSum[i] = 0 。
rightSum[i] 是数组 nums 中下标 i 右侧元素之和。如果不存在对应的元素，rightSum[i] = 0 。
返回数组 answer 。
class Solution {
public int[] leftRigthDifference(int[] nums) {
int n = nums.length;
int[] ans = new int[n];
ans[0] = nums[0];
for (int i = 1; i < n; ++i) {
ans[i] = ans[i - 1] + nums[i];
}
for (int i = n - 1, rs = 0; i >= 0; rs += nums[i--]) {
int ls = i == 0 ? 0 : ans[i - 1];
ans[i] = Math.abs(ls - rs);
}
return ans;
}
}
题解：（理解题目就很简单了）
示例
假设 nums = [1, 2, 3, 4]：
计算 leftSum:
leftSum[0] = 0（没有左侧元素）
leftSum[1] = 1（只有 1 左侧元素）
leftSum[2] = 3（1 + 2 左侧元素）
leftSum[3] = 6（1 + 2 + 3 左侧元素）
计算 rightSum:
rightSum[0] = 9（2 + 3 + 4 右侧元素）
rightSum[1] = 7（3 + 4 右侧元素）
rightSum[2] = 4（4 右侧元素）
rightSum[3] = 0（没有右侧元素）
计算 answer:
answer[0] = |0 - 9| = 9
answer[1] = |1 - 7| = 6
answer[2] = |3 - 4| = 1
answer[3] = |6 - 0| = 6
最终，answer 数组是 [9, 6, 1, 6]。
101. 对称二叉树
给你一个二叉树的根节点 root ， 检查它是否轴对称。
示例 1：
输入：root = [1,2,2,3,4,4,3]
输出：true
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public boolean isSymmetric(TreeNode root) {
return check(root, root);
}
public boolean check(TreeNode p, TreeNode q) {
if (p == null && q == null) {
return true;
}
if (p == null || q == null) {
return false;
}
return p.val == q.val && check(p.left, q.right) && check(p.right, q.left);
}
}
LCP 06. 拿硬币
桌上有 n 堆力扣币，每堆的数量保存在数组 coins 中。我们每次可以选择任意一堆，拿走其中的一枚或者两枚，求拿完所有力扣币的最少次数。
示例 1：
输入：[4,2,1]
输出：4
解释：第一堆力扣币最少需要拿 2 次，第二堆最少需要拿 1 次，第三堆最少需要拿 1 次，总共 4 次即可拿完。
class Solution {
public int minCount(int[] coins) {
int sum = 0;
for (int i : coins) {
sum += (i + 1) / 2;
}
return sum;
}
}
1365. 有多少小于当前数字的数字
简单
相关标签
相关企业
提示
给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。
换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。
以数组形式返回答案。
示例 1：
输入：nums = [8,1,2,2,3]
输出：[4,0,1,1,3]
解释：
对于 nums[0]=8 存在四个比它小的数字：（1，2，2 和 3）。
对于 nums[1]=1 不存在比它小的数字。
对于 nums[2]=2 存在一个比它小的数字：（1）。
对于 nums[3]=2 存在一个比它小的数字：（1）。
对于 nums[4]=3 存在三个比它小的数字：（1，2 和 2）。
class Solution {
public int[] smallerNumbersThanCurrent(int[] nums) {
int n = nums.length;
int[] ret = new int[n];
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (nums[j] < nums[i]) {
cnt++;
}
}
ret[i] = cnt;
}
return ret;
}
}
原文地址：https://blog.csdn.net/f552126506/article/details/140592975
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！