Algorithm to determine which numbers in a list are the sum of a given number

This is a knapsack problem. Refer here https://en.m.wikipedia.org/wiki/Knapsack_problem

Depends. If you want it fast, you can use a greedy(ish) algorithm: (pseudo code)

n = answer; // what you want the numbers to add up to be. 
numbers = [1, 2, 40, 39,....]; //the candidates. 
addList = Array[][];
addList[0] = numbers;
level = 0;
while(true){
    for (number in numbers){
         currnum = addlist[level][i] + number;
         if(currnum == n){
             return true; // or what ever you want to return
         } else if (currnum < n){
              addlist[level+1].append(currnum);
         }
    }
    if (addlist[level+1].length ==0){
          return false; // it will never add up to the value n. 
    }
    level++;
}

This is strictly pseudo code, I'm mixing arraylist and array a bit just for readability.

The only numbers that can be discarded are the ones bigger than the goal number, as any other combination of smaller numbers might sum up to the desired amount.

To find which ones (if any) you will have to check all possible combinations of remaining numbers.

The most simple approach would be to recursively traverse the list, once adding the current number and once leaving it out, pruning the current branch if the sum already exceeds the goal value.

An example (perl) implementation for your problem instance is given in the snippet below:

my @numbers = (4, 5, 10, 10, 23, 67, 889, 150, 50);
my $length = scalar @numbers; # length of the list


sub visit {
  my ($i, $sum, $goal, $items) = @_;
  # i: current index, sum: sum of numbers currently selected
  # goal: goal value to reach, items: list of numbers currently selected 

  # we found a solution !
  print join (", ", @$items) . "\n" if $sum == $goal;

  return if $i >= $length || $sum >= $goal;

  # continue without adding
  visit ($i+1, $sum, $goal, $items);

  # continue with adding
  visit ($i+1, $sum + $numbers[$i], $goal, [$numbers[$i], @$items]);
}

visit (0, 0, 200, []); it will report the pair 50, 150 as expected.

Note, that no attempt to remove duplicates was made, so calling with goal value of 77 visit (0, 0, 77, []); besides the triple 50, 23, 4 the pair 67, 10 will be listed twice, since there are two instances of 10s there.

Oh, and don't trust any greedy algorithms suggested in other posts, as they are doomed to fail solving knapsack problems.