dumb_shit/multiply_strings/src/main.rs

pub fn multiply(num1: String, num2: String) -> String {
    //

    let mut out: Vec<u32> = (0..(num1.len() + num2.len()))
        .into_iter()
        .map(|_| 0)
        .collect();

    let l1 = num1.len();
    let l2 = num2.len();

    // get the longest one as num1
    let (num1, num2) = if l1 < l2 { (num2, num1) } else { (num1, num2) };

    for (i2, d2) in num2.chars().rev().enumerate() {
        let mut mcarry = 0;
        let mut tmp: Vec<u32> = (0..i2).into_iter().map(|_| 0).collect();
        let d2 = d2.to_digit(10).unwrap();
        for d1 in num1.chars().rev() {
            let d1 = d1.to_digit(10).unwrap();
            let p = (d1 * d2) + mcarry;
            mcarry = p / 10;
            let p = p % 10;
            tmp.push(p);
        }
        if mcarry > 0 {
            tmp.push(mcarry);
        }
        merge(&mut out, &tmp);
    }
    while let Some(last) = out.last() {
        if *last == 0 {
            let len = out.len() - 1;
            out = out[0..len].to_vec();
        } else {
            break;
        }
    }
    if out.is_empty() {
        out.push(0);
    }

    out.iter().rev().map(|d| d.to_string()).collect()
}

fn merge(out: &mut [u32], rhs: &[u32]) {
    //
    let mut acarry = 0;
    let len = rhs.len();
    (0..len).for_each(|i| {
        let oi = out[i];
        let ri = rhs[i];
        let s = oi + ri + acarry;
        acarry = s / 10;
        let s = s % 10;
        out[i] = s;
    });
    if acarry > 0 {
        out[len] = acarry;
    }
}

fn main() {
    dbg!(multiply("2".to_string(), "4".to_string()));
    dbg!(multiply("27".to_string(), "49".to_string()));
    dbg!(multiply(
        "20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
            .to_string(),
        "4000000000000000000000000000000000000000000000000000000000000000".to_string()
    ));

    dbg!(multiply("0".to_string(), "8".to_string()));
}