pub fn add_binary(a: String, b: String) -> String {
  // Pad the strings with leading zeroes so they're the same length.
  let (a, b) = (
    format!("{:0>1$}", a, b.len()),
    format!("{:0>1$}", b, a.len()),
  );

  let mut carry = false;
  let mut sum = String::new();

  // Create reversed iterators for both binary strings.
  let (mut a, mut b) = (a.chars().rev(), b.chars().rev());

  while let Some(a) = a.next() {
    // Safe to unwrap since we know both iterators will be the same length.
    let b = b.next().unwrap();

    match (a, b) {
      ('1', '1') => {
        // For 1 + 1, if we need to carry it will be 01 + 01 -> 10 + 01 -> 11.
        // And otherwise it will be 01 + 01 -> 10, and carry next digit.
        if carry {
          sum.push('1');
        } else {
          sum.push('0');
          carry = true;
        }
      }

      // For 1 + 0 (and associatively 0 + 1), if we need to carry it's the same
      // as 01 + 01 -> 10. And keep the carry set.
      // And otherwise it will just be 01 + 00 -> 01.
      ('1', '0') | ('0', '1') => {
        if carry {
          sum.push('0');
        } else {
          sum.push('1');
        }
      }

      // For 0 + 0, if we need to carry it results in 1 and otherwise 0.
      ('0', '0') => {
        if carry {
          sum.push('1');
          carry = false;
        } else {
          sum.push('0');
        }
      }

      _ => unreachable!(),
    }
  }

  // And if the final digits required carrying, add the 1 here at the end.
  if carry {
    sum.push('1');
  }

  sum.chars().rev().collect()
}