Sum two integers, unless they are the same, in which case return double their sum

Question

I was doing a simple problem on codingbat and testing out my python. The problem was:

Given two int values, return their sum. Unless the two values are the same, then return double their sum.

sum_double(1, 2) → 3
sum_double(3, 2) → 5
sum_double(2, 2) → 8

My solution was:

def sum_double(a, b):
  if a is b:
    return 2 * (a + b)
  else:
    return a+b

and it worked just fine. However, when I checked the solution the answer they had was:

def sum_double(a, b):
  # Store the sum in a local variable
  sum = a + b

  # Double it if a and b are the same
  if a == b:
    sum = sum * 2
  return sum

But this seems to Java-y to me. Am I right to believe that my code is more pythonic? Or was their answer a better way to write code in python?

Answer 1

The existing answers mostly have just said is is wrong here. Which it undoubtedly is. The reason it's bad to use here is if you pass 257 and above, or -6 and below, you may get incorrect output. The best way to show how it's bad is to ask you what the output of the following are:

sum_double(2, 2)
sum_double(1 + 1, 2)
sum_double(257, 257)
sum_double(256 + 1, 257)

Simple! Surely it's 8, 8, 1028 and 1028, right? No, it's actually, 8, 8, 1028 and 514.
This is known and expected behaviour:

The current implementation keeps an array of integer objects for all integers between -5 and 256, when you create an int in that range you actually just get back a reference to the existing object.

Other than that both are fine, and I wouldn't really fret over which is 'better', this is as both are clear and understandable. Which is all your code needs to be.
A function that would be un-pythonic, as it's not clear could be:

def sum_double(a, b):
    return (a + b) * ((a == b) + 1)

Answer 2

Well, if I'd have to choose:

• your way of comparing two integers is wrong (a is b). This is unusual and it should NOT become a habit. Just use a == b.
• their solution also use a variable (sum) which in my opining is useless. I'd just return the needed calculus.

I'd do it this way:

def sum_double(a, b):
    return a + b if a != b else 2 * (a + b)

This is for me a pythonic way of returning the sum of two numbers using an inline return statement.

Answer 3

First, the is operator is for identity comparison, the == is for equality comparison. So the a == b part is more explicit (which is more pythonic).

Also, in your solution you do the sum twice, this is against DRY.

In the second code, it is bad that they name a variable after a built-in function sum. This should never be done (unless it is intended). In this scope the built-in function sum is overridden and can't be used.

Answer 4

One of the most important things is readability.

def sum_double(a, b):
  if a == b:
    return 2 * (a + b)
  else:
    return a+b

This is the best way to write your program in this context. Use of a variable is unnecessary, and although their solution gets rid of the redundant (a+b), their code is further from the intuition that comes from the specification.

The ultimate goal is to get that perfect mixture of brief, intuitive, clear, and efficient. It's a lot to juggle but luckily efficiency isn't very relevant here.

I saw some mention of inline statements. Don't get me wrong, I like inline statements as much as the next guy, but since this function is part of the "main idea" of the program it's better to write it out and keep it clear.

If the function is not that important and is clarified in naming/comments/documentation then you could probably get away with prioritizing the inherit desire that many python programmers have to golf over readability.

Answer 5

Aside from what others have said, I think it's better style not to use an else in cases like this, and just count on the fact that at the end of the function should be a return statement:

def sum_double(a, b):

    total = a + b
    if a == b:
        return 2 * total
    return total

This is effectively the same, but it's clearer at first glance to see that something is always returned.

The solution may consider it more Pythonic to have one return statement, but it can be better to have separate ones as you showed. Especially if the logic can become more complex, what if you had to return 0 if one of the numbers was zero, or if there's further calculations to do when the numbers are not equal? For this reason, having 2 returns (as you did) makes code neater.

Also, please use 4 spaces for indentation. It's the recommended amount and easier to read.

Answer 6

I would probably do it this way. I find that it conveys the idea most clearly while keeping it short and readable. (Flat is better than nested.)

def sum_double(aa, bb):
    mod = 2 if aa==bb else 1
    return mod * (aa + bb)