New Year Contest

The first few levels could be solved by hand — it was enough to use simple operations like addition, subtraction, multiplication, and exponentiation.

For the harder levels, you could write a brute-force search starting from all possible integers that can be formed from the “allowed” digits, and generating all expressions of lengths 1, 2, 3, and so on by building more and more complex expressions. It’s important not to get tripped up by operator precedence, but an LLM writes this kind of code very well.

On some levels you could also add fractional numbers or numbers in scientific notation (4e6) to find the optimal expression. This is easy to do: you just add those numbers to the initial set of numbers the search starts from. Also, it’s useful to start using the bitwise NOT operator ~ on a number. For example, ~1 == -2 (an explanation of why).

The next group of levels focused on hexadecimal notation, since it lets you build expressions without using digits at all! The solution approach doesn’t change, though — you just need to add hexadecimal numbers to the list of starting values if you aren’t allowed to use any digits other than zero. Zero is needed because hexadecimal numbers in Python are written like 0xBEA.

But what if you’re forbidden to use all digits — even zero? That’s where the True constant comes in handy, because True == 1 (“Why is bool a subclass of int?”)! This way, you can build expressions using only True: for example, (True+True<<True+True)+True == 9. To do this, you first build an expression using only ones, and then replace all ones with “True”. And for that we already have code! You just need to reduce the list of starting numbers to [1] — you can’t use anything but one now.

For simplicity and speed, you can generate expressions not only from ones, but from ones and twos, and then replace twos with -~True (don’t forget to get rid of the occasional double minus “--” by replacing it with pluses).

The final levels covered the case where the letter “e” is also forbidden, which means you can’t write True anymore... In that case, you need to replace one with not[]. And if square brackets are forbidden as well, then use not() or ()==() — limits were quite soft.

Note: operations like ~(not[]) do work, but they trigger a warning in modern Python:

>>> ~(not[])
<stdin>:1: DeprecationWarning: Bitwise inversion '~' on bool is deprecated and will be removed in Python 3.16. This returns the bitwise inversion of the underlying int object and is usually not what you expect from negating a bool. Use the 'not' operator for boolean negation or ~int(x) if you really want the bitwise inversion of the underlying int.
-2
        

Luckily, it’s 2026, and Python 3.16 won’t come out until 2027 ;-)

Note 2: during the contest, participants found an elegant way to obtain numeric constants:

b'"'[b''<b'']*b'K'[b''<b'']-b'\n'[b''<b'']

Cool!

I don’t know any way to solve this task better than with brute force. What’s more, today’s LLMs with the ability to run code are pretty good at brute-forcing the answers and finding the correct one. The only real issue you might run into is the time limit. We need to brute-force efficiently enough to clear all levels within the contest’s five hours! That was the main difficulty of this task.

As in the other tasks, the first levels can be solved by hand — in them the secret sequence is reconstructed uniquely (if you assume the sequence doesn’t contain numbers greater than ten).

For the harder levels, a straightforward brute-force over all possible secret sequences and checking each one will do.

MAX_NUMBER = 10
NUMBER_COUNT = 4

for secret in itertools.permutations(range(1, MAX_NUMBER), NUMBER_COUNT):
    if is_valid(secret):
        return secret

def is_valid(secret: list[int]) -> bool:
    for numbers, bulls, cows in guesses:
        if score(secret, numbers) != (bulls, cows):
            return False
    return True

def score(secret: list[int], guess: list[int]) -> tuple[int, int]:
    bulls = sum(1 for i in range(len(secret)) if secret[i] == guess[i])
    common = len(set(secret) & set(guess))
    return bulls, common - bulls

To speed up this brute force, you could implement backtracking — gradually add numbers one by one to secret while keeping track of how many “bulls” and “cows” you’ve already accumulated for each given guess. If for at least one guess they exceed the required amount, the search stops and we move on to the next options. This approach lets you prune a large number of “dead” branches.

But the fastest solution I know reformulates the problem as a SAT problem and uses one of the existing frameworks for solving such problems: for example, Google OR-Tools or Microsoft Z3. Bindings for these libraries exist for many programming languages, and the solution boils down to declaring the right number of variables and stating all the constraints. For example, with Z3:

