尝试着在 LeetCode 上用 Rust 刷些题。

题目地址：https://leetcode-cn.com/problems/add-binary/

这一题我的解法基本上就是把两个二进制反转后从前往后挨个进行相加进位，感觉代码还不够优雅。

但是基础原理够明白，没有任何所谓的溢出问题。

对于 Rust 不不是很熟悉，最折腾的就是这个 string_bin_vec 函数，最开始直接用 to_bytes() 或 .reverse() 进行反转，被借用、引用折腾好久就是编译不过，最终采用了复制成反转的 vec 方法，不过看了别人的题貌似两个字符串可以使用 .chars().rev() 之后以 iter 的形式进行遍历。

impl Solution {

    pub fn add_binary(a: String, b: String) -> String {
        // 从后向前运算会比较麻烦，所以这里将字符串复制成反转的 vec 后从前往后算就简单的多
        let ab = Solution::string_bin_vec(&a);
        let bb = Solution::string_bin_vec(&b);

        let mut c: Vec<u8> = vec![];

        // 当两个二进制字符串不一样长时，确定最长的处理次数
        let al = ab.len();
        let bl = bb.len();
        let max_len = if al > bl { al } else { bl };

        let mut plus = false;

        for x in 0..max_len {
            let ax: u8 = if x < al { ab[x] } else { 0 };
            let bx: u8 = if x < bl { bb[x] } else { 0 };

            // 确定当前相加值和是否有进位
            let mut cur: u8 = if ax == bx { 0 } else { 1 };
            let mut now_plus: bool = ax == 1 && bx == 1;

            // 如果前一次运算有进位则需要再运算
            if plus {
                cur = if cur == 0 { 1 } else {
                    now_plus = true;
                    0
                }
            }

            println!("ax={}, bx={}, cur={}, plus={}", ax, bx, cur, plus);

            plus = now_plus;
            c.push(cur);
        }

        if plus {
            c.push(1);
        }

        // 结果要再反转一下成为正常的顺序
        c.reverse();

        // 还原成字符串并返回
        let mut cs: String = String::from("");

        for x in 0..c.len() {
            let s = if c[x] == 1 {
                "1"
            } else {
                "0"
            };
            cs.push_str(s);
        }

        cs
    }

    fn string_bin_vec(str: &String) -> Vec<u8> {
        let bytes = &str.as_bytes();
        let mut new_vec: Vec<u8> = vec![];

        for x in 0..bytes.len() {
            new_vec.push(if bytes[x] == 48 { 0 } else { 1 });
        }

        new_vec.reverse();
        new_vec
    }

}