位运算 on Coder_Studio

BISHI65 【模板】分数取模

Sat, 21 Feb 2026 00:37:41 +0000

思路

求解代码

private static final int MOD = 1000000007;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(br.readLine().trim());

        for (int i = 0; i < t; i++) {
            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long b = Long.parseLong(str[1]);

            long bInv= mypower(b, MOD-2, MOD);
            long ans = (a%MOD+MOD)%MOD;
            ans = (ans*bInv)%MOD;

            out.println(ans);
        }

        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

BISHI64 【模板】快速幂Ⅰ ‖ 模小整数

Fri, 20 Feb 2026 22:22:19 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int T = Integer.parseInt(br.readLine().trim());

        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            long a = Long.parseLong(str[0]);
            long b = Long.parseLong(str[1]);
            long m = Long.parseLong(str[2]);

            out.println(mypower(a, b, m));
        }

        out.flush();
        out.close();
        br.close();
    }

    private static long mypower(long base, long exp, long mod) {

        long ans = 1 % mod;
        while (exp > 0) {

            if (exp % 2 == 1) {
                ans = (ans * base) % mod;
            }

            base = (base * base) % mod;
            exp /= 2;
        }

        return ans;
    }

BISHI33 Poi 的新加法（Easy Version）

Tue, 10 Feb 2026 21:20:54 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 拼接所有输入行：解决“数字可换行/空格分隔”的ACM输入特性
        StringBuilder sb = new StringBuilder();
        String line;
        // 逐行读取所有输入，直到输入结束（br.readLine()返回null）
        while ((line = br.readLine()) != null) {
            // trim()去掉行首行尾空格，append(" ")保证数字间用空格分隔
            sb.append(line.trim()).append(" ");
        }
        // 拼接后的字符串按“任意空格”拆分成一个个数字字符串
        StringTokenizer in = new StringTokenizer(sb.toString());
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(in.nextToken());

        for (int i = 0; i < t; i++) {
            long m = Long.parseLong(in.nextToken());
            long query = Long.parseLong(in.nextToken());

            long res = 0;

            for (int j = 0; j < m; j++) {
                // 读取第 j 个数值 val
                long val = Long.parseLong(in.nextToken());

                // 非第一个数，res 只保留和当前 val 二进制位 “都为 1” 的部分，其他位全部变成 0
                res = j > 0 ? ~(res ^ val) & res : val;

                // 非第一个数且 res>0 时，左移1位（等价于×2）
                if (res > 0 && j > 0) {
                    res <<= 1;
                }
            }
            int left = Integer.parseInt(in.nextToken());
            int right = Integer.parseInt(in.nextToken());
            out.println(res);
            res = 0;
        }

        out.flush();
        out.close();
        br.close();
    }

小贴士

反码：原码除符号位外全部取反
负数的补码 = 反码 + 1
~(res^val)&res的本质是筛选出 res 和 val 二进制中 “都为 1” 的位

BISHI30 二进制数1

Mon, 09 Feb 2026 22:09:39 +0000

求解代码

public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        String str = br.readLine();
        long n =Long.parseLong(str.trim());

        int count = 0;
        while (n > 0) {
            count += n & 1;
            n = n >> 1;
        }
        out.println(count);

        out.flush();
        out.close();
        br.close();
    }

小贴士

StreamTokenizer 的 in.nval 是 double 类型（64 位浮点数），但 double 的有效整数精度只有 53 位，将其强转为 long（64 位整数）会造成精度丢失，所以这里需要用BufferedReader.readLine()读取字符串再转 long。

LCR003-比特位计数

Thu, 29 Jan 2026 22:31:28 +0000

求解代码

public int[] countBits(int n) {
        int[] bits = new int[n+1];

        for(int i=0;i<=n;i++){
            bits[i]=oneBits(i);
        }
        return bits;
    }

    private int oneBits(int n){
        int count = 0;
        while(n>0){
            n&=(n-1);
            count++;
        }
        return count;
    }

小贴士

核心就是用 n & (n-1) 消去最右侧 1的技巧统计 1 的个数。

LCR001-两数相除

Thu, 29 Jan 2026 21:30:34 +0000

