Lesson 2
Traversing and Processing Integer Digits in Scala
Introduction

Welcome! In today's lesson, we'll dive into a fascinating coding challenge that revolves around traversing the digits of a number using a while loop under a specific condition. You will have the chance to practice and refine your skills in working with Scala's loops and conditional statements, which are fundamental concepts in programming. Are you ready to get started? Let's jump in!

Task Statement

Our objective today is to create a function that operates on an integer input. While the task may appear straightforward, it requires some cleverness. Here’s the challenge: given an integer, n, calculate and return the sum of its even digits without converting n into a string. For example, if n is 4625, the output should be 12, as the sum of the even digits 4, 6, and 2 equals 12.

Keep in mind that n will always be a positive integer between 1 and 10^8. Ready to tackle this challenge? Fantastic! Let’s begin!

Solution Building: Step 1

To get started, we need the basic structure of our function, beginning with defining a variable digitSum to keep track of the sum of even digits.

Here’s the initial platform for our function in Scala:

Scala
1def solution(n: Int): Int = {
2    var digitSum = 0
3    // Our code will evolve from here
4}
Step 2: Setting up the Loop

To traverse the digits of the input integer n, we will use a while loop that runs as long as n is greater than zero. Remember, the input n is immutable, so we'll work with a mutable copy of it. Let's incorporate this into our function:

Scala
1def solution(n: Int): Int = {
2    var digitSum = 0
3    var num = n // we need a mutable copy of n
4    while (num > 0) {
5        // We'll develop our function from here
6    }
7    digitSum
8}
Step 3: Extracting and Processing Each Digit

Inside our loop, we'll extract the last digit of num using the modulo operation (num % 10). If the digit is even, we'll add it to digitSum.

After processing a digit, remove the last digit from num using integer division (num / 10), which allows the while loop to continue to the next digit. Here’s how it appears in the code:

Scala
1def solution(n: Int): Int = {
2    var digitSum = 0
3    var num = n
4    while (num > 0) {
5        val digit = num % 10
6        if (digit % 2 == 0) {  // Check if the digit is even
7            digitSum += digit
8        }
9        num = num / 10  // Remove the last digit
10    }
11    digitSum
12}
Step 4: Returning the Result

After summing all the even digits, the final step is to return our digitSum. Here is the complete function in Scala:

Scala
1def solution(n: Int): Int = {
2    var digitSum = 0
3    var num = n
4    while (num > 0) {
5        val digit = num % 10
6        if (digit % 2 == 0) {
7            digitSum += digit
8        }
9        num = num / 10
10    }
11    digitSum
12}
Lesson Summary

Well done on completing this lesson! You have successfully navigated the foundational concepts of using a while loop to traverse the digits of a number and gained an understanding of how to apply conditions within it. I encourage you to explore additional challenges to solidify and build upon your new skill set. Remember, your potential for growth in programming is only limited by your persistence. Keep practicing; your proficiency with Scala is expanding with each challenge you master!

Enjoy this lesson? Now it's time to practice with Cosmo!
Practice is how you turn knowledge into actual skills.