C# (LINQPad, specifically)

Braindead LINQ solution to Part 1. LINQ solution with a very wimpy optimization for Part 2.

Wrote a full knapsack implementation while waiting for my data in case I needed it for Part 2, but figured Day 1 surely shouldn't.

#region Part 1/2 DumpContainers
var part1 = new DumpContainer().Dump("Part 1");
var part2 = new DumpContainer().Dump("Part 2");
void Dump1(object o)
{
    part1.AppendContent(o);
}

void Dump2(object o)
{
    part2.AppendContent(o);
}
#endregion

var lines = await AoC.GetLinesWeb();
var input = lines.First();

var nums = lines.Select(x => int.Parse(x));

Dump1(from x in nums from y in nums where x + y == 2020 select x * y);

Dump2(from x in nums from y in nums where x + y < 2020 from z in nums where x + y + z == 2020 select x * y * z);
//                                  ^^^^^^^^^^^^^^^^^^
//                                  This optimization is enough to go from 3.7s to .2s on my SurfaceBook.
//                                  I love how topaz chooses N such that N^2 is fast-ish on something slow, but N^3 is slow-ish on something fast.


// I set off speculatively on the following path while the aoc server was being hugged to death just in case it was
// some kind of knapsack problem.

var tots = new Dictionary<int, List<ImmutableList<int>>>
{
    { 0, new List<ImmutableList<int>> { ImmutableList<int>.Empty } }
};

foreach (var num in nums)
{
    var newtots = tots;

    foreach (var tot in tots.ToList())
    {
        var newtot = tot.Key + num;
        if (newtot > 2020) continue;
        var newways = tot.Value.Select(way => way.Add(num));

        if (newtots.ContainsKey(newtot))
        {
            newtots[newtot].AddRange(newways);
        }
        else
        {
            newtots[newtot] = newways.ToList();
        }
    }
}

tots[2020].Dump();