1. I think a more consistent approach would he to not count lines, but filesizes after the code has been minimized with a specific minimizer. I could write everything in one line in many languages, so lines isn’t very clever.

2. The code has to be compiled and run on a specific architecture and with specific test input (we don’t know if the AoC-example-data is always the same in size or resulting computanional complexity.

3. The final metric could be: [minified filesize] * [code execution time] * [problem solving time].

Some of the challenges feasably could be solved with a pen and paper amd a keen eye, giving a line count of 0.

#nocode :D

Lines of code can be arbitrarily reduced, and seconds to solve depends to a large extent on how good my hardware is. So both metrics are useless, and multiplying them makes a useless-squared metric.

I love it!

Here are my stats for the solutions so far (with no optimisation beyond the initial solution):

+-----+-----------+-------+---------------+
| Day | Time (s)  | Lines | line-seconds  |
+-----+-----------+-------+---------------+
|  1  |  0.003    |   35  |   0.098       |
|  2  |  0.001    |   47  |   0.042       |
|  3  |  0.006    |   60  |   0.348       |
|  4  |  0.003    |   41  |   0.115       |
|  5  |  0.077    |   74  |   5.708       |
|  6  |  0.000    |   45  |   0.001       |
|  7  |  0.005    |   87  |   0.395       |
|  8  | 10.175    |   60  | 610.476       |
|  9  |  0.004    |   31  |   0.128       |
| 10  |  0.084    |  103  |   8.634       |
| 11  |  0.240    |   49  |  11.771       |
| 12  |  2.448    |   93  | 227.633       |
| 13  |  0.009    |   83  |   0.707       |
+-----+-----------+-------+---------------+