力扣21-30题(数学的简单的结束和数组的前几道)

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;}
}