二进制求和 - 简单

*************

C++

topic: 67. 二进制求和 - 力扣（LeetCode）

*************

Give the topic an inspection.

Too many works these days. And no spare time for code learning. However here I am gagin.

This topic is an easy one and I want to practice some skills about namespace, class and so on. So todays study might have some fun.

binary is every, it is something like to be or not to be. It just has 0 and 1.

自己动手制作计算机CPU的核心部件，二进制加法器

so the code is really to say.

first to get the size and define a string to store the sumation. Adding another single bit need int carry help.

class Solution {
public:
    string addBinary(string a, string b) {
        string result; // 存储最终结果的二进制字符串
        int i = a.size() - 1; // 指针i初始指向字符串a的最后一个字符（最低位）
        int j = b.size() - 1; // 指针j初始指向字符串b的最后一个字符（最低位）
        int carry = 0; // 进位标志，初始化为0

        // 循环条件：当任意一个字符串还有未处理的位，或者还有进位需要处理时继续
        while (i >= 0 || j >= 0 || carry > 0) {
            // 获取当前位的数字，如果指针已越界则补0
            int digitA = (i >= 0) ? (a[i] - '0') : 0; // 将字符转换为数字（'0'->0, '1'->1）
            int digitB = (j >= 0) ? (b[j] - '0') : 0; // 同上

            // 计算当前位的总和（包括进位）
            int sum = digitA + digitB + carry;
            
            // 计算新的进位（二进制逢2进1）
            carry = sum / 2; // 如果sum>=2则carry=1，否则carry=0
            
            // 计算当前位的值（取sum对2的余数）
            int currentDigit = sum % 2; // 结果为0或1
            
            // 将当前位的结果存入result（注意这里是从低位到高位顺序存储的）
            result.push_back(currentDigit + '0'); // 将数字转换回字符格式
            
            // 移动指针到前一位
            i--; // 处理a的前一位
            j--; // 处理b的前一位
        }

        // 由于我们是先计算低位后计算高位，需要反转字符串得到正确顺序
        reverse(result.begin(), result.end());
        
        // 返回最终结果
        return result;
    }
};

take an example: a = "1", b = "1"（即 1 + 1，二进制结果应为 "10"）

步骤	当前执行代码行	变量状态变化 (i, j, carry, result)	条件判断结果	循环次数	输出内容	操作注释
1	string a = "1";	a = "1"	-	-	-	初始化输入 a
2	string b = "1";	b = "1"	-	-	-	初始化输入 b
3	string result;	result = ""	-	-	-	初始化空结果
4	int i = a.size()-1;	i = 0	-	-	-	指向 a 的最后一位 ('1')
5	int j = b.size()-1;	j = 0	-	-	-	指向 b 的最后一位 ('1')
6	int carry = 0;	carry = 0	-	-	-	初始化进位为 0
7	while (i >= 0 || j >= 0 || carry > 0)	i=0, j=0, carry=0 → 进入循环	true (满足任一)	1	-	第一次循环开始
8	int digitA = (i >= 0) ? (a[i]-'0') : 0;	digitA = 1 (a[0]='1' → 1)	i >= 0 为 true	1	-	取 a 的当前位 '1' 并转为数字 1
9	int digitB = (j >= 0) ? (b[j]-'0') : 0;	digitB = 1 (b[0]='1' → 1)	j >= 0 为 true	1	-	取 b 的当前位 '1' 并转为数字 1
10	int sum = digitA + digitB + carry;	sum = 1 + 1 + 0 = 2	-	1	-	计算当前位和进位总和
11	carry = sum / 2;	carry = 0 → **1**	-	1	-	更新进位：2 / 2 = 1
12	int currentDigit = sum % 2;	currentDigit = 0 (2 % 2 = 0)	-	1	-	计算当前位值：0
13	result.push_back(currentDigit + '0');	result = "" → **"0"**	-	1	-	将 '0' 存入 result
14	i--; j--;	i = 0 → **-1**, j = 0 → -1 `	-	1	-	移动指针到前一位（越界）
15	while (i >= 0 || j >= 0 || carry > 0)	i=-1, j=-1, carry=1 → 进入循环	true (carry > 0)	2	-	第二次循环（因 carry=1 继续）
16	int digitA = (i >= 0) ? (a[i]-'0') : 0;	digitA = 0 (i < 0)	i >= 0 为 false	2	-	a 已越界，补 0
17	int digitB = (j >= 0) ? (b[j]-'0') : 0;	digitB = 0 (j < 0)	j >= 0 为 false	2	-	b 已越界，补 0
18	int sum = digitA + digitB + carry;	sum = 0 + 0 + 1 = 1	-	2	-	计算当前位和进位总和
19	carry = sum / 2;	carry = 1 → **0**	-	2	-	更新进位：1 / 2 = 0
20	int currentDigit = sum % 2;	currentDigit = 1 (1 % 2 = 1)	-	2	-	计算当前位值：1
21	result.push_back(currentDigit + '0');	result = "0" → **"01"**	-	2	-	将 '1' 存入 result
22	i--; j--;	i = -1 → **-2** , j = -1 → -2`	-	2	-	移动指针（越界）
23	while (i >= 0 || j >= 0 || carry > 0)	i=-2, j=-2, carry=0 → 退出循环	false (全不满足)	-	-	循环终止
24	reverse(result.begin(), result.end());	result = "01" → **"10"**	-	-	-	反转结果字符串
25	return result;	-	-	-	"10"	返回最终结果 "10"

and the function is in class Solution, what if I put the calculation function in class calculationBinary?

// 专门负责二进制计算逻辑的类
class CalculationBinary 
{
public:
    string add(string a, string b) 
    {
        string result;
        int i = a.size() - 1;  // 指向a的末位（最低位）
        int j = b.size() - 1;  // 指向b的末位（最低位）
        int carry = 0;         // 进位标志

        // 当任意数字还有未处理的位或存在进位时继续
        while (i >= 0 || j >= 0 || carry > 0) 
        {
            // 获取当前位数字（越界补0）
            int digitA = (i >= 0) ? (a[i--] - '0') : 0;
            int digitB = (j >= 0) ? (b[j--] - '0') : 0;
            
            // 计算当前位总和及进位
            int sum = digitA + digitB + carry;
            carry = sum / 2;           // 计算新进位
            result.push_back((sum % 2) + '0');  // 存储当前位
        }
        
        // 反转得到高位优先的顺序
        reverse(result.begin(), result.end());
        return result;
    }
};


// 对外提供的接口类
class Solution {
public:
    string addBinary(string a, string b) 
    {
        CalculationBinary calculator;  // 创建计算器实例
        return calculator.add(a, b);   // 调用计算方法
    }
};