int superDigit(string n, int k) {
    
    // Base case
    if (n.length() == 1 && k == 0) {
        return std::stoi(n);
    }
    
    // First run
    if (k != 0) {
        size_t sum = 0;        
        for (size_t i = 0; i < n.length(); ++i) {
            sum += n.at(i) - '0';
        }
        sum = sum * k;
        return superDigit(to_string(sum), 0);
        
    } else { // Recursion body
        size_t sum = 0;        
        for (size_t i = 0; i < n.length(); ++i) {
            sum += n.at(i) - '0';
        }

        return superDigit(std::to_string(sum), 0);   
    }
}

def superDigit(n, k):
    # Write your code here
    sum_of_digits = 0
    for digit in n:
        sum_of_digits += int(digit)
    sum_of_digits *= k
    if sum_of_digits < 10:
        return sum_of_digits
    else:
        return superDigit(str(sum_of_digits), 1)

# Notes:
# 1. Don't calc p ahead of time both b/c Python's conversion of string to int
#    has a cap (adjust w/ sys.set_int_max_str_digits()) and b/c it's easier to
#    manage the expense of the operation during iteration
# 2. It's a little silly to pass k in the recursive call b/c it's only used
#    on the first iteration, but it seems even sillier to write a superDigit0
#    that only takes an n and is used for recursion.
# 3. It may be possible to determine that n < 1e100000 and k <= 1e5 will give
#    you a p that won't blow the stack by recurring too many times but I didn't
#    do that. To be safe, we could unroll the recursion into a loop.
def superDigit(n: str, k: int) -> int:
        
    def sdc(ns: str) -> int:
        acc = 0
        for ch in ns:
            acc += int(ch)
        return acc * k
        
    total = sdc(n)    
    if total < 10:
        return total
    return superDigit(str(total), 1)

def combineMethod(n,k):
    return str(n)*k

def sumCurrentDigit(current):
    sum = 0
    for record in current:
        sum += int(record)
    return sum

def getSuperDigit(combineDigit):
    super = None
    current = list(str(combineDigit))
    while(True):
        if len(current) ==1:
            super = current
            break
        sumDg = sumCurrentDigit(current)
        current = list(str(sumDg))
    return super
def superDigit(n, k):
    # Write your code here
    sumCurrent = sumCurrentDigit(n)
    combineDigit = combineMethod(sumCurrent,k)
    super = getSuperDigit(combineDigit)
    super = super[0]
    super = int(super)
    return super