s = z3.Solver()

x = [z3.Int(f"x_{i}") for i in range(K)]
for xi in x:
    s.add(And(xi >= 1, xi <= N))

s.add(Distinct(x))

for numbers, bulls, cows in guesses:
    add_guess_constraints(s, x, numbers, bulls, cows)

View how you can implement add_guess_constraints()

def add_guess_constraints(solver, secret_vars, guess: list[int], bulls: int, cows: int):
    K = len(secret_vars)

    # Counting Bulls: positions where secret[i] == guess[i]
    bull_bools = [secret_vars[i] == guess[i] for i in range(K)]
    bull_count = z3.Sum([z3.If(b, 1, 0) for b in bull_bools])
    solver.add(bull_count == bulls)

    # Counting Cows
    exists_in_secret = []
    for value in guess:
        # 1 if the value is in the secret, 0 otherwise
        value_exists_in_secret = z3.Sum([z3.If(secret_vars[i] == value, 1, 0) for i in range(K)])
        exists_in_secret.append(value_exists_in_secret)

    total_common = z3.Sum(exists_in_secret)
    solver.add(total_common == bulls + cows)

To find the minimum solution, you can use Z3’s built-in optimizer — z3.Optimize(), but in my experiments it turned out to be slower (YMMV!) than the following approach: let’s enumerate short prefixes in lexicographic order (start with “1 2”, then “1 3”, and so on), fix them in our answer, and try to find any (not necessarily minimal!) solution using z3.Solver(). If one is found, and none were found for the previous prefixes, that means we’ve found the smallest possible prefix! Keep extending it until we get the full answer.

In a normal programming language, such a program would be trivial:

input_line = read_line()
if input_line == "what":
    print("contest")
if input_line == "where":
    print("2026.andgein.ru")

Unfortunately (or fortunately!), Brainfuck doesn’t let you read an entire string at once, compare strings, or print them directly. Instead, it operates on individual memory cells or bytes (read about the language online if you haven’t worked with it before). It has other quirks too, but even with just these constraints, our program is forced to look something like this:

# Skip first two characters, because they are always "wh"
input_character = read_character()
input_character = read_character()
input_character = read_character()
if input_character == "a": # "what" branch
    print("c")
    print("o")
    ... # Print all characters of "contest" one by one
if input_character == "e": # "where" branch
    print("2")
    print("0")
    ... # Print all characters of "2026.andgein.ru" one by one

Another difficulty is that the language doesn’t even have a comparison like if input_character == "a". Instead, we have to subtract 97 (the ASCII code for a) from the byte that stores input_character, and then compare the result with zero, because that’s the only comparison the language provides. So the easiest approach is to sort the letters we want to compare input_character against and check them one by one by gradually subtracting:

# Skip first two characters, because they are always "wh"
input_character = read_character()
input_character = read_character()
input_character = read_character()
input_character -= 97    # ASCII code of "a"
if input_character == 0: # "what" branch
    print("c")
    print("o")
    ... # Print all characters of "contest" one by one

input_character -= 4     # ASCII code of "e" is 101, and 101 - 97 = 4
if input_character == 0: # "where" branch
    print("2")
    print("0")
    ... # Print all characters of "2026.andgein.ru" one by one

The remaining question is what to do when there are more than two possible strings, and some of them differ in the first character while others differ, say, in the third. Well, there’s no way around it! Let’s first read the first character and handle all possible cases for it; then, if needed, read the rest and again handle all scenarios until we figure out what we’re supposed to print. These ideas, together with a careful implementation and the ability to print the required strings reasonably efficiently, were enough to clear the first 20 levels — or even more.

View levels 1–20

2026

0 → 1
1 → 0

happy → new year
merry → christmas

eyes → coal
nose → carrot
arms → sticks
buttons → rocks

German → Frohe Weihnachten
Spanish → Feliz Navidad
Italian → Buon Natale

United States → Santa Claus
United Kingdom → Father Christmas
Russia → Ded Moroz
Netherlands → Sinterklaas
Norway → Julenissen
Finland → Joulupukki
Germany → Weihnachtsmann

