Given this exercise: (from codewars.com)

Create a function that returns the square of each digit of a number.

For example, when entering the function the number 702 should return 4904, since the square of 7 is 49, the square of 0 is 0 and the square of 2 is 4. If the function receives a zero it must return 0.

The underlying challenge of this exercise is to go through an integer digit by digit and return a result as another integer.

Like everything in programming, it is possible to solve this exercise in many ways. First, let's solve it using number manipulation properties in Python, then I will explain another more advanced way ?.

def square_digits(num):
    if num == 0:
        return 0
    result = ""
    while num > 0:
        num_sqr = (num % 10) ** 2 
        num = num // 10
        result = str(num_sqr)   result 
    return int(result)

In this code, we first evaluate whether a 0 is received to return a 0, as indicated in the statement. Then, we initialize the variable result as an empty string, create a while loop with the condition num > 0. We define the variable num_sqr, which is the square of each digit received. With num % 10 we obtain the last digit of the number received and then square it with **2.

• Using num % 10 is a common method for extracting the last digit of a number.

• The expression num = num // 10 removes the last digit of the number, moving forward through each digit.

Another way to solve it is to convert the number into a string and loop through this string with a for loop:

def square_digits(num):
    result = ""
    for digit in str(num):
        result  = str(int(digit)**2)
    return int(result)

This code is more optimal, it has fewer lines and the traversal is very well understood, and it is not necessary to evaluate if it receives a 0. In Python it is possible to traverse a string character by character with a for loop. We use this functionality to loop through the received number, converting it with str(num) to a string. We create the variable result as an empty string, to which a character will be concatenated that is the result of digit converted to an integer and raised to 2, all converted to a string. Then, we return the result converted to an integer.

• Concatenating strings within a loop may be less performance efficient for very large numbers, but is perfectly acceptable for most use cases.

*A more advanced and "elegant" way * is using Generator Understanding and the .join motodo. I present the code to you first and we will break it down explaining these terms.

def square_digits(num):
    return int(''.join(str(int(digit)**2) for digit in str(num)))

This first code is not very readable if you do not know the concepts
that make it up.

The expression str(int(digit)**2) for digit in str(num) is a _generator _(Generator Expression) that iterates over each digit in the string representation of the number num.
For each digit, it converts it to an integer (int(digit)), squares it (**2), and then converts it back to a string (str(...)). Then, with ''.join(...), you take a sequence (in this case, the generator) and concatenate all the elements into a single string. Here, all the square digits are combined into a single string without any separator (because the string between the single quotes is empty '').

As we see, the different ways of solving an exercise demonstrate the levels of knowledge in a language. All solutions are correct if they pass the tests, but some are more efficient and readable than others. The choice of approach depends on the context and what is prioritized in each case:

• Readability: It is crucial when other developers are going to read and maintain your code. Clear, easy-to-understand code reduces the chance of errors and makes it easier to maintain. ?

• Efficiency: Matters when working with large volumes of data or in applications where performance is critical. More optimized code can make a big difference in speed and resource consumption. ?

• Simplicity: For cases where the priority is to solve the problem quickly and directly, such as in prototypes or didactic exercises. Simplicity often makes code debugging and testing easier. ?

When developing, it is important to find a balance between these considerations, adapting the solution to the specific needs of the project or task.