3
\$\begingroup\$

Here is my code that finds the number of digits in a given integer (either positive or negative). The code works and results in expected output.

'''
Program that returns number of digits in a given integer (either positive or negative)
'''
def ndigits(x):
    # Assume for the input 0 the output is 0
    if(x == 0):
        return 0
    if(abs(x) / 10 == 0):
        return 1
    else:
        return 1 + ndigits(x / 10)
\$\endgroup\$
  • \$\begingroup\$ def ndigits(x): return sum(int(i) for i in str(x)) Here are a few other solutions stackoverflow.com/questions/14939953/…. \$\endgroup\$ – N3buchadnezzar Jun 30 '16 at 8:20
  • \$\begingroup\$ @N3buchadnezzar: He is not interested in the sum of the digits only in the number of digits. But the solutions can be adapted to this difference. \$\endgroup\$ – MrSmith42 Jun 30 '16 at 10:14
  • \$\begingroup\$ @MrSmith42 def ndigits(x): return 1 + int(log(x, 10) Something I am still missing? \$\endgroup\$ – N3buchadnezzar Jun 30 '16 at 13:35
  • \$\begingroup\$ @N3buchadnezzar: The link to the 'few other solutions' is a link to where the sum of the digits is calculated. \$\endgroup\$ – MrSmith42 Jul 1 '16 at 8:28
1
\$\begingroup\$

pro:

  • code is clean and easy to understand

con:

  • a recursive solution may not be optimized to a loop by your interpreter so there might be a lot of memory (stack) waste because of the recursion overhead. (So you could implement it as a loop instead of a recursion)
  • You do not need the if(abs(x) / 10 == 0) branch. So to simplify your code you could remove it.

Simplified recursive code:

def ndigits(x):
    # Assume for the input 0 the output is 0
    if(x == 0):
        return 0
    else:
        return 1 + ndigits(abs(x) / 10)

Simplified tail-recursive code: end-recursive methods are likely to be detected by the interpreter and transformed to a loop. So this code might be faster and may nor waste memory.
For more information see wikipedia Tail call

def ndigits(x):
    return ndigits_(0, abs(x))

def ndigits_(s,x):
    if(x == 0):
        return s
    else:
        return ndigits(s+1, x / 10)
\$\endgroup\$
  • \$\begingroup\$ The python interpreter doesn't do that sort of optimization period. There is some sort of work going on in that area, but that is the case right now. \$\endgroup\$ – TheBlackCat Jun 30 '16 at 15:57
  • \$\begingroup\$ @TheBlackCat: tail recursion is a very common optimization, so we can expect it also from the python interpreter in the near future. But good to know that it is not the case yet. \$\endgroup\$ – MrSmith42 Jul 1 '16 at 8:26
  • \$\begingroup\$ Not going to happen. Guido has explicitly rejected adding tail recursion to Python. \$\endgroup\$ – TheBlackCat Jul 1 '16 at 15:05

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.