consider this example, where n = 23, k = 3

accoring to problem we can do it as 2+3+2+3+2+3 = 6+9 or (n*k) means (23*3) = 69 eventually which leads to 6+9 then we use modulus 9, according to decimal number system here is some interesting fact with proof being provided in the following link key to your curiosity

cheers (y)

I have tried to explain this in a video https://youtu.be/4LFuarM8j9Q

First consider case where the input is only one digit: superdigit(x where x<10)

its obvious that superdigit(x) =x mod 9 if x is smaller than 9. Only x==9 will be an edge case. Now we consider a decimal number such as 100*a+10*b+c and we can prove that 100*a+10*b+c mod 9 =(a+b+c) mod 9 +(99*a+9*b)mod 9 100*a+10*b+c mod 9=0+(a+b+c) mod 9 which means mod9 conserves through recursive superdigit operation.

Then if we have any given input a, we can draw a chain like a-b-c-..-x where x is a single digit number.

From the previous paragraph, we know that amod9==bmod9==cmod9 .... ==xmod9

From the property defined in superdigit operation, we know that supdigit(a)==superdigit(b)==superdigit(c)==...superdigit(x)

Since in the first pragraph, we showed that superdigit(x)==xmod9 despite the edge case where x==9. This tells us that tails of two chains are equal, so the heads of two chains must also be equal except x==9 case.

Therefore supdigit(a)==a mod 9 if a mod 9!=0 supdigit(a)==9 if a mod9 ==0

which

C# Recursive:

static int superDigit(string n, int k) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < k % 9; i++){
            sb.Append(n);
        }
        return Helper(sb);
    }

    static int Helper(StringBuilder str){
        if(str.Length == 1)
            return Convert.ToInt32(str.ToString());
        else{
            long sum = 0;
            for(int i = 0; i < str.Length; i++){
                sum += Convert.ToInt32(str[i].ToString());
            }
            return Helper(new StringBuilder(sum.ToString()));
        }
    }

Totally agree with you. Here's what I did in Python:

def superDigit(n, k):
    if len(n)==1:
        return n
    return superDigit(str(sum(map(int, n))*k),1)

Can someone provide explaination as to what "return(x if x else 9)" is doing? I understand it is returning the output, but I do not understand the logic of how because how does the proram know when to return '9' versus 'x'?

memoize your results that helped me in solving in js with recursion

Java 8 Solution (with Recursion)

static int superDigit(String n, int k) {
    n = n.chars().mapToLong(Character::getNumericValue).sum() * k
            + "";
    return (n.length() > 1) ? superDigit(n, 1) :
                                Character.getNumericValue(n.charAt(0));
}

Same in C++. Recursive solution causes Stack Overflow in the huge test cases (7,8,9).

@carnegiehall This recursive JavaScript solution has passed all test cases in Node.js:

JavaScript Solution (with Recursion)

function superDigit(n, k) {
    n = n.split("").reduce((a, b) => +a + +b) * k + "";
    return (n.length > 1) ? superDigit(n, 1) : n.charAt(0);
}

python3 solution passed.

def superDigit(n, k):
    
    def add_digits(string):
        if len(string) == 1:
            return string
        result = sum(int(s) for s in string)
        return add_digits(str(result))
    
    start = sum(int(s) for s in n) * k
    return add_digits(str(start))

It's not really working for all of the test cases.

awesome code man. my function is exactly same as urs but I am unable to break the string.

why it didn't throw runtime error?? this solution includes many loops :\

nope.

Amazing solution!!!