Two Sum Leetcode

Question

Looking for some feedback on the Two Sum LeetCode problem. Looking for feedback on code style in general, use of var, variable naming and initialization, return placement, and any other feedback or optimizations I could make.

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

using System.Collections.Generic;

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
        var numsDictionary = new Dictionary<int, int>();

        int complement = 0;
        for(int i=0; i < nums.Count(); i++) 
        {            
            complement = target - nums[i];
            int index = 0;
            if(numsDictionary.TryGetValue(complement, out index))
            {
                int[] twoSumSolution = {index, i};
                return twoSumSolution;
            }                                                         

            if(!numsDictionary.ContainsKey(nums[i]))
            {
                numsDictionary.Add(nums[i], i);
            }            
        }

        return null;
    }
}

Answer 1

• Most C# developers will place opening braces on a new line. If you do this as well then you make it easier to read the code by others.

• complement and index should use var "type" as well

• twoSumSolution isn't really needed and is only adding noise to the code.

• I like to use if (bool == false) instead of if (!bool) because I can grasp it at first glance without wondering wether I see a exclamation sign or not.

• Instead of using the Count() extension method I prefer using the Length property for arrays. Using Count() will envolve a soft cast to ICollection<T> and a null check which just isn't needed.

• checking if complement > 0 will remove unneeded calls to TryGetValue(), but has implications on certain inputs like target = 0 and an array [-3, 7, 3].

Implementing the mentioned points will lead to

public int[] TwoSum(int[] nums, int target)
{
    var numsDictionary = new Dictionary<int, int>();

    var complement = 0;
    for (var i = 0; i < nums.Length; i++)
    {
        complement = target - nums[i];
        var index = 0;
        if (complement > 0 && numsDictionary.TryGetValue(complement, out index))
        {
            return new int[] { index, i };
        }

        if (numsDictionary.ContainsKey(nums[i]) == false)
        {
            numsDictionary.Add(nums[i], i);
        }
    }

    return null;
}

Answer 2

Some minor points:

1) You don't really need the complement variable, so just do the math in the call to TryGetValue().

2) If int[] nums are all positive you may continue the loop if nums[i] > target.

3) It is stated that there is only one solution per input, so you can skip the check if (!numsDictionary.ContainsKey(nums[i])). This will never be true for the nums that add up to the target. As for the rest of nums it doesn't matter.

---

All in all it could be reduced to this (for C# 7.0):

public int[] TwoSumReview(int[] nums, int target)
{
  Dictionary<int, int> numsDictionary = new Dictionary<int, int>();

  for (int i = 0; i < nums.Length; i++)
  {
    int num = nums[i];

    // You can uncomment this if nums are all positive
    //if (num > target) { continue; }

    if (numsDictionary.TryGetValue(target - num, out int index))
    {          
      return new [] { index, i }; 
    }

    numsDictionary[num] = i;
  }

  return null;
}

Answer 3

Dictionary can be initialized to an initial capacity
No purpose to index = 0

public static int[] TwoSum(int[] nums, int target)
{
    int numsLength = nums.Length;
    if(numsLength <= 1)
    {
        return null;
    }
    Dictionary<int, int> numsDictionary = new Dictionary<int, int>(numsLength);
    int complement;
    int index;
    int num;
    numsDictionary.Add(nums[0], 0);
    for (int i = 1; i < numsLength; i++)
    {
        num = nums[i];
        complement = target - num;
        if (numsDictionary.TryGetValue(complement, out index))
        {
            return new int[] { index, i };
        }
        if (!numsDictionary.ContainsKey(num))
        {
            numsDictionary.Add(num, i);
        }
    }
    return null;
}