Skip to content

Latest commit

 

History

History
183 lines (158 loc) · 4.88 KB

0049.整数的不同位数.md

File metadata and controls

183 lines (158 loc) · 4.88 KB

整数的不同位数

题目链接

C++

#include <iostream>
using namespace std;

int hammingDistance(int m, int n) {
    int xorResult = m ^ n; // 异或操作会生成一个新的整数，其二进制表示中的每一位表示m和n对应位是否相同
    int count = 0; // 初始化计数器
    while (xorResult != 0) {
        count += xorResult & 1; // 检查最低位是否为1，然后递增计数器
        xorResult >>= 1; // 右移异或结果
    }
    return count;
}

int main() {
    int m, n;
    cin >> m >> n;
    int result = hammingDistance(m, n);
    cout << result << endl;
    return 0;
}

Java

/**
 * 思路：使用异或运算
 * 异或运算的性质，如果两个对应位置上的二进制数字不同，则结果为 1，如果相同，则为 0
 * 
 * 算法步骤：
 * 对给定的两个整数 m 和 n 进行异或运算，得到结果 xorResult。
 * 
 * 初始化一个计数器 count 为 0，用于统计 xorResult 中1的个数。
 * 
 * 循环遍历 xorResult 的每一位：
 *     检查 xorResult 最低位是否为1，如果是则递增 count。
 *     右移 xorResult 一位，以继续检查下一位。
 * 
 * 返回 count，即为二进制中不同位数的个数。
 * 
*/
import java.util.Scanner;

public class Main {
    public static int hammingDistance(int m, int n) {
        int xorResult = m ^ n; // 异或操作会生成一个新的整数，其二进制表示中的每一位表示m和n对应位是否相同
        int count = 0; // 初始化计数器
        while (xorResult != 0) {
            count += xorResult & 1; // 检查最低位是否为1，然后递增计数器
            xorResult >>= 1; // 右移异或结果
        }
        return count;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();
        int n = scanner.nextInt();
        int result = hammingDistance(m, n);
        System.out.println(result);
    }
}

Python

def count_bits_diff(a: int, b: int) -> int:
    """
    异或操作是一种常用的位操作符，它的特点是相同的位取反，不同的位保持不变。
    例如，如果我们将两个二进制数101（对应十进制数5）和110（对应十进制数6）进行异或操作，结果将是011（对应十进制数3）。
    这是因为在这两个二进制数中，第一个位都是1，所以结果的第一个位是0; 第二个位一个是0，另一个是1，所以结果的第二个位是1; 
    第三个位都是1，所以结果的第三个位是0。因此，异或操作的结果就是将这两个二进制数中不同的位保留下来。

    在这个问题中，我们需要找出两个数字之间的不同位，而异或操作正好能满足我们的要求。
    当我们对两个数字执行异或操作时，结果就是它们所有不同的位组成的二进制数。
    因此，我们只需要将结果转换为十进制数，就可以得到不同位的数量。

    Python快捷解法：使用了bin函数将结果转换为二进制字符串，然后通过count方法统计字符串中'1'的出现次数，从而得到不同位的数量。
    """
    return bin(a ^ b).count('1')


a, b = map(int, input().split())
res = count_bits_diff(a, b)
print(res)

Go

//方式一，转换成栈的字符串，然后一一匹配
package main

import (
	"fmt"
	"strconv"
)

func transform(x int) string {
	var temp string
	for x > 0 {
		temp = temp+strconv.Itoa(x%2) 
		x /= 2
	}
	return temp
}

func main() {
	var n, m int
	fmt.Scan(&n, &m)
	res := 0 // 思路，用栈转化求出二进制字符串，然后一一比对即可
	str1 := transform(n)
	str2 := transform(m)
	for i := 0; i < 32; i++ {
		if i < len(str1) && i < len(str2) {
			if str1[i] != str2[i] {
				res++
			}
		} else if i >= len(str1) && i < len(str2) {
			if str2[i] == '1' {
				res++
			}
		} else if i >= len(str2) && i < len(str1) {
			if str1[i] == '1' {
				res++
			}
		} else {
			break
		}
	}
	fmt.Println(res)
}
//方式2，直接位运算
package main

import "fmt"

func main() {
    var n, m int
    fmt.Scan(&n, &m)
    res := 0
    for i := 0; i < 32; i++ {
        x1 := (n >> uint(i)) & 1
        x2 := (m >> uint(i)) & 1
        if x1 != x2 {
            res++
        }
    }
    fmt.Println(res)
}

Js

C

#include <stdio.h>

int hammingDistance(int m, int n) {
    int xorResult = m ^ n; // 异或操作会生成一个新的整数，其二进制表示中的每一位表示m和n对应位是否相同
    int count = 0; // 初始化计数器
    while (xorResult != 0) {
        count += xorResult & 1; // 检查最低位是否为1，然后递增计数器
        xorResult >>= 1; // 右移异或结果
    }
    return count;
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n);
    int result = hammingDistance(m, n);
    printf("%d\n", result);
    return 0;
}