hey jude → beatles
one → u2
smells like teen spirit → nirvana

what → contest
where → 2026.andgein.ru
when → 1 january 2026

18:00 → getting ready
21:00 → warm-up chatter
23:30 → countdown hype
00:00 → cheers and chaos
02:00 → philosophical conversations

january 1 → sleepy victory
january 2 → mild denial
january 3 → inbox shock
january 4 → routine reboot
january 5 → okay, new year mode on

violin → string
flute → woodwind
trumpet → brass
drum → percussion
piano → keyboard

mercury → 1
venus → 2
earth → 3
mars → 4
jupiter → 5
saturn → 6
uranus → 7
neptune → 8

pawn → 1
knight → 3
bishop → 3
rook → 5
queen → 9

a → alpha
b → beta
g → gamma
d → delta
e → epsilon
z → zeta
i → iota
l → lambda
o → omicron

january → february
february → march
march → april
april → may
may → june
june → july
july → august
august → september
september → october
october → november
november → december
december → january

USD → United States
EUR → Eurozone
JPY → Japan
GBP → United Kingdom
AUD → Australia

banana → yellow
strawberry → red
kiwi → green
blueberry → blue
grape → purple

Inception → 2010
The Matrix → 1999
Interstellar → 2014
Titanic → 1997
Parasite → 2019

AAPL → Apple
MSFT → Microsoft
GOOGL → Alphabet
AMZN → Amazon
TSLA → Tesla

4 → tetrahedron
6 → cube
8 → octahedron
12 → dodecahedron
20 → icosahedron

Later levels could require a few more optimizations. Let’s go over the ones I used (you might not need them if you implemented the other parts more efficiently!).

1. When printing a string (for example, “contest”), you first need to produce byte 99 (the ASCII code for c), then 111 (o), 110 (n), and so on. Obviously, you almost always want to reuse the same cell, because if it already contains 111, getting 110 is easy — just subtract one, which is a single instruction in Brainfuck. But how do you write the shortest program to get 111 from 99?

For that, let’s precompute, for every pair of bytes A and B, a reasonably short program that transforms A into B. Start with the trivial programs — lots of “+” increments and “-” decrements. Then use the fact that if you have a program that transforms A into C, and a program that transforms C into B, then their concatenation transforms A into B. Finally, use simple multiplication. For example, [--->+++++++<] multiplies a number by 7/3 — i.e., it maps 6 to 14 and 27 to 63.

By applying these operations, we’ll keep improving our programs as long as they keep getting shorter. Then we’ll use them both for printing strings and for subtracting before comparisons.

2. Sometimes the strings you need to print share the same prefix or the same suffix. Then you can save space by printing the common prefix/common suffix outside the branches.

3. Sometimes the general program-generation logic inserts zeroing loops [-], unnecessary shifts <>, or other things that turn out not to be needed. Remove them at the very end, making sure the program still behaves as expected. For that you’ll have to write a Brainfuck interpreter, but luckily it takes ten lines can be written by an LLM or imported from a library.

View levels 21–50

lift → elevator
lorry → truck
boot → trunk
petrol → gasoline
biscuit → cookie

New York → UTC-5
London → UTC+0
Tokyo → UTC+9
Sydney → UTC+10
Dubai → UTC+4

32 F → 0 C
68 F → 20 C
86 F → 30 C
104 F → 40 C
14 F → -10 C

hydrogen → 1
helium → 2
carbon → 6
oxygen → 8
iron → 26
copper → 29
zinc → 30
krypton → 36
silver → 47
tin → 50
iodine → 53
xenon → 54
gold → 79
mercury → 80
lead → 82
uranium → 92
plutonium → 94

H → Hydrogen
He → Helium
C → Carbon
O → Oxygen
Fe → Iron
Cu → Copper
Ag → Silver
Au → Gold

tennis → racket
soccer → ball
boxing → gloves
archery → bow
hockey → stick

phoenix → greek
kitsune → japanese
anubis → egyptian
kelpie → scottish

python → 1991
javascript → 1995
rust → 2010
go → 2009

