Advent Of Code 2020, day 1, find desired sum and multiply the addends you can find the challenge here for more details, but the subject says it all;
Check a provided list of entries for 2 numbers which sum to 2020, return the product of those addends.
I waited until the event was over to keep things fair.


/*This will search for 2 numbers in the `list that sum to `target` 
  Assumption;
  * We only get integers in a string that are new-line separated
  * The sum is there, so we dont stop searching even if it doesnt make sense
*/
function findTargetSum(listAsString, target){
  const list = entries.split('\n').map(s =&gt; s*1);
  const set = new Set(list);
  for (const i of set) {
     if(set.has(target - i)){
       return i * (target - i);
     }
  }
}

function findTargetSum3(listAsString, target){
   
  const list = entries.split('\n').map(s =&gt; s*1);
  const set = new Set(list);
  for (const i of set){
    for(const i2 of set){
      if(i != i2){
        if(set.has(target -i - i2)){
          return i * i2 * (target -i - i2);
        }
      }
    }
  }
}

const entries = `1780
1693
1830
1756
1858
1868
1968
1809
1996
1962
1800
1974
1805
1795
170
1684
1659
1713
1848
1749
1717
1734
956
1782
1834
1785
1786
1994
1652
1669
1812
1954
1984
1665
1987
1562
2004
2010
1551
961
1854
2005
1883
1965
475
1776
1791
262
1912
1227
1486
1989
1857
825
1683
1991
1875
1982
1654
1767
1673
1973
1886
1731
1745
1770
1995
1721
1662
1679
1783
1999
1889
1746
1902
2003
1698
1794
1798
1951
1953
2007
1899
1658
1705
62
1819
1708
1666
2006
1763
1732
1613
1841
1747
1489
1845
2008
1885
2002
1735
1656
1771
1950
1704
1737
1748
1759
1802
2000
1955
1738
1761
1765
1853
1900
1709
1979
1911
1775
1813
1949
1966
1774
1977
1757
1992
2009
1956
1840
1988
1985
1993
1718
1976
1078
1997
1897
1792
1790
1801
1871
1727
1700
1485
942
1686
1859
1676
802
1952
1998
1961
1844
1808
1703
1980
1766
1963
1849
1670
1716
1957
1660
1816
1762
1829
526
359
2001
1874
1778
1873
1511
1810
1699
1970
1690
1978
1892
1691
1781
1777
1975
1967
1694
1969
1959
1910
1826
1672
1655
1839
1986
1872
1983
1981
1972
1772
1760`;

console.log(findTargetSum(entries, 2020));
console.log(findTargetSum3(entries, 2020));
Looks mostly fine, though there are a few issues:
Argument bug/typo You're referring to top-level variable entries inside the function instead of to the listAsString argument.
Match numbers? Even if it's said that the input will contain line-separated numbers, I'd feel safer matching numeric characters instead of splitting by newlines. It'll be more robust if the input happens to not be formatted perfectly correctly, or at least makes the intent (to extract an array of only digit characters from the input) a bit clearer, without relying on the description.
Maybe use Number? Once you have an array of digit characters, you turn them all into numbers with .map(s =&gt; s*1). I think the intent - to cast to numbers - would be a bit clearer by using .map(Number) instead.
i is conventionally used to indicate the index being iterated over. Here, i isn't being used as the index, but as the element being iterated over. Maybe use num instead?
target - i can be saved into a variable instead of repeating it twice, if you want.
Counting bug If the target sum happens to be a sum of two of the same number, eg: 1010 + 1010, those will be matched even if the input only contains one of those numbers, since you're using a Set which doesn't differentiate one occurrence from multiple.
To fix this, you could add an index check to the original array if the two numbers happen to be the same (as I've done below), or count up occurrences into an object, or something like that.

With findTargetSum3, in addition to the above:
Computational complexity is unnecessarily large The first approach is O(n), which is good. This second approach is O(n ^ 2), since you're checking every element against every other element. I'd ditch findTargetSum3 completely.
Prefer strict equality over loose equality - yes, the types are surely the same, so it doesn't make a difference in the logic, but strict equality with !== and === is easier to understand at a glance due to the lack of strange coercion rules. Whenever I see sloppy comparison (especially in professional code), I think: &quot;Why isn't strict comparison being used, is there some possible type coercion weirdness going on that wasn't explicit?&quot; Better to be consistent and use strict equality comparison everywhere.


function findTargetSum(listAsString, target){
  const numbers = listAsString.match(/\d+/g).map(Number);
  const set = new Set(numbers);
  for (const num of set) {
    const otherNum = target - num;
    if (
      set.has(otherNum) &amp;&amp;
      (num !== otherNum || numbers.indexOf(num) !== numbers.lastIndexOf(otherNum))
    ) {
       return num * otherNum;
    }
  }
}

const entries = `1780
1693
1830
1756
1858
1868
1968
1809
1996
1962
1800
1974
1805
1795
170
1684
1659
1713
1848
1749
1717
1734
956
1782
1834
1785
1786
1994
1652
1669
1812
1954
1984
1665
1987
1562
2004
2010
1551
961
1854
2005
1883
1965
475
1776
1791
262
1912
1227
1486
1989
1857
825
1683
1991
1875
1982
1654
1767
1673
1973
1886
1731
1745
1770
1995
1721
1662
1679
1783
1999
1889
1746
1902
2003
1698
1794
1798
1951
1953
2007
1899
1658
1705
62
1819
1708
1666
2006
1763
1732
1613
1841
1747
1489
1845
2008
1885
2002
1735
1656
1771
1950
1704
1737
1748
1759
1802
2000
1955
1738
1761
1765
1853
1900
1709
1979
1911
1775
1813
1949
1966
1774
1977
1757
1992
2009
1956
1840
1988
1985
1993
1718
1976
1078
1997
1897
1792
1790
1801
1871
1727
1700
1485
942
1686
1859
1676
802
1952
1998
1961
1844
1808
1703
1980
1766
1963
1849
1670
1716
1957
1660
1816
1762
1829
526
359
2001
1874
1778
1873
1511
1810
1699
1970
1690
1978
1892
1691
1781
1777
1975
1967
1694
1969
1959
1910
1826
1672
1655
1839
1986
1872
1983
1981
1972
1772
1760`;
console.log(findTargetSum(entries, 2020));
console.log(findTargetSum(`1
3
3
5`, 6));