求解代码

    //定义移位边界，防止左移溢出
    private static final int BOUND = Integer.MIN_VALUE>>1;

    //被除数是最小负数，除数是-1，返回最大正数
    public int divide(int a,int b){
        if(a==Integer.MIN_VALUE&&b==-1){
            return Integer.MAX_VALUE;
        }

        if(a==0||b==1){
            return a;
        }else if(b == -1){
            return -a;
        }

        int negative = 2;
        // 统一转为负数计算，避免MIN_VALUE取反溢出
        if(a>0){
            negative--;
            a=-a;
        }

        //仅处理a、b均为负数的情况，返回正的商
        if(b>0){
            negative--;
            b=-b;
        }

        int ans = helpDivide(a,b);
        return negative == 1 ? -ans : ans;
    }

    private int helpDivide(int a,int b){
        // 被除数绝对值 == 除数绝对值，商为1
       if(a==b){
        return 1;
       } 
       int res = 0;
       int shift = getMaxShift(a,b);
       while(a<=b){
        while (a>(b<<shift)) {
            shift--;
        }
        a-=(b<<shift);// 减去 b×2^shift
        res+=(1<<shift);// 商累加 2^shift
       }
       return res;
    }

    // 获取除数b的最大有效移位次数
    private int getMaxShift(int a,int b){
        int shift = 0;
        int tmp = b;

        while(tmp>a && tmp>=BOUND){
            tmp<<=1;
            shift++;
        }
        return shift;
    }

小贴士

必须以除数为起点左移（倍增），而非被除数。

Integer.MIN_VALUE = -2^31 取反会溢出。

两个负数相比较时，a更小表示绝对值更大。

哈希-数组中只出现一次的两个数字

Sat, 17 Jan 2026 11:13:21 +0000

求解代码

public int[] FindNumsAppearOnce (int[] nums) {
        HashMap<Integer,Integer> map = new HashMap<>();

        int[] ans = new int[2];
        
        for(int i=0;i<nums.length;i++){
            map.put(nums[i],map.getOrDefault(nums[i],0)+1);
        }
        int j=0;
        for(int num:map.keySet()){
            if(map.get(num)==1){
                ans[j++]=num;
            }

            if(j==2){
                break;
            }
        }

        if(ans[0]>ans[1]){
            int t = ans[0];
            ans[0]=ans[1];
            ans[1]=t;
        }
        return ans;
    }

小贴士

for(int num : map.keySet())，我们很容易想到的是再一次遍历nums，但是这里可以利用HashMap的keySet，只遍历不重复的数字。

位运算实现整数加减乘除运算

Mon, 13 Oct 2025 20:40:59 +0000

本文借这道题，分析如何用位运算实现一套完整的整数运算体系。

1. 加法运算

public static int add(int a, int b) {
    int ans = a;
    while (b != 0) {
        ans = a ^ b;        // 无进位相加
        b = (a & b) << 1;   // 计算进位
        a = ans;
    }
    return ans;
}

2. 取反运算

1
2
3

public static int neg(int n) {
    return add(~n, 1);
}

经典的补码取反公式:一个数的相反数等于按位取反加1。

3. 减法运算

1
2
3

public static int minus(int a, int b) {
    return add(a, neg(b));
}

4.乘法运算

public static int multiply(int a, int b) {
    int ans = 0;
    while (b != 0) {
        if ((b & 1) != 0) {
            ans = add(ans, a);
        }
        a <<= 1;
        b >>>= 1;
    }
    return ans;
}

思路

将乘法转化为加法和移位操作,本质是将b的二进制展开:

1
2

a × b = a × (b₀×2⁰ + b₁×2¹ + b₂×2² + ...)
      = a×b₀ + (a<<1)×b₁ + (a<<2)×b₂ + ...

每次检查b的最低位,如果为1则累加当前的a,然后a左移(相当于×2),b右移(处理下一位)。

5.除法运算

public static int divide(int a, int b) {
    if (a == MIN && b == MIN) {
        return 1;  // 最小值除以最小值 = 1
    }
    if (a != MIN && b != MIN) {
        return div(a, b);  // 都不是最小值,正常处理
    }
    if (b == MIN) {
        return 0;  // 任何非最小值除以最小值 = 0
    }
    if (b == neg(1)) {
        return Integer.MAX_VALUE;  // 题目要求溢出返回最大值
    }
    
    // a是最小值,b不是最小值也不是-1
    a = add(a, b > 0 ? b : neg(b));
    int ans = div(a, b);
    int offset = b > 0 ? neg(1) : 1;
    return add(ans, offset);
}

思路

当a是最小值时:

先将a向0的方向移动|b|个单位:a = a + |b|
对调整后的a进行除法:ans = div(a, b)
补偿之前的调整:
- 如果b > 0:商应该减1(因为我们让被除数变大了)
- 如果b < 0:商应该加1(因为负数除法的特性)

函数:div

