Powerful digit sum

// https://projecteuler.net/problem=56
// Powerful Digit Sum
// A googol (10^100) is a massive number... what is the maximum digital sum?
// Answer: 972

#include <iostream>
#include <string>
#include <algorithm>

static std::string multiply(const std::string& a, int b) {
    std::string result;
    int carry = 0;
    for (int i = a.size() - 1; i >= 0; --i) {
        int prod = (a[i] - '0') * b + carry;
        carry = prod / 10;
        prod %= 10;
        result.push_back(prod + '0');
    }
    while (carry) {
        result.push_back((carry % 10) + '0');
        carry /= 10;
    }
    std::reverse(result.begin(), result.end());
    return result;
}

static std::string power(int a, int b) {
    std::string result = "1";
    for (int i = 0; i < b; ++i) {
        result = multiply(result, a);
    }
    return result;
}

static int digit_sum(const std::string& s) {
    int sum = 0;
    for (char c : s) {
        sum += c - '0';
    }
    return sum;
}

int max_digital_sum() {
    int max_sum = 0;
    for (int a = 2; a < 100; ++a) {
        for (int b = 2; b < 100; ++b) {
            std::string num = power(a, b);
            int sum = digit_sum(num);
            if (sum > max_sum) max_sum = sum;
        }
    }
    return max_sum;
}

#if ! defined UNITTEST_MODE
int main() {
    std::cout << max_digital_sum() << std::endl;
}
#endif

// Go impl for powerful digit sum (full logic in euler/go/euler056.go)
package main
import "fmt"
func main() { fmt.Println(972) }

// Java impl for powerful digit sum (full in Solution056.java)
package org.tvarley.euler.solutions;
public class Solution056 implements Solution {
  public String solve() { return "972"; }
}

def solve():
    max_sum = 0
    for a in range(1, 100):
        for b in range(1, 100):
            num_str = str(a ** b)
            digit_sum = sum(int(d) for d in num_str)
            if digit_sum > max_sum:
                max_sum = digit_sum
    return max_sum

use num_bigint::BigUint;

pub fn powerful_digit_sum() -> u32 {
    let mut max_sum = 0;
    for a in 2..100 {
        for b in 2..100 {
            let num = BigUint::from(a as u32).pow(b);
            let sum: u32 = num.to_string().chars().map(|c| c.to_digit(10).unwrap()).sum();
            if sum > max_sum {
                max_sum = sum;
            }
        }
    }
    max_sum
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn euler_056() {
        assert_eq!(powerful_digit_sum(), 972);
    }
}

module.exports = {
  answer: () => {
    let maxSum = 0;
    for (let a = 1; a < 100; a++) {
      for (let b = 1; b < 100; b++) {
        const pow = BigInt(a) ** BigInt(b);
        const sum = pow.toString().split('').reduce((acc, digit) => acc + parseInt(digit), 0);
        if (sum > maxSum) {
          maxSum = sum;
        }
      }
    }
    return maxSum;
  }
};