python → snake
go → gopher
rust → gear cog
java → steaming coffee cup
javascript → yellow JS badge

Gryffindor → bravery
Hufflepuff → loyalty
Ravenclaw → wisdom
Slytherin → ambition

pi → 3.14159
e → 2.71828
phi → 1.61803
tau → 6.28318

.jpg → photograph
.png → picture
.svg → vector image
.wav → audio
.epub → ebook
.yaml → config
.md → markdown text
.csv → comma-separated values
.mp4 → video
.ttf → font
.ico → icon

triangle → 3
square → 4
pentagon → 5
hexagon → 6

3 → triangle
4 → square
5 → pentagon
6 → hexagon

200 → OK
201 → Created
204 → No Content
301 → Moved Permanently
302 → Found
400 → Bad Request
401 → Unauthorized
403 → Forbidden
404 → Not Found
500 → Server Error
502 → Bad Gateway
503 → Service Unavailable

monet → impressionism
picasso → cubism
kahlo → surrealism
van gogh → post-impressionism
dali → surrealism
kandinsky → abstract
pollock → abstract expressionism
cezanne → post-impressionism
rothko → color field
hopper → realism

voyager 1 → interstellar
cassini → saturn
new horizons → pluto

AA → 1.5V
AAA → 1.5V
9V → 9V
CR2032 → 3V

hearts → red
diamonds → red
clubs → black
spades → black

tokyo → mega
vienna → large
reykjavik → small
new york → mega
shanghai → mega
berlin → large
lisbon → medium
zurich → medium
oslo → small

baguette → france
naan → india
pita → middle east
focaccia → italy
tortilla → mexico
brioche → france
injera → ethiopia
pretzel → germany

heart → circulatory
lungs → respiratory
kidneys → urinary
liver → digestive
stomach → digestive
pancreas → endocrine
brain → nervous
skin → integumentary
spleen → lymphatic

+ → add
- → subtract
* → multiply
/ → divide

titan → saturn
ganymede → jupiter
triton → neptune
enceladus → saturn
charon → pluto
phobos → mars
deimos → mars

git status → what changed?
git add → remember this
git commit → lock in a snapshot
git push → send it away
git pull → get latest from others

greenland → atlantic
madagascar → indian
fiji → pacific
iceland → atlantic
sri lanka → indian
hawaii → pacific
new guinea → pacific
sumatra → indian
canary islands → atlantic

cerulean → #007BA7
vermillion → #E34234
chartreuse → #7FFF00
ultramarine → #3F00FF
crimson → #DC143C
indigo → #4B0082
turquoise → #40E0D0
gold → #FFD700
salmon → #FA8072
magenta → #FF00FF

( → )
) → (
[ → ]
] → [
{ → }
} → {
> → <
< → >

Hippogriff → XXX
Acromantula → XXXX
Phoenix → XXXX
Niffler → XXX
Basilisk → XXXX
Chinese Fireball → XXXXX
Gnome → XX

2+2 → 4
2*2 → 4
3+3 → 6
3*3 → 9
4+4 → 8
4*4 → 16

Note: on every level you can write an even shorter program — the answers above aren’t the limit!

First, the task could be solved by hand! By my estimates it should have taken two to three hours, but it seems some teams got good enough to do it faster :-) Next, let’s talk about an automated solution.

Generally, it doesn’t look too hard — you just need to build a small object-detection pipeline. A significant number of first levels contained nothing but LEGO minifigures, so if you learned how to separate them from the background, you could already score a solid number of coins.

However, later on the minifigures appeared together with other toys, so you’d want to tell them apart. There weren’t that many different figures overall, so you could try writing code to automatically cut them out from the background and rotate them, and then manually label which ones are minifigures and which aren’t.

Or you could take a LEGO minifigure dataset and train a detector specifically for that kind of object. For example, this dataset detects all the figures well except the skeleton, which it recognizes only about 50% of the time.

You could pick any suitable model for object-class detection. I chose YOLOv8, and thankfully, in modern frameworks training can be done in three lines:

from ultralytics import YOLO

