负二进制表示法——“奋斗杯”编程大赛题目

0、题目

计算机里的数都是二进制表示，其实还有一种负二进制表示法，都不需要符号位。

如 3 的负二进制表示法为 111，因为 (-2)² + (-2)¹ + (-2)⁰ = 4-2+1 = 3 。

再如 -3 的负二进制表示法为 1101，因为 (-2)³ + (-2)² + (-2)⁰ = -8+4+1 = -3 。

要求输入一个整数，输出其负二进制表示。

• Golang
• Java

1、思考

幂	值
0	1
1	-2
2	4
3	-8
4	16
5	-32

由表可知，负二进制理论上可以表示计算机位数范围内的任意整数值。
准备几个特殊的值备用，(0)₁₀ = (0)_-2 , (1)₁₀ = (1)_-2 , (-1)₁₀ = (11)_-2

首先回忆一下十进制转二进制的方法，除2取余倒着写，嗯，我们先试一下，看看能不能也用到负二进制的换算上。

1.1 先试一个简单的值 16

• 16/(-2) = -8 ······ 0
• -8/(-2) = 4 ······ 0
• 4/(-2) = -2 ······ 0
• -2/(-2) = 1 ······ 0

所以 (16)₁₀ = (10000)_-2 ，嗯，看起来好像没毛病。

1.2 再试一下题干中的值3

• 3/(-2) = -1 ······ 1
• -1/(-2) = 0 ······ -1
• -1/(-2) = 0 ······ -1
• ······
• -1/(-2) = 0 ······ -1

呃，怎么成了无限循环了，虽然根据之前的特殊值 (-1)₁₀ = (11)_-2 ，可以推出 3/(-2) 商为 -1 余数为 1，所以 (3)₁₀ = (111)_-2，貌似也搞定了。

1.3 试一下特殊值-13

先在代码里运行一下 -13/(-2)，得到商为6，余数为-1。等等，余数为-1是什么鬼，余数不应该是1或者0吗？再想想，应该得到的商为7，余数为1，这样就行了。于是：

• -13/(-2) = 7 ······ 1
• 7/(-2) = -3 ······ 1
• -3/(-2) = 2 ······ 1
• 2/(-2) = -1 ······ 0
• -1/(-2) = 1 ······ 1
  所以，(-13)₁₀ = (110111)_-2 。
  验算一下，(-2)⁵+(-2)⁴+(-2)²+(-2)¹+(-2)⁰ = -32+16+4-2+1 = -13 。没毛病！

结论，当被除数为负数，余数为-1时，计算所得的商应该加一，余数就变为正1。

2 代码实现go和java

//go语言实现
func intToNegativeBinary(n int) {
    
    
	if n == 0 {
    
    
		fmt.Println(0)
		return
	}
	const BASE = -2
	var ans []byte
	for n != 1 {
    
    
		if n > 0 {
    
    
			ans = append(ans, byte('0'+n%BASE))
			n /= BASE
		} else {
    
    
			yu := n % BASE
			if yu == -1 {
    
    
				//余数为-1
				n = n/BASE + 1
				ans = append(ans, '0'+byte(1))
			} else {
    
    
				ans = append(ans, '0'+byte(yu))
				n /= BASE
			}
		}
	}
	//把最后剩下的1加进去
	ans = append(ans, '0'+byte(1))
	
	length := len(ans)
	//反转
	for i := 0; i < length/2; i++ {
    
    
		ans[i], ans[length-1-i] = ans[length-1-i], ans[i]
	}
	fmt.Println(string(ans))
}

//java代码实现
public static void intToNegativeBinary(int n){
    
    
        if (n == 0){
    
    
            System.out.println(0);
            return;
        }
        int BASE = -2;
        StringBuilder str = new StringBuilder();
        while (n != 1){
    
    
            if (n > 0){
    
    
                str.append(n%BASE);
                n/=BASE;
            } else {
    
    
                int yu = n%BASE;
                if (yu == -1){
    
    
                    //余数为-1
                    n = n/BASE + 1;
                    str.append(1);
                } else {
    
    
                    str.append(n%BASE);
                    n/=BASE;
                }
            }
        }
        //把最后剩下的1加进去
        str.append(1);
        str.reverse();
        System.out.println(str);
    }

java代码，也可以不用先append，再reverse，可以直接用 str.insert(0, 1); 实现向最前append。
自己测试了一下，大量数据时，如量级在10⁵，两个时差接近20倍，所以先append再reverse 速度更快。