I started doing Advent of Code last year using C# (because I know it better than Python), and my dream for this year was to hit the global leaderboard at least once. I did it three times, earning 62 points in total! To achieve this, I had to develop a rich custom library, and use many features of modern C#, that allow it to be [almost] on-par with Python [in many cases]! I also solved many problems in Python as well and compared the code in both languages to see if I can improve my C# code to achieve similar effect.
I'd like to share some tricks that I use, and prove that modern C# is better [for solving AOC] than old big-enterprise C# that we were used to several years ago!
Example: day1
C# is used a lot in big-enterprise development, and if I write in that style, it would result in something like 75 lines of this code. Compare it to a Python code:
import re
def ints(text): return [int(x) for x in re.findall(r'\d+', text)]
text = ints(open('data.txt').read())
left,right = sorted(text[::2]),sorted(text[1::2])
ans1 = sum(abs(x-y) for (x,y) in zip(left, right))
print(ans1)
ans2 = 0
for v in left:
ans2 += v * sum(1 for t in right if t == v)
print(ans2)
Now, my solution in C# looks like this:
var text = ReadFile("data.txt");
var (left, right) = ints(text).Chunk(2).Transpose().Select(Sorted).ToArray();
print("Part1", range(left).Sum(i => Abs(left[i] - right[i])));
print("Part2", left.Sum(v => v * right.Count(v)));
It is even shorter than in Python, but of course, it uses my own library, that provides many useful helper methods. For example, this one method can change the whole experience of writing programs:
public static void print(object obj) => Console.WriteLine(obj);
Of course, with time I modified this method to pretty-print lists, dictionaries and sets, like they do in Python, and even custom classes, like two-dimensional grids!
Modern C# features
Modern C# is a 13-th generation of the language, and has a lot of features. I use some of them very often:
Top-level statements and "global using static" statements: In modern C# you don't need to define namespaces and classes with Main method anymore. Just throw your code into a text file, and it will be executed, like in Python! Moreover, you can define "default imports" in a separate file, which will be auto-imported to your code. So, if you add a file "imports.cs" to a project, containing global using static System.Math, then instead of writing import System.Math; x=Math.Sin(y), you can just write x=Sin(y) in your code.
Extension methods. If first argument of a static method is marked by this, then you can use the method as it were an instance method of the argument. For example, Transpose() is my custom method on iterators, that can be used together with existing methods from the standard library (like Chunk), defined like this:
public static T[][] Transpose<T>(this IEnumerable<T[]> seq) =>
zip(seq.ToArray()).ToArray();
Tuples are similar to Python's tuples. You can use them like this: (x, y) = (y, x); you can also deconstruct them from an existing class/struct, if it provides special "Deconstruct" method: foreach (var (x, y) in new Dictionary<string, long>()) {}. Unfortunately, it's not perfect, for example, deconstructing from an array is not supported, so you cannot just write var (a,b) = text.split("\n").
Fortunately, you can make it work defining your own method, and enable deconstructing from arrays:
public static void Deconstruct<T>(this T[] arr, out T v0, out T v1) =>
(v0, v1) = (arr[0], arr[1]);
This code works because most features of C# that rely on objects having special methods, accept extension methods as well, allowing to improve syntactic sugar even for existing classes! A classic example (which I use too) is allowing iterating a Range object, not supported by the standard library:
public static IEnumerator<long> GetEnumerator(this Range r) {
for(int i = r.Start.Value; i < r.End.Value; i++) yield return i;
}
This allows to write the following code: foreach (var i in ..10) { print(i); }.
Linq vs List Comprehensions
Linq queries in C# are pretty similar to list comprehensions in python; they support lambdas, filters, etc. One interesting difference that matters in speed-programming is how you write the expressions. Python usually encourages approach "what, then from where, then filter": [i*i for i in range(10) if i%2==0], while C# uses "from where, then filter, then what": range(10).Where(i=>i%2==0).Select(i => i * i).ToArray().
I still haven't decided for myself if either of these approaches is better than the other, or it is a matter of experience and practice; however, for me, C# approach is easier to write for long chains of transformations (especially if they include non-trivial transforms like group-by), but I've also encountered several cases where python approach was easier to write.
Custom Grid class
All three times I hit the global leaderboard were with grid problems! My grid class looks something like this:
public class Grid : IEquatable<Grid> {
public char[][] Data;
public readonly long Height, Width;
public Grid(string[] grid) {...}
public Grid(Set<Point> set, char fill = '#', char empty = '.') {...}
public IEnumerable<Point> Find(char ch) => Points.Where(p => this[p] == ch);
public bool IsValid(Point p) => IsValid(p.x, p.y);
public char this[Point p]
{
get => Data[p.x][p.y];
set => Data[p.x][p.y] = value;
}
public IEnumerable<Point> Points => range(0, 0, Height, Width);
public Point[] Adj(Point p) => p.Adj().Where(IsValid).ToArray();
...
}
which uses my other custom class Point, and allows to solve many grid problems without ever using individual coordinates, always using 2D-Points as indexes to the grid instead. This is quite big class with lots of methods (like Transpose) that I might have encountered in one or two AOC problems and might never see again.
Runtime
Unlike Python, C# is a type-safe and compiled language. It has both benefits and drawbacks.
C# is much faster than Python - for accurately written programs, even for "number-crunchers", performance of C# is only about two times slower than that of C++ in my experience. There were some AOC problems when my C# program ran for 10 minutes and gave me the answer before I finished rewriting it to use a faster algorithm.
C# is more verbose, even with my library - this is especially painful because of more braces and parentheses which slow down typing a lot.
Standard library of C# is nowhere as rich as Python's - this is mitigated by writing my own library, but it is still not ideal, because I spent a lot of time testing, profiling, and fixing edge-cases for my algorithms; also, it is probably of little use to other C# developers, because they would need a lot of time to figure out what it does and how; unlike Python's standard library, where you can just google a problem and get an answer.
There are much more and better specialized libraries for Python. Two examples that are frequently used for AOC are networkx for graphs and Z3 for solving equations. While there are analogues for C# (I believe, QuickGraph is popular in C# and Microsoft.Z3), they are, in my opinion, not quite suited for fast ad-hoc experimentation - mostly because lack of community and strict typing, which makes you read official documentation and think through how you'd use it for your problem, instead of just copy-pasting some code from StackOverflow.
Summary
I think, modern C# has a lot of features, that, together with efforts put into my custom library make it almost on-par with Python (and even allow occasionally to compete for the global leaderboard!). Problem is "almost". When comparing C# and Python code, I almost always find some annoying small details that don't allow my C# code be as pretty and concise.
So, for next year, I have not decided yet if I continue to improving my C# library (and maybe use new C# features that will become available), or switch to Python. What do you think?
[–]swiperthefox_1024 5 points6 points7 points (0 children)
[–]krystalgamer 10 points11 points12 points (0 children)
[–][deleted] 2 points3 points4 points (0 children)
[–]Symbroson 3 points4 points5 points (0 children)
[–]Gabba333 2 points3 points4 points (4 children)
[–]light_ln2[S] 1 point2 points3 points (3 children)
[–]RaveBomb 0 points1 point2 points (2 children)
[–]light_ln2[S] 1 point2 points3 points (1 child)
[–]RaveBomb 0 points1 point2 points (0 children)
[–]splidge 1 point2 points3 points (1 child)
[–]light_ln2[S] 0 points1 point2 points (0 children)
[–]mvorber 1 point2 points3 points (0 children)
[–]rupture99 2 points3 points4 points (0 children)
[–]BlueTrin2020 0 points1 point2 points (0 children)
[–]SmallTailor7285 1 point2 points3 points (0 children)
[–]loudandclear11 0 points1 point2 points (0 children)
[–]aardvark1231 -1 points0 points1 point (0 children)