Binary 使用逻辑运算将1添加到二进制数

如标题所述；我想只使用AND或XOR操作将1添加到4位二进制数。我怎样才能做到这一点

---

关于

想想当你用长手笔进行十进制数加法时你在做什么。完全一样

---

下面是我的做法，展示了大量的工作

标记从

b0

（最低有效位）到

b3

（最高有效位）的四位，并引入5个进位，

c0

到

c4

。修改后的值是

b3'，b2'，b1'，b0'

，因此您的半字节、进位和修改后的值是：

{     b3  b2  b1  b0  }
{ c4  c3  c2  c1  c0  }
{     b3' b2' b1' b0' }

它们通过以下方式相互关联：

c0  = 1 (this is to flip the least significant bit)

b0' = XOR(b0, 1)
c1  = AND(b0, 1)

b1' = XOR(b1, c0)
c2  = AND(b1, c0)

b2' = XOR(b2, c1)
c3  = AND(b2, c1)

b3' = XOR(b3, c2)
c4  = AND(b3, c2)

注意：

public class Nibble
{
    const int bits = 4;

    private bool[] _bools = new bool[bits];

    public void Reset()
    {
        for ( int i = 0; i < _bools.Length; i++ )
            _bools[i] = false;
    }

    public void Increment()
    {
        bool[] result = new bool[bits];
        bool[] carries = new bool[bits + 1];

        carries[0] = true;

        for ( int i = 0; i < bits; i++ )
        {
            result[i] = _bools[i] ^ carries[i];
            carries[i + 1] = _bools[i] && carries[i];
        }

        if ( carries[bits] )
            Console.WriteLine("Overflow!");

        _bools = result;
    }

    public byte Value
    {
        get
        {
            byte result = 0;
            for ( int i = 0; i < bits; i++ )
            {
                if ( _bools[i] )
                    result += (byte)(1 << i);
            }
            return result;
        }
    }
}

static class Program
{
    static void Main()
    {
        var nibble = new Nibble();
        for ( int i = 0; i < 17; i++ )
        {
            Console.WriteLine(nibble.Value);
            nibble.Increment();
        }
    }
}

不需要使用

或

四位的选择是任意的——超过第一位，逻辑是任意的

当最后一个进位

c3

为

0

时，数字为静默（从

15

到

0

）

不需要四个进位，但为了与手动加法范例保持一致，我还是介绍了它们

四位是一个数字

---

样本C#类：

public class Nibble
{
    const int bits = 4;

    private bool[] _bools = new bool[bits];

    public void Reset()
    {
        for ( int i = 0; i < _bools.Length; i++ )
            _bools[i] = false;
    }

    public void Increment()
    {
        bool[] result = new bool[bits];
        bool[] carries = new bool[bits + 1];

        carries[0] = true;

        for ( int i = 0; i < bits; i++ )
        {
            result[i] = _bools[i] ^ carries[i];
            carries[i + 1] = _bools[i] && carries[i];
        }

        if ( carries[bits] )
            Console.WriteLine("Overflow!");

        _bools = result;
    }

    public byte Value
    {
        get
        {
            byte result = 0;
            for ( int i = 0; i < bits; i++ )
            {
                if ( _bools[i] )
                    result += (byte)(1 << i);
            }
            return result;
        }
    }
}

static class Program
{
    static void Main()
    {
        var nibble = new Nibble();
        for ( int i = 0; i < 17; i++ )
        {
            Console.WriteLine(nibble.Value);
            nibble.Increment();
        }
    }
}

公共类半字节
{
常数int位=4；
私有bool[]_bools=新bool[bits]；
公共无效重置（）
{
对于（int i=0；i<\u bools.Length；i++）
_bools[i]=false；
}
公共空间增量（）
{
bool[]结果=新bool[位]；
bool[]进位=新bool[位+1]；
携带[0]=真；
for（int i=0；i