trjhtr

A related Java question got me curios.

All unique combinations (not permutations) of 3 values that sum to a target from a list of integers.

Values can duplicate in the list but are only used once.

By sorting the input the evaluation is able to take shortcuts.

Feedback on both code and speed please.

Assume all input and sum >= 0.

public static List<List<int>> FindThreeSum(List<int> input, int sum = 24)

In general it looks OK to me, but you could maybe consider the following:

1) Return a IEnumerable<int> instead of List<List<int>> and then yield the positive results when found:

 ...
 else if (sumSoFar == sum)
 
 yield return new int iValue, jValue, kValue ;
 ...

2) The names sumI, sumJ, sumK are somewhat misleading because they aren't sums. Better names would be valueI, -J, -K

 int valueI;
 int valueJ;
 int valueK;

3) For the fun of it, you could consider: Because you basically do the same same loop nested three times, it could be a candidate for a recursive function iterating over each addend and yielding all the positive sums. In that way you could generalize the algorithm to handle any number of addends...