public static int div(int a, int b) {
    int x = a < 0 ? neg(a) : a;  // 转为正数
    int y = b < 0 ? neg(b) : b;
    int ans = 0;
    
    for (int i = 30; i >= 0; i = minus(i, 1)) {
        if ((x >> i) >= y) {
            ans |= (1 << i);
            x = minus(x, y << i);
        }
    }
    
    return a < 0 ^ b < 0 ? neg(ans) : ans;
}

思路

类似于二分查找,从高位到低位试探商的每一位:

将x和y都转为正数
从第30位开始(第31位是符号位)向下遍历
检查x >> i是否大于等于y:
- 如果是,说明商的第i位是1,同时从x中减去y << i
最后根据符号决定结果的正负

Leetcode2166-设计位集

Sun, 12 Oct 2025 22:26:58 +0000

在处理大规模布尔数组时,我们经常面临空间和时间效率的双重挑战。

如果用普通的 boolean 数组,每个元素至少占用 1 字节,当数据量达到百万级别时,内存开销会非常可观。

而位集合(Bitset)通过将每个布尔值压缩为一个比特位,可以将空间占用降低到原来的 1/32。

以下是一个支持延迟翻转优化的高效 Bitset 实现。

代码

	class Bitset{

		private int[] set;//整形数组，用于存储位信息
		private final int size;//位集合的逻辑大小（用户视角的位数）
		private int zeros;//统计当前值为0的位的数量
		private int ones;//统计当前值为1的位的数量
		private boolean reverse;//反转标志

		//构造函数
		public Bitset(int n){
			set = new int[(n+31)/32];
			size = n;
			zeros = n;
			ones = 0;
			reverse = false;
		}

		public void fix(int i){
			int index = i/32;
			int bit = i%32;
			if(!reverse){
				//正常模式reverse=false，将0改为1
				if((set[index]&(1<<bit))==0){
					zeros--;
					ones++;
					set[index]|=(1<<bit);
				}
			}else{
				//反转模式reverse=true，将1改为0
				if((set[index]&(1<<bit))!=0){
					zeros--;
					ones++;
					set[index]^=(1<<bit);
				}
			}
		}

		public void unfix(int i){
			int index = i/32;
			int bit = i%32;
			if(!reverse){
				//正常模式reverse=false，将1改为0
				if((set[index]&(1<<bit))!=0){
					ones--;
					zeros++;
					set[index]^=(1<<bit);
				}
			}else{
				//反转模式reverse=true，将0改为1
				if((set[index]&(1<<bit))==0){
					ones--;
					zeros++;
					set[index]|=(1<<bit);
				}
			}
		}

		//翻转所有位（0变1，1变0）
		public void flip(){
			reverse = !reverse;
			int tmp = zeros;
			zeros=ones;
			ones = tmp;
		}

		//检查是否全为1
		public boolean all(){
			return ones == size;
		}

		//检查是否至少有一个1
		public boolean one(){
			return ones>0;
		}

		//返回1的数量
		public int count(){
			return ones;
		}

		//将位集合转换为字符串表示
		public String toString(){
			StringBuilder builder = new StringBuilder();
			for(int i=0,k=0,number,status;i<size;k++){
				number = set[k];
				for(int j=0;j<32&&i<size;j++,i++){
					status = (number>>j)&1;
					status ^= reverse?1:0;
					builder.append(status);
				}
			}
			return builder.toString();
		}

	}

用-按位统计-找唯一出现少于-3-次的数

Sat, 11 Oct 2025 22:38:35 +0000

这道题如果用哈希表统计次数，空间复杂度是 O (n)；

如果用异或，只能处理 “出现偶数次抵消” 的情况（比如出现 2 次），面对 3 次、5 次这类奇数次数就失效了。

首先，这里用到了一个核心规律：

对于任意一个二进制位（比如第 0 位、第 1 位），如果某个数出现了 m 次，那么这个数在该位上的 1 的总贡献，一定是 m 的倍数。

代码逻辑

1. 按位统计 1 的个数

int[] cnts = new int[32]; 
for (int num : arr) {
    for (int i = 0; i < 32; i++) {
        cnts[i] += (num >> i) & 1; 
    }
}

2. 重构目标数

int ans = 0;
for (int i = 0; i < 32; i++) {
    if (cnts[i] % m != 0) {
        ans |= (1 << i); 
    }
}

完整代码

// LeetCode 137（其他数出现3次，目标数出现1次）
public static int singleNumber(int[] nums) {
    return find(nums, 3); // 直接调用通用解法，m=3
}