model = YOLO('yolov8n.pt')
dataset_yaml_path = "path/to/lego/dataset/data.yaml"
results = model.train(data=dataset_yaml_path, epochs=100, imgsz=640)

print("Training Complete!")
print("Your new .pt file is located in the 'runs' folder created in this directory.")
print("Look for: runs/detect/train/weights/best.pt")

What should you train the model on? You can do it on a modern CPU, but to stay within the contest’s limited time, I rented a virtual server with a fairly basic GPU for this kind of work (an RTX 4000 Ada) and trained the model in under $1 per hour. For even more speed, you could use something like an H100 or H200 — on such a small dataset they should finish in minutes.

Then you just need to build the pipeline correctly:

1. Split the image into squares.
2. Feed each square into model.predict(...) with the right parameters. For example, I recommend agnostic_nms=True, imgsz=2048, and iou=0.5. If you’re also using YOLO, read more about the parameters in the documentation.
3. Finally, choose a confidence threshold above which you’ll count a detected object as a LEGO minifigure. Typically, people recommend at least 50%, or even 75%.

View images from all levels

#	Image	Number of minifigures
1		10
2		25
3		37
4		34
5		39
6		85
7		105
8		93
9		68
10		78
11		93
12		96
13		60
14		97
15		89
16		188
17		170
18		168
19		154
20		186
21		163
22		195
23		190
24		181
25		192
26		222
27		273
28		176
29		194
30		212
31		291
32		151
33		184
34		342
35		285
36		474
37		339
38		392
39		536
40		626
41		694
42		239
43		358
44		373
45		325

It turns out the image can be reconstructed uniquely, even if the number of chunks is fairly large! Let’s start with the case where there aren’t many chunks. In that case you can simply try all possible permutations and keep the ones that produce a valid PNG file.

View images for levels 1–4

#	No. of pieces	Question	Restored image
1	3	How many birds are on the wire?
2	4	How many cars are preparing for the race?
3	5	What's a title of this famous book?
4	8	How many fish are in the aquarium?

In the next levels, the number of chunks increases to 18, 38, and even 113, and brute-forcing all permutations is no longer feasible. However, it’s enough to remember that a PNG file consists of chunks, each of which contains a CRC32 checksum. If a chunk happens to lie across the boundary between two pieces of our split file, then you can quickly tell whether those two pieces can be adjacent — just check that the checksum for the chunk is correct.

Let’s run a backtracking search, which will try to append some piece to the already glued-together beginning of the file. Starting the file is easy — in the first piece there must be the PNG header (eight fixed bytes) and the IHDR chunk, which among other things contains the image dimensions in pixels. We enumerate candidates for the next piece and check the checksum of the chunk that crosses the boundary. If it matches, then with high probability this is the correct next piece; we can continue, then continue further, and so on, until the image is fully reconstructed.

View images for levels 5–9

#	No. of pieces	Question	Restored image
5	18	How many donuts are on a plate?
6	36	How many clouds are in the sky?
7	38	How many slices of pizza weren't eaten?
8	73	How many chairs are on the image?
9	113	How many eyes does the robot have?

But what if a single chunk spans several pieces? Then you’d have to brute-force multiple pieces at once to assemble one chunk and verify its checksum — and that’s something we can’t afford anymore...

In that case, reading pixel data directly from the IDAT chunks helps. The thing is, if you glue the pieces together in the wrong order, the image will still decompress correctly (at least until we reach the end of the chunk and check the CRC), but it will look something like this:

Notice the bottom rows of pixels — that’s where we glued on the wrong piece! The presence of this kind of “noise” can be detected automatically, and you can use it to discard the corresponding piece.

View images for levels 10+

#	No. of pieces	Question	Restored image
10	30	How many blue carriages are on a train?
11	269	How many fire blocks are on the image?
12	398	How many candles are on the cake?
13	537	How many buttons does the snowman have?
14	356	How many cups are on the table?
15	567	How many steps are on the staircase?

It’s important to note that on many levels you don’t need to reconstruct the entire image — restoring half or two thirds is enough. If you occasionally save the part of the image you’ve already reconstructed during the search, you can get the answer much earlier.