Two weeks ago we had a sneak peek on the Tuenti Challenge 9 statistics, and today we come with more numbers!
This year’s edition included 20 challenges, like the first six editions (the other two came with only 15 challenges, but harder ones!). There was an increase in non-algorithmic problems, since 7 problems (a third of them!) required you to either connect to a daemon, analyze a JAR file or even restore a MariaDB database.
In the sneak peek we talked about how the challenge 8 was the first stopper, but there were three more problems with less submits than the next one: challenges 10, 14 and 17, all of which were non-algorithmic! The latter had the highest percentage of skips of all problems, since 14 participants skipped it and only 4 managed to solve it! (we expected that this could happen, and that’s why it was the last problem you could skip).
As you can see in the previous graph, challenges 11 and 13 had the highest percentage of wrong solutions. They required you to write a lot of code in order to solve them, so there was a high chance of having small mistakes in the algorithm. As always, most of the daemon problems had zero wrong submits, since you had to solve them correctly in order to get to the submit phase (except in problem 15).
In the previous post we talked about how Python reigned over the rest of languages in the global stats. As expected, it is also the top language in most of the problems, although there are some exceptions: problem 8 included PHP code you had to reverse while problem 12 had a daemon that accepted SQL code, and it makes sense for them to be preferred over the rest of languages for those problems.
In problems 18 and 19, Python gets replaced by C++ as the choice for algorithmic problems. In the case of problem 19, we had made a mistake during the generation of its inputs and it was solvable by a “brute-force” algorithm, so most of the participants preferred to use fast languages to solve it quickly (otherwise you would have to take a break until your program calculated the solution).
Lines of code
Amoung the top languages in this competition, Ruby is also the one which wins in the lines per solution statistics. However, take in mind that it was only used in the first 7 challenges. The most used language, Python, was almost able to tie with Ruby with only 3 more lines per solution (56 vs 53).
The shortest solution of this year submitted by a participant is a 68-bytes long AWK script that solved problem 1. We also had our own fun searching for the shortest possible solutions for this problem, and ended up with a 41-bytes long (!) AWK solution (or 47 bytes when turned into a shell script which calls awk):
Writeups and solutions
We also include a compilation of solutions and writeups shared by the participants. We hope you like them.
- @miguescri: https://miguescri.com/tags/tuenti-challenge/ (1–10)
- @Nisckis: https://bitbucket.org/nisckis/tuenti-challenge-2019/wiki/Home (1–7, 9)
- @AlbertMoran_YL: https://github.com/ichirusaki/TuentiContest9 (1–6, in Python)
- @csoroz: https://github.com/csoroz/Tuenti-challenges/tree/master/2019 (1–7, 9, in Haskell)
- @furstenheim: https://github.com/furstenheim/tuenti-challenge-9 (2–4, 6, 8, 9, 11–13, 15 in Go and Node)
- @Rzial: https://github.com/Rzial/tuenti-challenge-2019 (1–6, 8, 9, 11, mostly in Go)
- @warbelt: https://github.com/warbelt/tuenti-challenge-9 (1–9, in Python)
That’s all for now, we hope you enjoyed the competition as much as we did! But it hasn’t ended yet, since during today and tomorrow the ten finalists of this year will be visiting our offices and will have some more challenges awaiting them! Stay tuned to know who will be the winner!