// 通用解法：数组中只有1种数出现次数<m，其他数都出现m次，返回该数
public static int find(int[] arr, int m) {
    // cnts[i]：统计数组中所有数在第i位（0~31）上1的总个数
    int[] cnts = new int[32]; 
    
    // 遍历数组，统计每一位上1的总个数
    for (int num : arr) {
        for (int i = 0; i < 32; i++) {
            // 提取num第i位的1，累加到cnts[i]
            cnts[i] += (num >> i) & 1; 
        }
    }
    
    // 根据cnts重构目标数
    int ans = 0;
    for (int i = 0; i < 32; i++) {
        // 如果第i位1的总个数不是m的倍数，说明目标数第i位是1
        if (cnts[i] % m != 0) {
            // 把第i位设为1
            ans |= (1 << i); 
        }
    }
    
    return ans;
}

用异或找-两个只出现一次的数

Sat, 11 Oct 2025 08:39:06 +0000

如果是只有一个元素只出现一次，那么可以用异或抵消出现两次的元素，从而找出那个只出现一次的元素。

现在是恰好有两个元素只出现一次，那这道题的难点就在于：

如何把 “这两个只出现一次的元素” 拆分开，再分别用异或抵消出现两次的元素的方式，从而找出这两个只出现一次的元素。

1.计算所有数的异或结果

根据异或运算的性质，出现偶数次的数会互相抵消，最后剩下的就是两个奇数次的数的异或结果。

int eor1 = 0;
for (int num : nums) {
    eor1 ^= num;
}

2.用 Brian Kernighan 算法提取最右侧的 1

`1`	`int rightOne = eor1 & (-eor1);`

3.分组异或得到其中一个目标数

因为rightOne是a ^ b最右侧的 1，这意味着 a 和 b 在rightOne对应的位上，一个是 0，一个是 1，可以此作为依据进行分组。

int eor2 = 0;
for (int num : nums) {
    if ((num & rightOne) == 0) {
        eor2 ^= num;
    }
}

4.得到另一个目标数

`1`	`return new int[] { eor2, eor1 ^ eor2 };`

完整代码

public static int[] singleNumber(int[] nums) {
    // 计算所有数的异或结果，得到 a ^ b
    int eor1 = 0;
    for (int num : nums) {
        eor1 ^= num; // 偶数次的数抵消，最后剩下 a^b
    }

    // 提取 eor1 二进制中最右侧的1
    int rightOne = eor1 & (-eor1);

    // 按 rightOne 分组，异或得到其中一个目标数 a
    int eor2 = 0;
    for (int num : nums) {
        // 判断 num 在 rightOne 对应的位上是否为0
        if ((num & rightOne) == 0) {
            eor2 ^= num; // 该组中偶数次的数抵消，剩下 a
        }
    }

    // 得到另一个目标数 b = a ^ (a^b) = eor2 ^ eor1
    return new int[] { eor2, eor1 ^ eor2 };
}

寻找丢失的数字

Fri, 10 Oct 2025 07:35:15 +0000

这道题大多数人的第一反应是 “求和法”（用 0~n 的和减去数组总和），或者 “哈希表法”（存出现过的数再遍历查找）。

但今天本文要讲的异或解法，不仅时间复杂度和求和法一样是 $O (n)$，空间复杂度更是最优的 $O (1)$。

数组 nums 包含 [0, n] 中的 n 个数，理论上应该有n+1个数，实际上只有n个数，说明正好缺了一个。

也就是说：

完整的数字集合是：0, 1, 2, …, n（共 n+1 个数）；

数组中的数字集合是：完整集合去掉一个数（共 n 个数）。

想想看，如果我们把 “完整集合的所有数” 和 “数组中的所有数” 都做一次异或，会发生什么？

根据异或的性质：

完整集合和数组中都出现的数会互相抵消，最后剩下的，就是 “完整集合有、数组没有” 的那个数 —— 也就是我们要找的缺失数字。

代码实现

public static int missingNumber(int[] nums) {
    // eorAll：存储 0~n 所有数的异或结果
    // eorHas：存储数组 nums 所有数的异或结果
    int eorAll = 0, eorHas = 0;

    for (int i = 0; i < nums.length; i++) {
        eorAll ^= i;       // eorAll 异或 0~nums.length-1
        eorHas ^= nums[i]; // eorHas 异或数组中的每个数
    }

    // 补全 eorAll，异或上 nums.length（因为完整集合是 0~n，循环漏了 n）
    eorAll ^= nums.length;

    // eorAll ^ eorHas = 缺失数字
    return eorAll ^ eorHas;
}

不使用比较运算符-如何获取两个整数的最大值

Thu, 09 Oct 2025 20:18:41 +0000

这道题如果用 a-b 的符号判断，在两数处于比较极端的情况下可能会发生整数溢出。

