Here's my solution for the Leet Code's Two Sum problem -- would love feedback on (1) code efficiency and (2) style/formatting.

Problem:

Given an array of integers, return indices of the two numbers such
that they add up to a specific target.

You may assume that each input would have exactly one solution, and
you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9, return [0, 1].

My solution:

def twoSum(nums, target):

    """

    :type nums: List[int]

    :type target: int

    :rtype: List[int]

    """



    num_lst = list(range(len(nums)))



    for indx, num in enumerate(num_lst):

        for num_other in num_lst[indx+1:]:

            if nums[num] + nums[num_other] == target:

                return [num, num_other]

            else: 

                continue

    return None

Code Style

• 
  

  Your code contains a few lines that accomplish nothing and obfuscate your intent:

  
  
  

      else: 
  
          continue
  
  

  
  
  

  If the conditional is false, you'll automatically continue on the next iteration without having to tell the program to do that.

  
  
  

      return None
  
  

  
  
  

  All Python functions implicitly return None, so there's nothing gained in explicitly typing this out.

  
  


• 
  

  num_lst = list(range(len(nums))) effectively generates a list of all the indices in the nums input list. Then, you immediately enumerate this list, which produces pairs of identical indices indx, num. If all you're attempting to do is iterate, this is significant obfuscation; simply call enumerate directly on nums to produce index-element tuples:

  
  
  

  def twoSum(self, nums, target):
  
      for i, num in enumerate(nums):
  
          for j in range(i + 1, len(nums)):
  
              if num + nums[j] == target:
  
                  return [i, j]
  
  

  
  
  

  This makes the intent much clearer: there are no duplicate variables with different names representing the same thing. It also saves unnecessary space and overhead associated with creating a list from a range.

  
  


• Following on the previous item, indx, num and num_lst are confusing variable names, especially when they're all actually indices (which are technically numbers).

Efficiency

• 
  

  This code is inefficient, running in quadratic time, or O(n²). I'm surprised Leetcode permits this to pass. The reason for this is the nested loop; for every element in your list, you iterate over every other element to draw comparisons. A linear solution should finish in ~65 ms, while this takes ~4400 ms.

  
  
  

  Here is a clean, efficient solution that runs in O(n) time:

  
  
  

  hist = {}
  
  
  
  for i, n in enumerate(nums):
  
      if target - n in hist:
  
          return [hist[target - n], i]
  
      hist[n] = i
  
  

  
  
  

  How does this work? The magic of hashing. The dictionary hist offers instant O(1) lookup time. Whenever we visit a new element in nums, we check to see if its sum complement is in the dictionary; else, we store it in the dictionary as a num => index pair.

  
  
  

  This is the classic time-space tradeoff: the quadratic solution is slow but space efficient, while this solution takes more space but gains a huge boost in speed. In almost every case, choose speed over space.

  
  
  

  For completeness, even if you were in a space-constrained environment, there is a fast solution that uses O(1) space and O(n log(n)) time. This solution is worth knowing about for the practicality of the technique and the fact that it's a common interview follow-up. The way it works is:

  
  
  
  
  
  1. Sort nums.
  
  
  2. Create two pointers representing an index at 0 and an index at len(nums) - 1.
  
  
  3. Sum the elements at the pointers.
     
     
     
     
     • If they produce the desired sum, return the pointer indices.
     
     
     • Otherwise, if the sum is less than the target, increment the left pointer
     
     
     • Otherwise, decrement the right pointer.
     
     
     
     
  
  
  4. Go back to step 3 unless the pointers are pointing to the same element, in which case return failure.
  
  
  
  



• Be wary of list slicing; it's often a hidden linear performance hit. What you're doing here appears safe, because Python should know not to copy the entire list from num_lst[indx+1:] onward, but it's worth avoiding if possible. Removing this slice as the nested loop code above illustrates doesn't improve the quadratic time complexity, but it does reduce overhead.

num_lst = list(range(len(nums)))



for indx, num in enumerate(num_lst):

I'm not sure if I'm missing something, but I think not. I ran this code

nums = [2,5,7,9]

num_lst = list(range(len(nums)))

list(enumerate(num_lst))



output : [(0, 0), (1, 1), (2, 2), (3, 3)]

So why do you create the list and then enumerate it? Maybe what you want to do is simply : enumerate(nums) then enumerate(nums[index+1:]) on your other loop? A simpler way would be to only use the ranges, as I'll show below.

Also, given your input, there's a possibility that a single number would be higher than the target, in this case you shouldn't make the second iteration.

You also don't need the else: continue , as it's going to continue either way.

I'd end up with :

def twoSum(nums, target):

    """

    :type nums: List[int]

    :type target: int

    :rtype: List[int]

    """



    for i1 in range(len(nums)):

        if nums[i1] >= target:

            continue



        for i2 in range(i1, len(nums)):

            if nums[i1] + nums[i2] == target:

                return [i1, i2]



    return None

This offers a potential performance boost, and in my opinion the code is clearer.