【经典算法】LeetCode 67. 二进制求和(Java/C/Python3/Golang实现含注释说明,Easy)

public class Solution {
    public String addBinary(String a, String b) {
        StringBuilder sb = new StringBuilder();
        int carry = 0; // 进位
        int i = a.length() - 1;
        int j = b.length() - 1;
        while (i >= 0 || j >= 0 || carry != 0) {
            int sum = carry;
            if (i >= 0) {
                sum += a.charAt(i) - '0';
                i--;
            }
            if (j >= 0) {
                sum += b.charAt(j) - '0';
                j--;
            }
            sb.append(sum % 2); // 当前位的值
            carry = sum / 2; // 更新进位
        }
        // 反转字符串得到正确的结果
        return sb.reverse().toString();
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* addBinary(char* a, char* b) {
    int lenA = strlen(a);
    int lenB = strlen(b);
    int carry = 0;
    int maxLength = lenA > lenB ? lenA : lenB;
    char* result = (char*)malloc(maxLength + 2); // 多分配一位用于进位和字符串结尾'\0'
    int i = lenA - 1;
    int j = lenB - 1;
    int index = 0;
    while (i >= 0 || j >= 0 || carry != 0) {
        int sum = carry;
        if (i >= 0) {
            sum += a[i] - '0';
            i--;
        }
        if (j >= 0) {
            sum += b[j] - '0';
            j--;
        }
        result[index++] = sum % 2 + '0';
        carry = sum / 2;
    }
    result[index] = '\0'; // 字符串结尾
    // 反转结果字符串
    for (int start = 0, end = index - 1; start < end; start++, end--) {
        char temp = result[start];
        result[start] = result[end];
        result[end] = temp;
    }
    return result;
}

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        carry = 0
        i, j = len(a) - 1, len(b) - 1
        result = []
        while i >= 0 or j >= 0 or carry:
            sum_val
            = carry
            if i >= 0:
                sum_val += int(a[i])
                i -= 1
            if j >= 0:
                sum_val += int(b[j])
                j -= 1
            result.append(str(sum_val % 2))
            carry = sum_val // 2
        return ''.join(reversed(result))

package main
import (
  "fmt"
  "strconv"
  "strings"
)
func addBinary(a string, b string) string {
  carry := 0
  i, j := len(a)-1, len(b)-1
  var result strings.Builder
  for i >= 0 || j >= 0 || carry > 0 {
    sum := carry
    if i >= 0 {
      sum += int(a[i] - '0')
      i--
    }
    if j >= 0 {
      sum += int(b[j] - '0')
      j--
    }
    result.WriteByte(byte(sum%2 + '0'))
    carry = sum / 2
  }
  // 反转结果字符串
  resultBytes := result.String()
  for i, j := 0, len(resultBytes)-1; i < j; i, j = i+1, j-1 {
    resultBytes = strings.Replace(resultBytes, string(resultBytes[i])+string(resultBytes[j]), string(resultBytes[j])+string(resultBytes[i]), 1)
  }
  return resultBytes
}
func main() {
  a := "1010"
  b := "1011"
  fmt.Println(addBinary(a, b)) // 输出: 10101
}

public class Solution {
    public String addBinary(String a, String b) {
        int num1 = Integer.parseInt(a, 2); // 将二进制字符串转换为整数
        int num2 = Integer.parseInt(b, 2);
        int sum = num1 + num2;
        return Integer.toBinaryString(sum); // 将整数转换为二进制字符串
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
char* addBinary(char* a, char* b) {
    // 转换字符串到整数（手动实现，因为没有内建函数）
    int len_a = strlen(a);
    int len_b = strlen(b);
    int max_len = len_a > len_b ? len_a : len_b;
    int carry = 0;
    int sum = 0;
    int *result = (int *)malloc((max_len + 2) * sizeof(int)); // +2 for carry and null terminator
    result[max_len + 1] = '\0'; // Null terminator for the string
    // 从字符串的末尾开始相加，并处理进位
    for (int i = 0; i <= max_len; i++) {
        int digit_a = i < len_a ? a[len_a - i - 1] - '0' : 0;
        int digit_b = i < len_b ? b[len_b - i - 1] - '0' : 0;
        sum = digit_a + digit_b + carry;
        result[max_len - i] = sum % 2;
        carry = sum / 2;
    }
    // 如果最高位有进位，则需要添加一位
    if (carry > 0) {
        result = (int *)realloc(result, (max_len + 2 + 1) * sizeof(int));
        memmove(result + 1, result, (max_len + 2) * sizeof(int));
        result[0] = carry;
        result[max_len + 2] = '\0'; // Update null terminator position
    }
    // 将整数数组转换为字符串并返回
    char *binary_string = (char *)malloc((max_len + 2 + 1) * sizeof(char)); // +1 for null terminator
    for (int i = 0; i <= max_len + carry; i++) {
        binary_string[i] = result[max_len + carry - i] + '0';
    }
    binary_string[max_len + carry + 1] = '\0'; // Null terminator
    free(result); // 释放整数数组的内存
    return binary_string;
}

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        return bin(int(a, 2) + int(b, 2))[2:]

在Golang中，使用`strconv`包中的函数将二进制字符串转换为整数，并执行加法运算后，再将结果转换回二进制字符串，是一个简单且有效的方法。下面是完整的Golang代码示例：

package main
import (
  "fmt"
  "strconv"
)
func addBinary(a string, b string) string {
  // 将二进制字符串转换为整数
  num1, _ := strconv.ParseInt(a, 2, 64)
  num2, _ := strconv.ParseInt(b, 2, 64)
  // 执行加法运算
  sum := num1 + num2
  // 将整数转换回二进制字符串
  binarySum := strconv.FormatInt(sum, 2)
  return binarySum
}
func main() {
  a := "1010"
  b := "1011"
  fmt.Println(addBinary(a, b)) // 输出: 10101
}