比如当 a 是Integer.MIN_VALUE（-2147483648）、b 是Integer.MAX_VALUE（2147483647）时，a-b 会溢出成正数，导致错误地认为 a 比 b 大。

本文接下来介绍一种新颖的解法。

代码逻辑

1.flip：翻转0和1

// 必须保证n是0或1，返回翻转后的值
public static int flip(int n) {
    return n ^ 1; // 异或1：0^1=1，1^1=0
}

2.sign：判断数字符号

int 是 32 位，最高位（第 31 位）是 “符号位”——0 表示非负（正数或 0），1 表示负数。经过flip 翻转后非负数从 0→1，负数从 1→0。

// 非负数返回1，负数返回0
public static int sign(int n) {
    return flip(n >>> 31); // 无符号右移31位后翻转
}

3.核心方法getMax

当 a 和 b 符号不同时，直接根据符号判断；当符号相同时，再用 a-b 的符号判断。


public static int getMax(int a, int b) {
    int c = a - b; 
    
    // 计算a、b、c的符号
    int sa = sign(a); // a非负→1，负→0
    int sb = sign(b); // b非负→1，负→0
    int sc = sign(c); // c非负→1，负→0（c可能溢出）
    
    // 判断a和b的符号是否不同：diffAB=1（不同），diffAB=0（相同）
    int diffAB = sa ^ sb; // 不同为1，相同为0
    // 判断a和b的符号是否相同：相同为1，不同为0
    int sameAB = flip(diffAB);
    
    // 确定returnA（选a的权重：1选a，0选b）
    // 符号不同时（diffAB=1）：选非负的那个（sa=1→a非负，选a）
    // 符号相同时（sameAB=1）：选c非负的那个（sc=1→a>=b，选a）
    int returnA = diffAB * sa + sameAB * sc;
    int returnB = flip(returnA); // 选b的权重
    
    // 返回最大值
    return a * returnA + b * returnB;
}

完整代码

链接：https://pan.quark.cn/s/7efcb9d22a2f 提取码：jdgT

基数排序分析

Wed, 08 Oct 2025 16:52:18 +0000

在排序算法里，我们总习惯说 “快排是平均效率最高的”，但在某些场景下 —— 比如给手机号排序、给 10 万条 “0-9999” 的数字排序 ——基数排序的速度会远超快排。

原因很简单：基数排序是 “非比较排序”，不需要通过元素间的比较来确定顺序，而是靠 “按位分组” 实现排序，时间复杂度能稳定在 O (n*k)（k 是数字的位数）。

基数排序的核心其实就是把数字按每一位（个位、十位、百位…）拆开来排序。

代码逻辑

1.找最小值（处理负数）

考虑到如果数组有负数，按位提取会出问题，所以需要先把所有数转成非负。

int min = arr[0];
for (int i = 1; i < n; i++) {
    min = Math.min(min, arr[i]);
}

2.平移数组 + 找最大值

平移后数组使得所有元素均≥0；

记录最大值max，是为了通过bits(max)计算 “需要排序几轮”。

int max = 0;
for (int i = 0; i < n; i++) {
    arr[i] -= min; 
    max = Math.max(max, arr[i]);
}

3.bits（计算位数）

public static int bits(int number) {
    int ans = 0;
    while (number > 0) {
        ans++;
        number /= BASE;
    }
    return ans;
}

4.radixSort（按位排序）

public static void radixSort(int[] arr, int n, int bits) {
		// offset：当前处理的位数（比如：1=个位，10=十位，100=百位...）
		for (int offset = 1; bits > 0; offset *= BASE, bits--) {
			// 初始化计数数组（每次处理新的位，都要清空）
			Arrays.fill(cnts, 0);
			// 统计当前位（offset对应的位）上，0~BASE-1的出现次数
			for (int i = 0; i < n; i++) {
				// 提取arr[i]在当前位的数字
				int digit = (arr[i] / offset) % BASE;
				cnts[digit]++; 
			}

			// 将计数数组转为“前缀和数组”（确定元素在help中的位置）
			for (int i = 1; i < BASE; i++) {
				cnts[i] += cnts[i - 1];
			}

			// 逆序遍历原数组，填充辅助数组help
			for (int i = n - 1; i >= 0; i--) {
				// 再次提取当前位数字
				int digit = (arr[i] / offset) % BASE;
				// 前缀和-1：得到当前元素在help中的索引
				help[--cnts[digit]] = arr[i];
			}

			// 将辅助数组的结果复制回原数组（完成当前位的排序）
			for (int i = 0; i < n; i++) {
				arr[i] = help[i];
			}
		}
	}

完整代码 链接：https://pan.quark.cn/s/3071ab17556e