You up for another Code Wars Python Challenge?

Today I am doing the 6 kyu challenge "Does my number look big in this?".

This one we need to analyze an incoming number to see if it is a Narcissistic number. This is the first time hearing about such a number for me, but basically you sum all the digits after they have been raised to the power of the number of digits in the number. If this result equals the number, then it is a narcissistic number. ¯\_(ツ)_/¯ but ok.

Let's break this down into smaller problems.

• Iterate over the digits
• Determine how many digits in the input
• Raise each digit by the number of digits
• Sum these result of these operations
• Compare the sum to the original number
• Return boolean

A lot of steps, but each one is pretty easy on their own.

Let's give it a go starting with the iteration. We have done this quite a few times by now you should have this down.

You may try to do a simple for loop over the digits but realized you can not do this to a number.

def narcissistic( value ):
    for digit in value:
        pass

Let's turn it into a string first.

def narcissistic( value ):
    for digit in str(value):
        pass

Let's get the length of the digits next, and store that.

def narcissistic( value ):
    number_of_digits = len(str(value))

    for digit in str(value):
        pass

Next we should want to keep some sort of variable to work up our sum.

def narcissistic( value ):
    number_of_digits = len(str(value))
    sum = 0

    for digit in str(value):
        pass

We don't have any usable output to test with, so let's keep going. At this point let's start doing something in our for loop, raise the digit to the power of number_of_digits.

def narcissistic( value ):
    number_of_digits = len(str(value))
    sum = 0

    for digit in str(value):
        sum += int(digit)**number_of_digits

We have to convert the digit back to an int because we previously casted it as a string. ** is the operator for raising to the nth power. += is a short hand operator (syntactical sugar) for x = x + y removing the second x from the equation.

One thing I want to touch on here is the naming of variables. I do not like the python standard for variables using an underscore between words, I much prefer camelCase. You need to use the accepted standard for the language you are working. It is important for consistency and working with others code.

I think we are just about done, we just have one last thing. Let's return an evaluation if our sum matches the input.

def narcissistic( value ):
    number_of_digits = len(str(value))
    sum = 0

    for digit in str(value):
        sum += int(digit)**number_of_digits
        
    return sum == value

Looking good! Let's test against the full suite of tests.

Still good, so we have a working solution.

Let's look at the ideal solutions.

I want to talk a bit about the first one. It is obviously a lot smaller than ours. Is it better though? Maybe, maybe not.

It does use a list comprehension with a list as a return, this is very pythonic and preferred when writing Python code. It makes for a very concise function but we have two issues.

It's a bit more difficult to read and it is slower than our solution (potentially).

Both solutions require us to calculate the number of digits for the input value. If this operation is slow and expensive, the top solution repeats this operation for every digit in the input. This could cause a noticeable performance problem if the code is executed frequently.

Our solution first completes this operation and stores it. In this case, the len() function is very fast and won't create any noticeable overhead. What if this function is run 1M times in a row? Even a simple function like len() run 2-10+ times for every use of this function can slow things down a bit.

In this situation, it likely won't matter at all, but this is something you need to keep in mind when trying to optimize your code. You also don't want to spend too much time trying to optimize your code on your first pass. Just avoid obvious performance traps. After all "Premature optimization is the root of all evil". Although this statement has been challenged and why I like to suggest avoiding obvious performance traps and try to always think ahead of where you may have issues.

Code Wars Python Challenge Series

• How to become a better programmer with Code Wars
• Vowel Count
• Array.diff
• RGB to Hex
• Square Every Digit
• Valid Parentheses

---

Securely chat with me on Keybase

Why you should vote me as witness

i