英雄哪里来位运算

4triumph

已于 2022-08-05 16:51:29 修改

阅读量242

点赞数

分类专栏： Leetcode 文章标签： leetcode

于 2022-08-04 19:13:39 首次发布

本文链接：https://blog.csdn.net/weixin_63914060/article/details/126165173

版权

Leetcode 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

2的幂

给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。

如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。

示例 1：

输入：n = 1
输出：true
解释：20 = 1
示例 2：

输入：n = 16
输出：true
解释：24 = 16
示例 3：

输入：n = 3
输出：false
示例 4：

输入：n = 4
输出：true
示例 5：

输入：n = 5
输出：false

提示：

-231 <= n <= 231 - 1

进阶：你能够不使用循环/递归解决此问题吗？

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/power-of-two
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
public:
    bool isPowerOfTwo(int n) {
        return (n > 0) && (n & (n - 1)) == 0;
    }
};

4的幂

给定一个整数，写一个函数来判断它是否是 4 的幂次方。如果是，返回 true ；否则，返回 false 。

整数 n 是 4 的幂次方需满足：存在整数 x 使得 n == 4x

示例 1：

输入：n = 16
输出：true
示例 2：

输入：n = 5
输出：false
示例 3：

输入：n = 1
输出：true

提示：

-231 <= n <= 231 - 1

进阶：你能不使用循环或者递归来完成本题吗？

由数学归纳法可知

class Solution {
public:
    bool isPowerOfFour(int n) {
        return (n > 0) && (n & (n - 1)) == 0 && (n % 3 == 1);
    }
};

位1的个数

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为汉明重量）。

提示：

请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的示例 3 中，输入表示有符号整数 -3。

示例 1：

输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
示例 2：

输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。
示例 3：

输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。

提示：

输入必须是长度为 32 的二进制串。

进阶：

如果多次调用这个函数，你将如何优化你的算法？

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int cnt = 0;
        while(n){
            n &= (n - 1);
            cnt ++;
        }
        return cnt;
    }
};

交换数字

编写一个函数，不用临时变量，直接交换numbers = [a, b]中a与b的值。

示例：

输入: numbers = [1,2]
输出: [2,1]
提示：

numbers.length == 2
-2147483647 <= numbers[i] <= 2147483647

class Solution {
public:
    vector<int> swapNumbers(vector<int>& numbers) {
        numbers[0] = numbers[0] ^ numbers[1];
        numbers[1] = numbers[0] ^ numbers[1];
        numbers[0] = numbers[0] ^ numbers[1];
        return numbers;
    }
};

只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1
示例 2:

输入: [4,1,2,1,2]
输出: 4

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int sum = 0;
        for(int i = 0; i < nums.size(); i ++ ){
            sum ^= nums[i];
        }
        return sum;
    }
};

汉明距离

TMD这道题题目我感觉没讲清楚汉明距离的意思，搞得我迷迷糊糊的，搜了汉明距离的定义才明白。QWQ

汉明距离是使用在数据传输差错控制编码里面的，汉明距离是一个概念，它表示两个(相同长度)字对应位不同的数量，我们以d(x,y)表示两个字x,y之间的汉明距离。对两个字符串进行异或运算，并统计结果为1的个数，那么这个数就是汉明距离。

class Solution {
public:
    int hammingDistance(int x, int y) {
        int ans = x ^ y;
        int cnt = 0;
        while(ans){
            ans -= ans&(- ans);
            cnt ++ ;
        }
        return cnt;
    }
};

交替位二进制数

给定一个正整数，检查它的二进制表示是否总是 0、1 交替出现：换句话说，就是二进制表示中相邻两位的数字永不相同。

示例 1：

输入：n = 5
输出：true
解释：5 的二进制表示是：101
示例 2：

输入：n = 7
输出：false
解释：7 的二进制表示是：111.
示例 3：

输入：n = 11
输出：false
解释：11 的二进制表示是：1011.

提示：

1 <= n <= 231 - 1

从最低位开始对相邻两位进行判断

如果这两位等于 00 或者 11 ，则返回FALSE，否则返回true

00 的十进制表示为0， 11 的十进制表示为3

class Solution {
public:
    bool hasAlternatingBits(int n) {
        while(n){
            if((n & 3) == 0 || (n & 3) == 3)
                return false;
            n >>= 1;
        }
        return true;
    }
};

找出所有子集的异或总和再求和

一个数组的异或总和定义为数组中所有元素按位 XOR 的结果；如果数组为空，则异或总和为 0 。

例如，数组 [2,5,6] 的异或总和为 2 XOR 5 XOR 6 = 1 。
给你一个数组 nums ，请你求出 nums 中每个子集的异或总和，计算并返回这些值相加之和。

