Add Digits

                                            
class Solution {
public:
    int addDigits(int num) {
        if (num == 0) return 0;
        if (num % 9 == 0) return 9;
        return num % 9;
    }
};

                                            
class Solution {
    public int addDigits(int num) {
        return 1 + (num - 1) % 9;
    }
}

                                            
class Solution(object):
    def addDigits(self, num):
        """
        :type num: int
        :rtype: int
        """
        if num == 0:
            return 0
        if num % 9 == 0:
            return 9
        return num % 9

                                            
int addDigits(int num) {
    return 1 + (num - 1) % 9;
}

                                            
public class Solution {
    public int AddDigits(int num) {
        if (num == 0)
            return 0;
        else if (num % 9 == 0)
            return 9;
        else
            return num % 9;
    }
}

                                            
/**
 * @param {number} num
 * @return {number}
 */
var addDigits = function(num) {
    return 1 + (num - 1) % 9;
};

                                            
function addDigits(num: number): number {
    return 1 + (num - 1) % 9;
};

                                            
class Solution {
    /**
     * @param Integer $num
     * @return Integer
     */
    function addDigits($num) {
        if ($num == 0) {
            return 0;
        } elseif ($num % 9 == 0) {
            return 9;
        } else {
            return $num % 9;
        }
    }
}

                                            
class Solution {
    func addDigits(_ num: Int) -> Int {
        if num == 0 {
            return 0
        } else if num % 9 == 0 {
            return 9
        } else {
            return num % 9
        }
    }
}

                                            
class Solution {
    fun addDigits(num: Int): Int {
        if (num == 0) return 0
        return 1 + (num - 1) % 9
    }
}

                                            
class Solution {
  int addDigits(int num) {
    if (num == 0) {
      return 0;
    } else if (num % 9 == 0) {
      return 9;
    } else {
      return num % 9;
    }
  }
}

                                            
func addDigits(num int) int {
    if num == 0 {
        return 0
    } else if num % 9 == 0 {
        return 9
    } else {
        return num % 9
    }
}

                                            
# @param {Integer} num
# @return {Integer}
def add_digits(num)
    return num == 0 ? 0 : 1 + (num - 1) % 9
end

                                            
object Solution {
    def addDigits(num: Int): Int = {
        if (num == 0) {
            0
        } else if (num % 9 == 0) {
            9
        } else {
            num % 9
        }
    }
}

                                            
impl Solution {
    pub fn add_digits(num: i32) -> i32 {
        if num == 0 {
            return 0;
        } else if num % 9 == 0 {
            return 9;
        } else {
            return num % 9;
        }
    }
}

                                            
(define/contract (add-digits num)
  (-> exact-integer? exact-integer?)
  (if (= num 0)
      0
      (if (= (remainder num 9) 0)
          9
          (remainder num 9))
      )
  )

                                            
-spec add_digits(Num :: integer()) -> integer().
add_digits(Num) ->
    case Num rem 9 of
        0 when Num > 0 -> 9;
        Digit -> Digit
    end.

                                            
defmodule Solution do
  @spec add_digits(num :: integer) :: integer
  def add_digits(num) do
    if num == 0 do
      0
    else
      rem(num - 1, 9) + 1
    end
  end
end

To solve this coding challenge, we need to continuously sum the digits of a given number until the result is a single digit. This needs to be done efficiently, aiming for a solution that avoids loops or recursion and achieves an O(1) runtime complexity.

Explanation

The problem can be approached in two ways:

Iterative Summing Method : This involves continuously summing the digits of the number until a single digit is achieved. This can be implemented using a loop or recursion but does not meet the O(1) runtime requirement.
Mathematical Approach : Using the properties of numbers and modular arithmetic, we can determine the result in O(1) time. This approach leverages the concept of digital roots.

Detailed Steps in Pseudocode

Digit Summing Method

Convert the number to a string to easily access each digit.
Sum the digits of the number.
If the result has more than one digit, repeat the process.
Continue this process until a single-digit number is obtained.

Mathematical Approach (Digital Root)

If the number is zero, the result is zero.
If the number is divisible by 9, the result is 9 (except when the number itself is zero).
For all other numbers, the result is the number modulo 9.

Pseudocode for Iterative Summing Method

                                            
# Define the function to add digits iteratively 
Function addDigitsIterative(number):
# Convert number to string to easily access each digit
While number is greater than or equal to 10:
digitSum = 0
# Loop through each digit
for digit in convert number to string:
# Add each digit to digitSum
digitSum = digitSum + convert digit to integer
# Set number to digitSum to re-evaluate in the next loop iteration
number = digitSum
# Return the resulting single digit number
Return number

Pseudocode for Mathematical Approach (Digital Root)

                                            
# Define the function using the mathematical approach
Function addDigitsMathematical(number):
# If the number is 0, the result is 0
If number == 0:
Return 0
# If the number is divisible by 9, the result is 9
If number modulo 9 == 0:
Return 9
# Otherwise, return the number modulo 9
Return number modulo 9

Step-by-Step Explanation

Iterative Summing Method

Initialization : Start with the given number.
Digit Access : Convert the number to a string format to loop through each character (digit).
Sum of Digits : Initialize a variable (
digitSum

) to store the sum of the digits.
Loop Through Digits : Loop through each character of the string representation of the number, convert each character back to an integer, and add it to
digitSum

.
Update Number : Set the number to the
digitSum

obtained.
Repeat : Continue this process while the number has more than one digit.
Return Result : Once a single-digit number is obtained, return it.

Mathematical Approach

Zero Check : Immediately return 0 if the input number is zero.
Modulo Check : Check if the number modulo 9 is zero. If so, return 9.
Modulo Result : Otherwise, return the result of the number modulo 9.

This method leverages modular arithmetic and properties of numbers to achieve constant time complexity, hence effectively solving the problem without loops or recursion.