JavaScript Coding Test Course, Sum of Numbers

This article will cover one of the frequently asked algorithm problems in JavaScript coding tests, “Sum of Digits.” Through this problem, we will learn about basic algorithm construction abilities and how to handle data in JavaScript.

Problem Description

Given a string of numbers, write a function that calculates the sum of the digits included in the string.
For example, if the input string is “12345”, it should return 1 + 2 + 3 + 4 + 5 = 15.

Input

  • A single string of digits with length n is provided (1 ≤ n ≤ 106)

Output

  • Returns the sum of all the digits in the string as an integer.

Problem Approach

To solve this problem, the following basic steps will be undertaken:

  1. Traverse the string of digits and convert each character to a number.
  2. Accumulate the converted numbers.
  3. Return the final sum.

Code Implementation

The code implementation to solve this problem in JavaScript can be done as follows. 


function sumOfDigits(numString) {
    // Initialize basic variable
    let total = 0;

    // Traverse characters
    for(let i = 0; i < numString.length; i++) {
        // Convert each character to number and accumulate
        total += parseInt(numString[i]);
    }

    // Return final sum
    return total;
}

// Function test
const inputString = "12345";
const result = sumOfDigits(inputString);
console.log("Input string:", inputString);
console.log("Sum of digits:", result); // Output: 15

Code Explanation

The above code defines a function called sumOfDigits. This function takes a string of numbers as input, traverses each character, converts it to an integer, and calculates the total sum.

  • let total = 0;: Initializes a variable to store the sum from the string.
  • for(let i = 0; i < numString.length; i++) { ... }: Uses a loop to iterate through each character of the input string based on its length.
  • total += parseInt(numString[i]);: Uses parseInt to convert each character of the string to an integer and accumulates the sum.
  • return total;: Returns the accumulated sum.

Time Complexity Analysis

The time complexity of this algorithm is O(n), where n refers to the length of the input string. Since we only traverse the string once, the time complexity is linear.

Space Complexity Analysis

The space complexity is O(1). This is because, apart from the input string, only one additional variable is used.

Variant Problem

If the above problem is the basic form, a variant might be "Calculate the sum of positive numbers in an array containing both negative and positive numbers."
Such problems may require adjusting the basic algorithm or considering additional conditions, thus necessitating slight modifications to the code.

Example Modified Code for Variant Problem


// Variant Problem: Calculate the sum of digits at even indices
function sumEvenIndexedDigits(numString) {
    let total = 0;

    // Sum only the digits at even indices
    for(let i = 0; i < numString.length; i += 2) {
        total += parseInt(numString[i]);
    }
    
    return total;
}

// Code test
const inputString = "123456"; // Example: sum 1, 3, and 5
console.log("Sum of even indices:", sumEvenIndexedDigits(inputString)); // Output: 12

Conclusion

The "Sum of Digits" problem is very useful for learning the basic syntax and algorithms of JavaScript.
Through this problem, one can learn foundational concepts like string handling, loops, and conditional statements.
Try exploring various variant problems to deepen your understanding of algorithms.

In the next session, we will tackle more complex problems. I hope this course helps you learn various techniques that you can use in JavaScript coding tests and aids you in effectively solving problems.