注意：在本题中，元素相同的不同子集应多次计数。

数组 a 是数组 b 的一个子集的前提条件是：从 b 删除几个（也可能不删除）元素能够得到 a 。

示例 1：

输入：nums = [1,3]
输出：6
解释：[1,3] 共有 4 个子集：
- 空子集的异或总和是 0 。
- [1] 的异或总和为 1 。
- [3] 的异或总和为 3 。
- [1,3] 的异或总和为 1 XOR 3 = 2 。
0 + 1 + 3 + 2 = 6
示例 2：

输入：nums = [5,1,6]
输出：28
解释：[5,1,6] 共有 8 个子集：
- 空子集的异或总和是 0 。
- [5] 的异或总和为 5 。
- [1] 的异或总和为 1 。
- [6] 的异或总和为 6 。
- [5,1] 的异或总和为 5 XOR 1 = 4 。
- [5,6] 的异或总和为 5 XOR 6 = 3 。
- [1,6] 的异或总和为 1 XOR 6 = 7 。
- [5,1,6] 的异或总和为 5 XOR 1 XOR 6 = 2 。
0 + 5 + 1 + 6 + 4 + 3 + 7 + 2 = 28
示例 3：

输入：nums = [3,4,5,6,7,8]
输出：480
解释：每个子集的全部异或总和值之和为 480 。

提示：

1 <= nums.length <= 12
1 <= nums[i] <= 20

对于一个n个元素的整形数组，每个元素可以选择取或不取，所以总共有2^n个子集

如果二进制内有1则代表在集合中

~~好痛苦，好难理解啊这种解法，感觉快要难到紫砂了QAQ~~

class Solution {
public:
    int subsetXORSum(vector<int>& nums) {
        int sum = 0;
        for(int i = 0; i < (1 << nums.size()); i ++ ){ // 遍历所有子集
            int temp = 0;
            for(int j = 0; j < nums.size(); j ++ ){ // 遍历每一个数
                if(i & (1 << j)){
                    temp ^= nums[j];
                }
            }
            sum += temp;
        }
        return sum;
    }
};

两整数之和

给你两个整数 a 和 b ，不使用运算符 + 和 - ，计算并返回两整数之和。

示例 1：

输入：a = 1, b = 2
输出：3
示例 2：

输入：a = 2, b = 3
输出：5

提示：

-1000 <= a, b <= 1000

推理过程

~~（不行了，好想紫砂，好难）~~

/*
//错误代码
class Solution {
public:
    int getSum(int a, int b) {
        return b == 0 ? a : getSum(a ^ b, (a & b) << 1);
    }
};
*/
class Solution {
public:
    int getSum(int a, int b) {
        return b == 0 ? a : getSum(a ^ b, (unsigned)(a & b) << 1);
    }
};

题解里错误原因：

加法器，只使用异或和与操作即可完成。在这个题目里，因为服务器程序编译的时候使用了 AddressSanitizer 工具，会对有符号数的左移位操作做保护，强制转成无符号数做移位可绕过。

有几个关键的点，有符号和无符号数。

符号对加减的结果不产生任何影响。至于是解释成负数还是正数，取决于你怎么解读。比如 0xffffffff，你可以认为它是 int 类型的 -1，也可以认为它是 unsigned int 类型的 0xffffffff.
符号位会影响：类型转换时的符号拓展操作、移位操作、大小比较的结果。从汇编指令的角度看，这几种汇编指令都区分了有符号和无符号版本的指令。（大小比较借助cmp 指令，cmp 指令本身不区分符号位，但是它会影响标志寄存器。如果你要比较结果，有符号和无符号看的 flag 位是不一样的）

插入

给定两个整型数字 N 与 M，以及表示比特位置的 i 与 j（i <= j，且从 0 位开始计算）。

编写一种方法，使 M 对应的二进制数字插入 N 对应的二进制数字的第 i ~ j 位区域，不足之处用 0 补齐。具体插入过程如图所示。

题目保证从 i 位到 j 位足以容纳 M，例如： M = 10011，则 i～j 区域至少可容纳 5 位。

示例1:

输入：N = 1024(10000000000), M = 19(10011), i = 2, j = 6
输出：N = 1100(10001001100)
示例2:

输入： N = 0, M = 31(11111), i = 0, j = 4
输出：N = 31(11111)
通过次数13,889提交次数27,113

~~本来没有悟，把 & ^ | 的定义多看了两遍突然就悟了orz~~

class Solution {
public:
    int insertBits(int N, int M, int i, int j) {
        for(int k = i; k <= j; k ++ ){
            N &= ~ (long long)(1 << k);
        }
        return N | (M << i);
    }
};