Ah. Another year, another EXCELSIOR. So, EXCELSIOR is my school’s annual competition event. It’ll be my last year contributing to the event as part of the committee, so I figured I want to do a big favor of rewriting our hackish PHP site with SvelteKit (and other modern web libraries). Last year, the tech team (not me, I was in design) deployed a (somewhat disasterous) AI slop site, so let’s settle it once and for all with a human-written future-proof website.

Web Form

The first task that I chose was rewriting the competition registration web form since it’s the one thing that needs to be rock stable after deployed. 2 years ago we had some people complaining about form submission failures and we couldn’t figure out why, so I decided to focus on this.

But oh, how web form suuucks. I mean, come on. HTML web forms have been here with us since the 90’s. I thought they’d be somewhat mature already? But no, web form can still turn into your nightmare.

A Basic Form

A basic HTML form? Yeah, we’re all familiar with them. They’re simply form fields enclosed inside a <form> element. We can send the form data for submission by sending a request to the server (POST or GET). The data is then handled by whatever backend software is being run by the server.

<form action="" method="get" class="form-example">
  <div class="form-example">
    <label for="name">Enter your name: </label>
    <input type="text" name="name" id="name" required />
  </div>
  <div class="form-example">
    <label for="email">Enter your email: </label>
    <input type="email" name="email" id="email" required />
  </div>
  <div class="form-example">
    <input type="submit" value="Subscribe!" />
  </div>
</form>

Above is an example of a web form from MDN.

There’s nothing wrong with it. Or, at least, that’s the case for most simple forms.

1. True Arrays? Objects? Nonexistent!

Let’s now talk about competition registration forms, as that’s what I’m trying to build for EXCELSIOR. Suppose I’m making a form for a solo competition. I’d require their contact information, maybe a photo of themselves, letter from their school, and a proof of payment. Works like a charm.

But then, what about team competitions where you need to submit information for more than one person? You’d think that HTML form handles arrays (like I did)? Oh, no it doesn’t.¹ As absurd as it sounds, form fields are limited to primitive types, and that’s not even including arrays.

Now, here’s the strange part: our legacy website actually managed multi-participant information just fine. How did they do that? Well, you can get a little creative with naming. Our legacy site uses an index-based names for the form fields:

function generate_text_field($form_name, ...) {
?>
<div class="form-row">
	<input name="<?= $form_name ?>">
</div>	
<?php
}

// ...
for($f = 1 ; $f <= $members_min ; $f++){
    generate_text_field("name".$f, "Full name of participant #".$f."", "text", false);
    generate_text_field("notelp".$f, "Phone number", "text", false);
    generate_text_field("email".$f, "Email", "email", false);

// ...

So later during form processing, we’d just refer to the user input by the field name + its index. But obviously, this is not clean. A slight change in field naming convention can break everything. You can try to mitigate that by using functions to format the fields—but there’s still no guarantee that the functions are really used by both frontend code and backend code.

So, how do we make it safer? Obviously, have something type-safe. Have an array of participant objects or something. It’d be nice if we can represent the form data as a JSON object and have the schema be known by both the frontend and the backend. This way, I can have custom object types, arrays, and all the goodies! We can implement this from scratch ourselves by programatically submitting a JSON instead of a form data somehow, but I personally would rather not to. I opted to use SvelteKit Superforms instead, which is a nice SvelteKit form library that does all those for me.

JSON Form with Superforms

Now, obviously, when we involve some nonstandard way to submit a form, we’re talking about sticking some JavaScript to the client page. But I’m fine with that; most people registering for our competition will probably have JavaScript anyway.

With Superforms, I can simply define a form schema like this:

// form-schema.ts
export function getParticipantSchema(enforceInstitution: boolean) {
	return z.object({
		name: z.string()...,
		email: z.email()...,
	})
}

export function getFormSchema(enforceInstitution: boolean, minParticipants: number, maxParticipants: number, addExtraQuestion: boolean) {
	return z.object({
		participants: getParticipantSchema(enforceInstitution)...,
		institutionName: enforceInstitution ? z.string()... : z.string()...,
		compSlug: z.string(),
		extraQuestionAnswer: addExtraQuestion ? z.string()... : z.string()...,
		representative: minParticipants > 1 ? z.string()... : z.string()...,
	})
}

Notice the conditional statements—we can have a conditional schema! how cool.

And then, we write some backend code that queries the database for the right competition data:

// +page.server.ts
export const load: PageServerLoad = async ({ params }) => {
	const competitionData = await db.query.competitions.findFirst({
		where: eq(competitions.compSlug, params.slug)
	})

	if (competitionData == undefined) {
		return error(404, {
			message: "Competition not found"
		})
	}

    // ...

	form = await superValidate(preFilled, zod4(getFormSchema(competitionData.enforceInstitution, competitionData.membersMin, competitionData.membersMax, competitionData.extraQuestion != null)), { errors: false });

	return { form, ...};
}

And lastly, for the frontend, simply bind our form fields to the form values object, like this:

<!--+page.svelte-->
{#each $form.participants as participant, i (i)}
    <Input
        type="email"
        name="email"
        placeholder="nama@email.com"
        bind:value={participant.email}
    />
    ...
{/each}

Superforms will then handle turning the form into a JSON which the client sends, along with deserializing the data once they’re in the server. Oh, and, did I mention form validation too? For both frontend and backend?! I chose Zod and Superforms did a nice job integrating it. There are other validators you can use with Superforms too, though.

So. Clean. I simply love it.

2. File Handling Puzzle

But wait, how about files? We can’t just represent a file as a JSON, can we? While that’s true, Superforms gets around this by having the file in the form data itself instead of being serialized further.

Now, this is where things got confusing for me. Superforms doesn’t have the documentation for how to have files, in an object, in an array. The only official documentation of file uploads is located here where they use a proxy function (fileProxy) that connects user file uploads to the input field’s FileList via bind:files. And here’s the tricky part that stumped me: fileProxy takes a path to the file object, which in my case would be something like participants[i].fileObject. I was unsure if string interpolation would work at all there. I tried anyway since that seems faster than digging the source code, and apparently it works fine.

But, still. How do I manage a bunch of file proxies of different file objects together that are inside an array? And that’s when I realize that I’ve forgotten Svelte’s very superpower of componentization. Right, I can just stick the fileProxy inside a component so it manages the proxy on its own:

<script lang="ts">
    // ...
	const proxy = fileProxy(form, `participants[${index}].testfile`);
</script>

<Field.Field>
	<Input
		type="file"
		name="testfile"
		accept="image/png, image/jpeg, image/webp, image/heif"
		bind:files={$proxy}
	/>
</Field.Field>

End Thoughts

Great! We unlocked the ultimate web form experience for both developers and users. But, still, it’s absurd that we need to attach a JSON inside a form data and hack our way out to still get file access just to have a clean competition registration form. I really, really wish that HTML would support JSON form natively! (plus with file transport somehow)

Anyway, this year I mostly used Rust. I had these goals in mind:

• No external libraries

  Well, I thought I could do it until I finally got hit with problems that include parsing nightmare and iterator hell. Thus, I added nom and itertools to my dependencies list.

• All solutions must run under a second

  All of them did except for my 9th day part 2 when ran with extra checks (still gives correct answer without it, though).

• Do not implement any naive solution that comes right off my mind

  Yep, except when I don’t think there’s a better solution than the one I can think of right away.

• Try my best before giving up

  I did, except for the last day. It was too suspicious and I couldn’t help but to check the trick.

• Just Chill™

  For sure.

Overall, it was fun I guess! I learned a ton of stuff along the way. I’d like to share my solutions’ breakdowns too (I haven’t reviewed much of others’ solutions yet, though!).

Day 1

Day 1: Secret Entrance

You’re tasked to find the password to enter the North Pole base by using a rotating dial.

This problem is actually the only one I answered with a C++ code.

1a

The first part is pretty standard modular arithmetic. The idea is to simply to simulate the operations and count how many times the dial points to 0 after an operation.

The problem, though: C++’s modulo doesn’t work with negative dividend. I had to write a custom modulus function that works with negative numbers:

long long modn(long long x, long long n) {
	if (x < 0) return (n - (-x % n))) % n;
	else return x % n;
}

1b

Now this one is supposed to be easy, but damn, the amount of silly mistakes I made-

I “initially attempted to check only the landing position” (this was left in my C++ source file; I don’t remember anymore). But obviously, that’s incorrect since it’s no different than the first part.

I finally got the logic right the second time. The occurrence of 0 for each operation is the number of times it rotated completely plus 1 if it passed 0 during the “redundant” rotation, 0 otherwise.

The redundant rotation check is a bit tricky for me, at least the left rotation one. I initially did the checks like this:

...
if (instruction[0] == 'R') {
    occurrence += (num / 100) + (pos + (num % 100) >= 100 ? 1 : 0);
    pos = modn(pos + num, 100);
} else if (instruction[0] == 'L') {
    occurrence += (num / 100) + (pos - (num % 100) <= 0 ? 1 : 0);
    pos = modn(pos - num, 100);
}
...

However, I just couldn’t get the answer correctly. As it turns out, if we get the left instruction and the initial position was already 0, the redundant rotation cannot ever pass 0 anymore. This fixed it:

...
} else if (instruction[0] == 'L') {
    occurrence += (num / 100) + (pos != 0 && pos - (num % 100) <= 0 ? 1 : 0);
...

Day 2

Day 2: Gift Shop

You’re tasked to find all invalid IDs among several product ID ranges (they were added by a young elf).

This is the point where I read the problem and go, “damn it, C++ ain’t gonna cut it”. I could not imagine myself writing the loops and all that in C++, let alone debugging when things go wrong.

2a

My naive idea was this: uh, just loop through the ranges and check if it’s an invalid pattern?

But eh, of course, I’m not allowed to implement naive solutions, remember? Maybe there is some kind of pattern, so I continued checking. And indeed, we can easily know the first valid pattern that comes after the start of the range.

There are two cases for our start of range: either the number of digits is odd, or it’s even. In the case that it’s odd, we can simply repeat the first $ \lceil\frac{n}{2}\rceil $ digits twice, then continue generating the next patterns from there until we hit the dead end.

In the case that it’s even, however, we got two possibilities: repeat the first $ \frac{n}{2} $ digits twice, or repeat the first $ \frac{n}{2} $ digits, plus one, twice. The plus one is needed when the number formed by the first $ \frac{n}{2} $ digits is less than the other half. For example, the number 812813 has its first half (812) less than its other half (813), so the first valid pattern is going to be (812 + 1) repeated twice, i.e, 813813.

And after we know how to generate the invalid patterns, we just sum them up.

for range in ranges {
    ...

    // if number of digit is odd
    if digits(start) % 2 == 1 {
        // set the repeatable chunk to the number from the first ceil(n/2) digits
        ...
    } else {
        ...
        // slice our number to two
        let (left, right) = slice2(start);
        // do the first half and right half comparison
        if left < right {
            segment = left + 1;
        } else {
            segment = left;
        }
    }

    // loop until we hit dead end
    ...
}
...

2b

Oh no, generalization! My first thought is that this probably has pattern as well. But unfortunately, I couldn’t find any and even if one exists, it’ll probably be too convoluted. I did still attempt to write the smart version but it failed miserably because I missed a bunch of edge cases.

Anyway, I actually wrote two working solutions later. In the first one, I looped through every single number from every single range and see if it’s invalid (by checking if it’s a certain number repeated n times). However, this turned out to be somewhat slow.

...
for range in ranges {
    ...
    for i in start..=end {
        if is_pattern(i) {
            sum += i;
        }
    }
}
...

In the second code (inspired by @sbxte on GitHub), I tried to build invalid patterns from the ground up until I hit a dead end, i.e stop when the number of digits in my repeatable chunk is greater than half the number of digits of the range’s end. Turns out, this is way faster.

...
for range in ranges {
    // to prevent duplicates, e.g 1 four times and 11 twice should be the same
    let mut checked_patterns: HashSet<i64> = HashSet::new();
    ...
    let mut chunk: i64 = 1;
    let mut len;

    'a: loop {
        // set the length appropriately to the first one possible so we don't
        // spend time checking the obviously wrong (valid) ones
        if digits_start % digits_chunk == 0 {
            len = (digits_start / digits_chunk).max(2);
        } else {
            len = (digits_start / digits_chunk + 1).max(2);
        }

        let mut result = repeat_num(chunk, len);
        while result <= end {
            // keep repeating until we hit the end range
            ...
        }
        chunk += 1;

        // if the length of the digits of our chunk is now inappropriate
        if digits(chunk) > digits(end) / 2 {
            break 'a;
        }

    }
}
...

Day 3

Day 3: Lobby

You’re tasked to determine the maximum joltage you can make from each bank (by picking subset of numbers).

3a

For this part, we can simply loop through the string and set the first number to be the highest we have found, so long as it’s not the last number of the string. We do this for the second number as well.

for line in lines {
    ...

    for d in 0..length {
        // first digit
        if digits[d] > max_first_digit && d < length - 1 {
            max_first_digit = digits[d];
            max_second_digit = 0;
        // second
        } else if digits[d] > max_second_digit {
            max_second_digit = digits[d];
        }
    }

    total += max_first_digit * 10 + max_second_digit;
}

3b

The second part of the problem is the generalization of the first one. I guess I could have written 12 else if branches—but that would’ve been tiring, so I just used an array:

for line in lines {
    ...
    let mut max_digits: [u32; 12] = [0; 12];
    let length = digits.len();

    for d in 0..length {
        for i in 0..12 {
            if !(digits[d] > max_digits[i] && d <= length - (12 - i)) {
                continue;
            }
            max_digits[i] = digits[d];
            for j in i + 1..12 {
                max_digits[j] = 0;
            }
            break 'inner;
        }
    }
    ...
}

Day 4

Day 4: Printing Department

You’re tasked to help the elves remove rolls of papers so you can.. break through the wall to get to the cafeteria. Yup.

4a

I don’t really know a non-naive solution, so I just went with looping through each paper roll and checking if it’s accessible or not (by the said rules):

const NEIGHBORS: [(i64, i64); 8] = [
    (-1, -1),
    (-1, 0),
    ...
    (1, 1),
];

...
for row in 0..map.len() {
    'b: for col in 0..cols {
        // no paper roll
        if !map[row][col] {
            continue 'b;
        }

        let mut neighbors_count = 0;
        'c: for (r, c) in NEIGHBORS {
            // check neighbor
            ...
        }

        if neighbors_count < 4 {
            count += 1;
        }
    }
}
...

Maybe there’s some kind of trickery you can do here, but then again, this is already sub-optimal as it’s $ O(RC) $ where $ R $ = rows and $ C $ = columns. I don’t think anything can beat that, because you need to check all paper rolls anyway.

4b

Now we’re asked to simulate the paper roll removal. To be fair, I couldn’t think of a non-naive solution here, either. However, I used a small optimization trick: keeping track of the neighbor count for each paper roll. This way, I don’t have to keep recalculating the neighbors to know which paper rolls I can remove. Then, I just basically do a multi-pass sweeping from top to bottom and remove all paper rolls I can remove.

// count neighbors, like from part a
...

loop {
    let mut done = true;
    for row in 0..map.len() {
        'b: for col in 0..cols {
            if !map[row][col] {
                continue 'b;
            }

            if neighbors[row][col] < 4 {
                // erase the paper roll
                map[row][col] = false;

                done = false;
                count += 1;

                ...
                'c: for (r, c) in NEIGHBORS {
                    // out of map
                    if !(new_r >= 0 && new_r < rows_i && new_c >= 0 && new_c < cols_i) {
                        continue 'c;
                    }

                    // reduce the neighbors
                    neighbors[new_r as usize][new_c as usize] -= 1;
                }
            }
        }
    }
    if done {
        break;
    }
}
...

Day 5

Day 5: Cafeteria

You’re tasked to help the elves find fresh ingredient IDs from their new inventory management system.

This line right here:

[…] “If only we hadn’t switched to the new inventory management system right before Christmas!” another Elf exclaims.

It reminds me of the times when I upgrade my (Artix btw) Linux system right before an important task and it ruined my day. Oh well, I guess we can’t really blame the elves.

5a

The first part screams point query in an interval tree. Basically, create an interval tree for the range of fresh IDs, insert the ranges, then just query the points (made with interval with same start and end).

...
for q in queries {
    if ranges.contains(&Int::new_point(q)) {
        count += 1;
    }
}
...

For the interval query, I wrote my own interval tree that augments a standard non-self-balancing BST (also my own—judging by the fact that it’s non-self-balancing). It was good enough for this purpose.

Funny enough, I thought that interval trees are for “containment” queries (i.e interval a is contained by b if a.start >= b.start and a.end <= b.end). I had a terrible time making a containment tree by reading guides about interval tree. Eventually, I did make it work, and I ended up with a tree that can do both overlapping range query and containment query. How fun (albeit pretty unnecessary).

5b

For the second part, I use a BTreeMap that holds fresh ingredient ranges and orders the elements using ranges’ start as the sorting key. Whenever I add a new range, it and any overlapping ranges are merged into one. The list is then guaranteed to hold non-overlapping ranges, so then, I can simply loop through all the ranges and count how many fresh ingredients are there.

...
while reader.get_line()? != 0 {
    let (start, end) = reader.buffer.trim().split_once('-').unwrap();
    ...

    // delete any overlapping intervals
    ...

    // insert the new interval, which is the result of the new interval
    // merged with any other overlapping intervals.
    ranges.insert(start, end);
}

let mut count: u64 = 0;
for (s, e) in ranges {
    count += e - s + 1;
}
...

I used a lot of non-stable features here actually (not shown), like Cursors for BTree. I needed it for the sake of being able to use the upper_bound method to find where I should start doing overlap checks to this new interval. Coming from doing competitive programming with C++, I’m surprised this is not available in stable Rust.

Day 6

Day 6: Trash Compactor

You’re tasked to help a young cephalopod with her math homework.

Okay, but, why do they even have those??

6a

Anyway, this is starting to look somewhat cumbersome to parse, but at this point I still wanted to not have any external parsing libraries. Thus, my code consists of mostly me doing tedious string parsing:

Since this is simply a problem that requires you to implement the rules they gave, the logic is pretty straightforward.

...
let mut total: u64 = 0;

for i in 0..len {
    if ops[i] == '*' {
        total += num1[i] * num2[i] * num3[i] * num4[i];
    } else if ops[i] == '+' {
        total += num1[i] + num2[i] + num3[i] + num4[i];
    }
}
...

6b

For the second part, my code is a bit long, but really what it’s just doing is parsing each number entries with padding (0). The maximum length of a number is obtained by making use of the problem gaps that exist in the operators row.

...
#[derive(Default, Debug)]
struct Problem {
    operation_type: OperationType,
    digits_len: usize,
    nums: Vec<Vec<Option<u8>>>,
}

impl Problem {
    fn evaluate(&self) -> u64 {
        ...
        for i in index.rev() {
            let mut tens_factor = 1;
            let mut formed_number = 0;

            // we have to reverse the order because we are reading from top to
            // bottom, and the number with the smallest 10 factor is at the bottom
            // fortunately, both addition and multiplication are commutative.
            for num in self.nums.iter().rev() {
                formed_number += if let Some(x) = num[i] {
                    let res = x as u64 * tens_factor;
                    tens_factor *= 10;
                    res
                } else {
                    0
                };
            }

            match self.operation_type {
                OperationType::Addition => sum += formed_number,
                OperationType::Multiplication => sum *= formed_number,
            }
        }
        sum
    }
}
...

And yes, I’m still doing manual string parsing (not shown).

Day 7

Day 7: Laboratories

You’re tasked to fix a broken teleporter so you can escape a North Pole research wing.

7a

The first part of the problem reminds me of another similar problem I’ve solved before, titled Waterfall (it’s written in Indonesian, by the way). Just that instead of finding the best spot for the tachyon beam to enter the manifold, we have to calculate the number of beam splits that will occur, given a starting spot.

Funny story, I got slightly confused with the definition of a beam “splitting” and I wrote the solution for part 2 when trying to solve part 1.

But anyway, my first part had this DP recurrence relation:

Essentially, whenever a beam hits a splitter, it will get split once—thus adding 1 to our total sum. It will also create 2 new beams, which might split again later, so we call f(r, c - 1) and f(r, c + 1) to get the number of splits that will occur for each of the newly created beams. When a beam doesn’t hit a splitter, it just travels down like normal. The “if visited already” here is needed so we don’t solve for the same table entry twice, as when two beams overlap, they’re considered as just one beam.

I wrote a recursive function to solve this proble. I know that it isn’t the best thing to do, but I just can’t help but to try it for this problem because in the Waterfall problem, I only used simple for loops. Experimentations are cool, yk?

...
type Map = Vec<Vec<MapItem>>;
type Marker = Vec<Vec<bool>>;

fn splits(marker: &mut Marker, map: &Map, row: i64, col: i64) -> u64 {
    ...
    if row >= rows || col >= cols || col < 0 {
        // base case: out of map so no splits will occur. return 0
    } else if marker[rw][cl] {
        // visited already, don't try to do it again (return 0).
    } else if map[rw][cl] == MapItem::Splitter {
        // this is a splitter: split the beam.
        marker[rw][cl] = true;
        let result = 1 + splits(marker, map, row, col - 1) + splits(marker, map, row, col + 1);
        return result;
    } else {
        // blank space: propagate downwards.
        marker[rw][cl] = true;
        let result = splits(marker, map, row + 1, col);
        return result;
    }
}
...

7b

This is yet another DP problem. To be specific, this is the counting-total-ways (the beam can travel) style. DP is important here because we do not want to waste resources calculating the number of ways a beam can travel down for the same tile (position) over and over again.

Thus, I came up with this (which I just copied from my previously deleted part 1 solution):

This one I think is simpler to think of. There are two ways a beam can travel when it hits a splitter, so obviously the timelines possible is the number of timelines possible if it travels to the left + if it travels to the right. If the beam isn’t in a splitter, it’ll just continue propagating downwards (i.e just 1 timeline possible).

fn timelines(dp: &mut DP, map: &Map, row: i64, col: i64) -> u64 {
    ...
    if row == rows - 1 {
        // base case: we're at the last row. there's only 1 timeline.
    } else if col < 0 || col >= cols {
        // base case: we're out of the map (invalid column). no timeline
        // is even possible. return 0.
    } else if let Some(val) = dp[rw][cl] {
        // we already know the answer so return that.
        return val;
    } else if map[rw][cl] == MapItem::Splitter {
        // either it goes to the left or it goes to the right
        let result = timelines(dp, map, row, col - 1) + timelines(dp, map, row, col + 1);
        dp[rw][cl] = Some(result);
        return result;
    } else {
        // only one possibility: travelling down again
        let result = timelines(dp, map, row + 1, col);
        dp[rw][cl] = Some(result);
        return result;
    }
}

Day 8

Day 8: Playground

You’re tasked to help the elves connect electrical junction boxes together so electricity reaches all decoration lights.

8a

So the elves are doing a greedy approach: repeatedly connect two junction boxes that are the closest together (luckily, this approach does result in the global minima—that’s minimum spanning tree for you!). This problem fits perfectly under the category of graph problems, so we’ll use graph-related terminologies here.

Obviously, to know which junction box to connect, we need to know which two pairs of the boxes are the closest at a time. Thus, we need to store the list of all pairs of boxes and their distances (i.e the edges and the distances as the weight), and we need a way to access the one with the shortest distance quickly. Binary heap would make a perfect data structure for that, as we can do $ O(1) $ query to get the pair of junction boxes closest at a time.

After two junction boxes are connected, they belong in the same component. To keep track of this set membership data, we can use a DSU (disjoint union set). Now, our objective is to keep track of the graph’s component sizes after the first 1000 connections.

To simplify my life (and further Advent of Code instances), I wrote a custom disjoint set union that:

• Stores the number of components that exist, which is updated after each join operation. This allows $ O(1) $ time for number of components query.
• Stores a BTreeMap that stores [component size, component count] as [key, value]. The list is sorted ascending (from components of smallest sizes to largest sizes).
• Allows $ O(1) $ query of the size of a component that any given element belongs to.

So now, my job is to do the first 1000 connections, then check the component sizes. Pretty easy with the help of my ChonkDSU (yes).

static COUNT: usize = 1000;

use aoc::{chonk_dsu::ChonkDSU};
...
let mut dsu = ChonkDSU::new(jboxes.len());

// connect the first N pairs of junction boxes closest together.
for _ in 0..COUNT {
    let edge = possible_connections.pop().unwrap();
    dsu.unite(edge.0.a, edge.0.b);
}

...

// count the sizes of the three largest circuits.
for (size, count) in dsu.get_components_map().iter().rev() {
    for _ in 0..*count.min(&(3 - processed)) {
        result *= size;
        processed += 1;
    }
    if processed == 3 {
        break;
    }
}
...

8b

Oh great, it’s literally just part one but actually finish our circuit (and also take note of the last processed pair of junction boxes)!

There are many ways to check if we’re done connecting all junction boxes together in the same circuit, such as by checking the size of the component newly merged or by counting the number of components that exist. I went with the latter since it’s the easiest.

...
let mut last_a_idx: usize = 0;
let mut last_b_idx: usize = 0;

// this time, connect ALL of the junction boxes until we only have 1 component left.
while dsu.n_components() > 1 {
    let edge = possible_connections.pop().unwrap();
    last_a_idx = edge.0.a;
    last_b_idx = edge.0.b;
    dsu.unite(edge.0.a, edge.0.b);
}

let x1 = jboxes[last_a_idx].x;
let x2 = jboxes[last_b_idx].x;
println!("Result:\nx1: {x1}\nx2: {x2}\nx1 × x2 = {}", x1 * x2);
...

Day 9

Day 9: Movie Theater

You’re tasked to help the elves form the largest rectangle possible on their big tile movie theater floor.

why do you guys flip row and column in the input?!

9a

Before my explanation and commentary begins, to clarify, I do indexing like this (and I do believe this is THE only legal way when doing CS ^_^):

(x, y) -> row x, column y

TOP-LEFT                       TOP-RIGHT
(0, 0), (0, 1), (0, 2), (0, 3), ...
(1, 0), (1, 1), (1, 2), (1, 3), ...
(2, 0), (2, 1), (2, 2), (2, 3), ...
(3, 0), (3, 1), (3, 2), (3, 3), ...
...
BOTTOM-LEFT                 BOTTOM-RIGHT

A brute force would have probably worked just fine, but I wondered if doing a greedy approach was possible. I knew it has to be something like, pick the “most corner” points—but I had no idea of what quality even determines “corner-ness”.

Okay, let’s take an example of a corner: top-right corner. How do we determine if a point is definitely “more top-right corner” than the other? Let’s start with the most obvious case: it has smaller row number and bigger column number:

In this case, it’s clear that point B is a better candidate than point A. This is because, regardless of any other point we pick, the rectangle that would be formed by using point B and this other hypothetical point is always going to be bigger than if I had picked point A (so long as the hypothetical point has smaller or equal column number and bigger or equal row number than point A or B—that is, this hypothetical point it is valid as a bottom-left corner and not any other corner). So obviously, here, point B is “more top-right corner” than point A.

However, we run into trouble when we have cases like-

Point B having bigger row number than point A (bad), but bigger column number than point A (good):

Point B having smaller row number than point A (good), but smaller column number than point A (bad):

In this case, only one of the row and column of point B is better than A. So, which one is more “top-right corner”? Unfortunately, that depends on where the other (left-bottom) corner point lies on. In some cases, using point B can make you a better rectangle. In others, point A will do better:

Thus, we kind of have to pick both points in this case, because they’re better in some way than the other.

As it turns out, if we eliminate all the “obviously worse” points and keep the “somewhat equal” ones for each corners (top-right, top-left, bottom-right, bottom-left), we get a, surprise surprise: convex hull set. Ah yes, the convex hull set indeed contain the most “corner” points—so we’re back to square one. It does make sense—the two points that make the largest rectangle must be part of the convex hull set.

Anyway, just to be clear, we don’t need to try all pairs of the convex hull points. We can simply try the best rectangle we can get from picking a point from top-right and bottom-left, and try again from top-left and bottom-right.

This is how I wrote my code:

...
// note: points are already sorted by the column.
for i in 0..n_points {
    // left to right
    let ltr = i;

    // set local min/max for the current column
    if points[ltr].0 < ltr_min {
        ...
    }

    if points[ltr].0 > ltr_max {
        ..
    }

    // if after this it's different column.. or this is the last one, gotta push the points
    if points[ltr].1 != ltr_next_col || ltr == n_points - 1 {
        if ltr_min < ltop_min {
            ...
        }
        if ltr_max > lbot_max {
            ...
        }

        // if next one is available
        if ltr <= n_points - 1 - 1 {
            ltr_next_col = points[ltr + 1].1;
        }
    }

    // right to left (yes we iterate from two directions.. at once because why not)
    // code same as above but mirrored
    ...
}

let mut max_area: usize = 0;

// left top and bottom right
for a in &ltop {
    for b in &rbot {
        max_area = max_area.max(area(a, b));
    }
}

// right top and bottom left, same as above but mirrored
...

println!("Max area: {max_area}");
...

For my input, it reduced the total checks needed from $ \binom{496}{2} = 122760 $ pair of points down to just 5308. Added with other operations necessary (sorting, etc.), I got a total of $ 496+4442+5308 = 10246 $ operations. This means that I reduced the work needed by 91.7%. Cool!

9b

Now this one, I completely gave up doing any optimizations. Heck, I couldn’t think of a naive solution right away.

I sort of cheated by checking how other people do this part, and I found this post written by @derailed-dash on GitHub that suggested the use of several pruning logic, edge-intersect check, and ray casting (to determine if the resulting rectangle is inside the geometry or not). I didn’t read exactly how they did it, so I wrote my own edge-intersect check implementation by augmenting two interval trees (for vertical edges and horizontal edges) and turning it into an edge intersection checker data structure (I called it an OrthogonalEdgeTree).

As for the ray cast, things get a little finicky. You see, this solution ain’t trivial at all because of how big the given polygon is. A ray cast is absolutely needed to determine if the resulting rectangle is outside of the polygon (thus, it’s invalid). However, doing ray cast in a gigantic space millions of time is.. not exactly feasible. My code ran for over 11 minutes and even after that, it still hasn’t spat out anything yet.

I then decided to delete the ray casting altogether and after that, my code finished executing in.. just under a second. Was the answer correct? Thankfully, yeah. So, I guess that unless your input data is very cursed (which I doubt Eric’s software will even hand to you), any (logical) heuristics you do is fine for this problem.

Here’s my logic (without the ray casting):

...
let mut best_area: usize = 0;
'a: for (a, b) in UniquePairs::from(0..points_len) {
    let area_curr = area(&points[a], &points[b]);

    // if this is worse than our best then don't even try to check it..
    if area_curr < best_area {
        continue 'a;
    }

    // validate our rectangle by checking if each of the edges overlap with any of our current
    // edges
    ...
    let mut result = false;

    if edge_top.end >= edge_top.start {
        result = result || edge_list.overlaps(&edge_top);
    }

    if edge_bottom.end >= edge_bottom.start {
        result = result || edge_list.overlaps(&edge_bottom);
    }
    ...

    if result {
        continue 'a;
    }

    best_area = area_curr;
}
...

Day 10

Day 10: Factory

You’re tasked to help the elves initialize their factory’s machines by pressing some available buttons.

10a

For this one I did a sort of breadth-first search among all possible states of the lights (stored as bitmasks), and use the given buttons to manipulate the state (also with bitwise operations). I stop when I have found a previously explored state to prevent dead loops. This would cap the search space to $ 2^{10} $ (the maximum number lights from the input seems to be 10) for each problem, or just 1024. So, pretty light and fast.

...
fn part1(data: &InputData) -> Option<usize> {
    ...
    queue.push_back((0, data.lights_target));
    added_to_queue.insert(data.lights_target);

    while let Some((depth, curr)) = queue.pop_front() {
        // found the correct configuration
        if curr == 0 {
            return Some(depth);
        }

        for mask in &data.lights_combos {
            let new_subset = curr ^ mask;
            if !added_to_queue.contains(&new_subset) {
                added_to_queue.insert(new_subset);
                queue.push_back((depth + 1, new_subset));
            }
        }
    }

    None
}
...

To be fair, when I did this problem, I didn’t even realize that each button must be pressed at most just once (because pressing one twice would simply undo the changes). I only did the BFS implementation because it reminded me of some other similar problem I’ve solved before, and I wanted to see if the solution would work here too. Anyway, a brute-force solution by trying all possible button presses would cap the search space to $ 2^{13} $ (similarly, the maximum number of buttons from the input seems to be 13). This is just slightly worse than mine, but asymptotically still the same. If the brute force is paired with memoization, it’s going to be pretty much the same as mine (capped to $ 2^{10} $).

10b

A vector of target joltages $ V $ can be represented as a combination of [several button presses times the contribution vector that the button gives]:

And we have to find $ \sum x_i $ such that it is minimized among all possible solutions.

Oh, this one is trippy! I couldn’t really think of the solution myself, so I resorted to looking for hints from the internet. Most people used mixed integer linear programming solvers but I kind of didn’t wanna dive into too much math. I then found a cool divide-and-conquer algorithm proposed by u/tenthmascot on Reddit. Essentially, the algorithm relies on some key observations:

• Let $ f(V) $ be defined as the minimum button presses needed to reach vector $ V $ (the target joltages). If $ V = {0, 0, 0, \dots} $, then $ f(V) = 0 $ as we do not need to press any button to get absolutely nothing.
• $ f(2V) = 2f(V) $. Or, equivalently, $ \frac{f(V)}{2} = f(\frac{V}{2}) $. As a simple proof, suppose that $ f(2V) < 2f(V) $. Now, let’s work backwards. Notice that I can now theoretically reach vector $ V $ by doing $ f(2V) \div 2 $ button presses, i.e, $ f(2V) \div 2 < f(V) $. This would contradict our definition of $ f(V) $, which is “the minimum button presses to reach vector $ V $”. Therefore, $ f(2V) \ge 2f(V) $, and since we trivially know too that $ f(2V) \le 2F(V) $, this concludes to $ f(2V) = 2f(V) $.
• When all of each button presses are even, the resulting vector must have all even elements too (since each button contributes even elements, and combination of even numbers will ultimately give us all even elements as well). However, the converse is not true. Not all resulting vector with all even elements are made up of even button presses. This is because, combination of arbitrary numbers may still give you even number.

Let’s start with the simple case: all of our target vector’s elements are even.

The second key observation says that we can actually divide our work to two, i.e, $ f(V) = 2f(\frac{V}{2}) $, so that’s great. However, the third observation says that this might not always give us a valid result (if there’s an odd number of a button press, we can’t just divide our work into two).

Thus, we can divide our case to two: do not do any work, or try to do some other work that will make our elements still even. In this case, the extra work is pressing all button combinations (only at most once each, because twice, thrice, etc. returns the parity back) that give the same parity as the target vector so the parities cancel out to be all even.

Notice that we can write our equation as combination of some [even number of button presses, plus 1 or 0]:

Thus, doing this “extra work” is guaranteed to always give us at least one valid (possible to form) vector, as we try to “trim away” all the $ x_i \mod 2 $ in our equation.

For the other case, that is, when our target vector’s elements are not all even, we can do something similar. We can do the “trimming” as well and then we can divide our work to two again, but obviously, this time we can’t just “do nothing”.

Notice the similarity of both the cases [when all of our target vector’s elements are not all even] and [when they are all even]. We always need to do the “trimming”, and as it turns out, we can generalize “doing nothing” as a work as well! This simplifies how we can write the algorithm:

...
fn recurse(
    joltages: Vec<usize>,
    lookup_map: &HashMap<Vec<bool>, HashMap<Vec<usize>, usize>>,
) -> Option<usize> {
    // if all elements are 0
    if joltages.iter().fold(true, |acc, v| acc && *v == 0) {
        // no work needed
        return Some(0);
    } else {
        // try to make all the joltages even
        let parity = joltages.iter().map(|v| v % 2 == 1).collect::<Vec<bool>>();

        let mut best = usize::MAX;

        // try all possible work we can try to do.
        // note: the empty button presses, i.e [0, 0, 0, ...] must
        // exist in the lookup map of all even numbers. this is what
        // i mean by "generalizing no work as work".
        for (coeff, presses) in lookup_map.get(&parity).unwrap() {
            if let Some(new_joltages) = sub_two_vectors(&joltages, coeff) {
                if let Some(val) = recurse(
                    new_joltages.iter().map(|x| x / 2).collect::<Vec<usize>>(),
                    lookup_map,
                ) {
                    best = best.min(val * 2 + presses)
                }
            }
        }

        if best == usize::MAX {
            return None;
        } else {
            return Some(best);
        }
    }
}

fn solve(input: InputData) -> Option<usize> {
    ...
    let lookup_map = get_lookup_map(&input.joltage_req, &btns);
    recurse(input.joltage_req, &lookup_map)
}
...

The lookup map here defines which combination of button presses (again, at most once) is possible to form a given parity of the vector, and how many presses each pattern needed (minimum).

This is a really clever solution, honestly. I kind of had a similar idea—I knew well that certain button presses are “redundant”, but I wasn’t sure how to implement something like this.

Day 11

Day 11: Reactor

You’re tasked to help the elves figure out a communication issue between their new server rack and their reactor.

Finally, the difficulty level got ramped down again :sob:

11a

[..] every path [..]

Well, that’s another graph problem (so more graph terms)! To be specific, this is a path counting problem for directed acyclic graph (DAG). I actually know well how to do this with pen and paper (cough.. it’s in 2025 OSN-K), but I’ve never thought about solving it by code.

With pen and paper, I would use this kind of recurrence relation:

The solution I thought of right away was to write something recursive. However, I wanted to try with breadth-first search for efficiency. I initially wrote something basic like:

...
while let Some(key) = queue.pop_front() {
    let now = dp[&key];
    let children = adj.get(&key).unwrap();
    for c in children {
        *dp.get_mut(c).unwrap() += now;
        if !queued.contains(c) {
            queue.push_back(*c);
            queued.insert(*c);
        }
    }
}
...

And, well, it did give me the right answer. Then, after failing to solve for the second part, I realized that I wasn’t doing it correctly at all! I forgot that recursive solution will automatically give me dependency resolution (by solving path count for all nodes that come before the next ones), but implementing a BFS wouldn’t suddenly give me such.

Thankfully, adding a dependency check is somewhat easy. I borrowed the idea from Kahn’s algorithm so that my nodes will be processed in topological order, thus, giving me the dependency resolution needed. It works like a normal BFS, but the number of ingoing edges not processed yet from each node are stored, and a newly discovered node is only queued when it only has one ingoing edge left.

...
while let Some(key) = queue.pop_front() {
    let now = dp[&key];
    let children = adj.get(&key).unwrap();
    for c in children {
        *dp.get_mut(c).unwrap() += now;

        // only queue if it's already been processed by all the nodes before it.
        if ingoing[c] <= 1 {
            queue.push_back(*c);
        } else {
            *ingoing.get_mut(c).unwrap() -= 1;
        }
    }
}
...

11b

Now, this is essentially the same problem as before, but we have a new constraint: the paths must visit both dac and fft (in any order). Also, we now start from svr and not you.

I had two options: I can find all the paths and filter them, or, I can use the multiplication rule from FPC (fundamental principle of counting) to get the number of valid paths directly. That is:

I mean, this seemed like a lot, so I was gonna start filtering paths. However, I was too lazy for that as well, so I returned to my beloved FPC method since I can basically reuse the code for part 1 to solve this easily.

...
paths_count(['s', 'v', 'r'], &ingoing, &adj, &mut dp);
let svr_to_dac = dp[&['d', 'a', 'c']];
let svr_to_fft = dp[&['f', 'f', 't']];

paths_count(['d', 'a', 'c'], &ingoing, &adj, &mut dp);
let dac_to_fft = dp[&['f', 'f', 't']];
let dac_to_out = dp[&['o', 'u', 't']];

paths_count(['f', 'f', 't'], &ingoing, &adj, &mut dp);
let fft_to_dac = dp[&['d', 'a', 'c']];
let fft_to_out = dp[&['o', 'u', 't']];

// total of paths that come from svr to out that crosses fft and dac (in any order)
let mut total = svr_to_dac * dac_to_fft * fft_to_out;
total += svr_to_fft * fft_to_dac * dac_to_out;
...

After realizing that the answer to my input for this part is quite literally 331,468,292,364,745 (331 trillion), I am oh-so-grateful for not attempting to filter paths. I forgot that the number of paths in a graph can go exponential.

Day 12

Day 12: Christmas Tree Farm

You’re tasked to help the elves arrange presents under their Christmas trees.

There’s only one part that needs to be solved here.

Anyway, this problem is ridiculous. It’s NP-hard. If there exists a computationally cheap solution, the Tetris champions would absolutely go nuts over it.

We kind of have to brute force all configurations to be able to solve for all kinds of input, but I couldn’t imagine how long that would take. I guess I can cheat for certain inputs by determining if the Elves’ region is obviously too small or obviously too big. But if that fails, what on earth should I do?

This problem is way too suspicious, so I checked this other post written by @derailed-dash on GitHub. Turns out, for their input (and mine), all of the regions fall under one of [the obviously too small category] or [the obviously too big category]. This means that there’s no need to do brute force at all :sob:

...
while reader.get_line()? != 0 {
    // if this is the gift box definition
    if reader.buffer.trim().split_once(':').unwrap().1.is_empty() {
        ...
        gift_sizes.push(count);
    // if this is the region definition
    } else {
        ...
        // too small
        if blocks_sizes > area {
            // do nothing
        } else if area >= gifts_cnt * 9 {
            total += 1;
        } else {
            println!(
                // i guess this would never happen :|
                "[!] Cannot determine if gifts would fit this region: {}x{}, {} gifts",
                dimension.0, dimension.1, gifts_cnt
            );
        }
    }
}
...

And yeah, the caveat is, this doesn’t work for the sample cases they give which is absolutely hilarious:

[!] Cannot determine if gifts would fit this region: 4x4, 2 gifts
[!] Cannot determine if gifts would fit this region: 12x5, 7 gifts
Total: 1

Nonetheless, I’m happy so long as it works for the real input.

Oh boy, I would like to skip talking about this exam (because I can barely do it) if it’s possible but I do have some memorable stuff from it.. x) And I hate how you can’t know your code verdict in OSN-P.

At School

I took my OSN-P exam with some senior friends from my school earlier today. I guess I’m a bit pissed off with the exam date because we held several school events to celebrate Indonesia’s independence day today and so I couldn’t chip in. However, on the flip side, I got to bypass the flag ceremony held today—those often make me feel short of breath, so I’m grateful of that.

Some other OSN-P participants and I spent time “preparing” ourselves in a room near teachers’ office. Since the computer science exam starts at 1 PM, we had plenty of time to do stuff. We held a small programming match with problems rated as the easiest ones in CodeForces, but I literally struggled with the first one because I tried to outsmart the by-nature naive problem ahaha. Afterwards, I decided to watch some random science/compsci YouTube videos I can find, listen to some songs, and drank a cool beverage I grabbed from one of the food/drink stands for the independence event.

And then, at around 11 AM, we packed our luggages and made our way to the school where the exam will be held. Everyone from my city went there to do the OSN-P exam. We were brought to the canteen to eat something first but one of the seniors said that they would like to avoid eating anything to prevent getting sleepy. I thought it would be a great idea too, and so I didn’t eat anything before doing the exam.

The Exam

We entered the exam room a bit earlier to set up everything correctly (our proctoring device, laptop, etc). I have prepared everything from home, except for one thing: setting up the Wi-Fi hotspot from my laptop for my phone (as the proctoring camera). I had just 5 minutes left, and since for the exam I used (Artix) Linux, and we all know it—there’s no way one can figure out how to configure networking in just a short amount of time. Fortunately, I still have plentiful of mobile data left, so I had to sacrifice about 2 gigabytes of mobile data just for the Zoom meeting..

Also, I didn’t expect the scene set-up to take forever. I hadn’t gone to the restroom yet, but there was no time left. I didn’t get the urge to pee yet or anything, so I started the exam anyway.

The String Problem

So this was roughly the first problem of the exam:

Congratulations on passing to OSN-P! As a way to congratulate you, Mr. Dengklek will make you a “pretty OSN-P string”.

A “pretty OSN-P string” is a string that:

• Consists of at least one letter of each O, S, N, and P.
• Does not contain letter(s) other than P after a single letter P.

Example: “OSNSPP” is a pretty OSN-P string, but both “OSSSP” and “OSNPS” are not.

Your task is to determine the length of the longest possible pretty OSN-P string Mr. Dengklek can make for you by deleting one or more letters from a given string S. If it isn’t possible to create such string, output “-1”. Otherwise, output the length of the string.

Okay, that’s a cute problem. Actually, it looked like a question from last year, so I tried to think about it the same way I would with last year’s problem. And the great part is that, it works just fine.

Initially, I kept track of the amount of O, S, and N characters up to the i-th index of string S so I can count the length when I meet a letter P. However, I realized that that list alone is not enough, since to maximize the length of the target string, you’d want all the extra trailing P letters after finding one P letter, too. I then added the amount of P characters up to the i-th index of string S. So now, I can just add the amount of O, S, and N characters by the amount of P characters from the current index to the last index whenever I encounter a letter P. The maximum length from all those possible configurations would be the answer.

All good, but it took me plenty of time because of my stupid coding mistakes. One of them is:

best = max(best, cnt[i-1]) + 1 + (p[n-1] - p[i]);

Why is the + 1 + (p[n-1] - p[i]) expression outside the max function 😭 yeah but thankfully I noticed that right away. I hope that I didn’t miss any edge case for this one..

Exploring Other Problems

I knew it was going to be hard onwards after I finished that first question, so I hunted for something doable. Was there any? … No, I wouldn’t say so, but I decided to bet on this one:

Factorization Problem

This was roughly the third problem of the exam:

Mr. Dengklek has a budget of N. In a store, he can buy one or more trays of eggs, where all the trays have size of M × M and each costs M. M is an arbitrary prime number. To make matters easier, Mr. Dengklek will buy trays with just one size. After buying the trays of eggs, he will end up with N/M trays of M × M eggs and he would like to sell the eggs back. Mr. Dengklek would be able to arrange the newly bought eggs in several rectangular configurations all with different rows a and heights b (resulting in tray of size a × b). Note that a × b tray and b × a tray are considered different. Because he doesn’t know what the customer’s preferred tray configuration, he wants to buy the tray of eggs that can result him in the most amount of possible row and heights configurations.

What’s the tray size of the eggs that Mr. Dengklek should buy? If there are more than one possible answers, pick the one with smallest tray size.

For example, if Mr. Dengklek has a budget of 60, then he can buy 30 of 2×2 eggs, 20 of 3×3 eggs, or 12 of 5×5 eggs. Each configuration will respectively result in 2² × 30 = 120 eggs, 3² × 20 = 180 eggs, and 5² × 12 = 300 eggs. For the 120 eggs, he has 16 possible configurations. For the 180 eggs, he has 18 possible configurations. For 300 eggs, he has 18 as well. Because the 3×3 tray is smaller and still give the most amount of configurations (18), he should pick eggs of 3×3 sized tray to buy.

Ah, a math problem. To know the possible tray sizes of eggs Mr. Dengklek can buy, I can just do a prime factorization. Then, a factor-counting function can determine the amount of configurations he can make after buying the eggs. Now, I just have to find the tray that gives the most number of factors. Since the algorithms can be run in O(√N) time, I’m pretty sure the program can run safely below the 2 seconds limit.

Well, guess what, factor-counting and prime factorization were my FIRST ever look at competitive programming problems. If you look at TOKI’s competitive programming book, the intro example codes were all about those discrete math problems. It took me a few days just to get the hang of the example implementations back then. I wondered if I could write the same functions in just an hour or less this day..

I slowly traced the problem and wrote the solution. However, I forgot how to write a factor-counting function midway x) after several times doing factorization by hand, I eventually figured it out though.

So, all good, right?

*tries test case 3 with N = 1000000007*

It’s slow?! I thought that my functions are all O(√N).

Oh, wait, the number of eggs Mr. Dengklek can end up with may be so humongous to the point where the square root of it is no longer small enough for the calculation to finish quickly. Also, integer overflow is concerning at this point. I had to do something. I broke down the equation of the total eggs he’ll end up with, and factorized each terms separately by using a hashmap to accumulate the exponents of each factors before finally counting the number of factors the number has by looping through the hashmap once.

Other Problems

As for the rest of the problems in the exam, I was completely clueless 💀 I’m not even sure if most of them are DP or can be solved by greedy, but I think most of them are indeed DP.

Freezing

The exam room got cold really quickly. We didn’t wear shoes inside the room; I could feel my feet freezing slowly. However, not just that: being in a cold place is an enemy against my typing skill. Maybe I actually coded a bit slower in the exam, I don’t know.

After a while of freezing, I suddenly got the urge to pee. I had to tell the supervisors that I need to go for a bit but apparently they said I only get 3 minutes. And, guess what? The restroom was crowded 😭 I dreaded in panic, but thankfully, half of them weren’t going to pee at all (Universe pranking me?) and I only had to wait for 2 people in line.

I then returned to my chair, still hopeless about the rest of the problems x)

Going back Home

Yeah I pretty much couldn’t figure out any solution in the last hour that I had. How sad. I guess that I’m a bit disappointed, but honestly, everyone I know of was only able to answer just one or two problem(s) as well.

We then drove back to our school after the exam, but the car was completely silent for the most part. I had no idea why my friends didn’t talk much. Anyway, I had to tell everyone about the exam so I didn’t bother to talk a lot to them either, hhaha.

End Thoughts

I actually came out of the room just as happy as before the exam started.

Well, for one, now I can do TWO problems in a contest! I usually can only do one before 💀 (holy crap, that’s actually pathetic). And then, there’s also me proving to my past self that I am able to write code faster than ever! And besides, I still have next year. No biggie.

But also, I think I really enjoyed the companionship of competitive programming friends. That meant a whole lot more to me than the competition itself. I attended trainings with them for this OSN-P, and honestly, there’s always nothing better than having people to talk to about your stupid algorithm with O(2^N) time complexity and stack overflow potentials ;) I can’t see them anymore next year, and that’s unfortunate. I wish all the best for them.

So yeah. That’s probably it for this year! I’m proud as always to see myself improving. I wish that I won’t have to attend training sessions alone next year, will I?

My country, Indonesia, runs an annual Olympiad they call “OSN” (Olimpiade Sains Nasional/National Science Olympiad) for all sorts of subjects: from maths, physics, economics, geography, astronomy, and of course, computer science (just officially called “computer”). To get there, though, is no small feat—because you need to pass two of their exams first: OSN-K and OSN-P, each referring to the city-level and province-level exams, respectively. Oh, and, your (high)school must register you too to be able to join OSN-K—which may require another entrance exam depending on the school you attend.

Now, before we go further, I’d like to point out an interesting observation: this system where you have to pass two exams first—based on your school location—doesn’t really guarantee that the country will actually get the nation-wide top students.

Here’s an example:

• A, B, and C are from city X.
• D, E, and F are from city Y.

Let’s say that A and D won the city-level competition for wherever they live, respectively. Now, you can try to let both A and D compete together and see who would win. For example, A beats D. But it doesn’t really mean that D is second-best at this point, because if A is just so good, A might have beaten B and C (who both may be better than D) before both of them ever get a chance to continue to the next exam. It’s an unfair system, in my opinion..

With that out of the way, though, I’d like to share my funky experience with OSN-K.

Background

You can join OSN beginning from elementary level, but I never really got selected for any. They only had a few subjects too, like math and general science, and I never liked any of them—it’s only in high school that computer science subject (the only subject I like) began to be available.

The OSN-K computer science competition I joined contains questions similar to those you’d find in Bebras, but with more math, plus extra code-reading. Historically, though, pure discrete math questions dominate the question sets. I must say, I like the older questions better— especially the questions from around 2016-2023 that all have more discrete math than mathematical logic with less headache-inducing lore for each questions, which I’m better at. But alas, I was born a little too late, it seems like.

Anyway, their OSN-K official syllabus mentions several topics, such as:

• Discrete math
• Mathematical logic
• Boolean algebra
• Graph theory
• Data structures
• Popular algorithms
• …and general algorithm analyses

Olympiad level questions are pain in the ass to get right (at least for the inexperienced me). And if you can’t get one right, good luck finding the answer—even search engines or LLMs may not be able to provide an answer for whatever your question is. Your best bet is to befriend someone who’s good at Olympiad type of questions.

I was lucky enough to have quite a few of them since the early days of my high school, but I must admit that I was quite shy to ask :p So, early on, I’d dug through questions and try to get answers myself based on help from the internet. I’d still ask people when I got completely stuck, though.

Now, during those “early high school days”, I didn’t study much. I mean, for one, the OSN-K entrance exam at my school wasn’t even held until like 2 months ago. Also, compsci and programming are fun but I never really liked to dive the nitty-gritty theories myself. However, some of my extra-nerdy friends that I knew back then were my main inspiration—they make problem solving seem magical—I felt like I need to have that kind of skills too, which fueled my intents to join OSN-K this year and study for it.

The Club

The first step to join OSN-K was to join the “club” for whichever subject you’re interested in. For me, it was the computer science club. They had an initial entrance exam, too. Frankly, I felt quite pissed off because I originally didn’t get in, somehow (I think I messed up my arithmetics so badly; I was sick that day). I don’t know the details, but a senior of mine helped me to pass in anyway. It seemed odd, because I wasn’t even close to them. Was I thankful? Maybe.. but if I really didn’t deserve a spot then I should have not been allowed to join anyway.

Then, my school provided OSN-K training for club members which you can enter by taking another entrance exam. The entrance exam was actually mandatory for all members, and so I did it. Thankfully, I was accepted (the passing grade wasn’t that high anyway?), so I was slightly more confident that I really did deserve a spot in the club.

The Drilling

Everything had gone well past this point, so I started studying for OSN-K—even if I didn’t know whether or not I will actually join it. It was fun, although I was quite inconsistent :) Just me being me, but maybe it was partly because of my 10000 other side hobbies and school organization things.

How did I study? Thankfully, TOKI (the team that creates all question sets for compsci OSN-K) gave a hell lot of free resources for studying—from a free competitive programming course, a free competitive programming handbook, literally every single question sets they have made, and more. Those were my main resources up to that point.

Mock Exams

I joined some mock exams too for OSN-K. Oof, I was pretty horrible at them. But that was because the mock exams were actually harder than the actual thing :skull: And added with the fact that my arithmetic speed is pretty darn average, I’d certainly flop in many mock exams—most of which were formatted like ancient OSN-K questions from the bronze age or something, all packed with human calculator-level kind of math.

The other reason I was so terrible at mock exams was because I didn’t study the stuff I didn’t like. For instance, I didn’t study boolean algebra—my biggest enemy at that time.

Yet Another Entrance Exam

I was surprised to learn that you need to take another entrance exam for the actual OSN-K (yes, I did not know this early on). Around the same time, I got an offer to join FLS3N—another prestigious national-level arts competition.. BUT WITH AN INITIAL ENTRANCE ART SHOW OFF TEST TOO! I had to make this most off-putting life decision again: compsci or visual art?

I trembled. I definitely did not plan about FLS3N popping up in front of my face at all. Back in middle school, I joined FLS3N too, but I sucked so hard back then—and I felt like I wanted to do a redemption. Hmm.. I suddenly had an idea. I told my art teacher that I will join FLS3N under the condition that I fail my OSN-K entrance test ;P

Not gonna lie, I thought that maybe FLS3N would be better for me after all, since I feel like I hadn’t studied enough for OSN-K. I still had the next year for it, anyway. I then hoped that I would fail my OSN-K test so that I can have a chance to join FLS3N.

I took the entrance exam for OSN-K. It was mid? I couldn’t answer one or two (one of them is really vague), but the rest were fine. Then, yeah, I passed it and I was allowed to join. Man, I hated how my other grade 10 OSN-K participant kept on saying, “I actually did not want to join this, I don’t know why I passed” from since their OSN-K training exam up until the actual OSN-K entrance exam. Haha..

Final Drills

I spent a month or two for some focused self-training. Then, I bought (yes) some question sets alongside their answers and spent another two weeks for absolute maxx drilling I could achieve. I faced all my hatred topics: boolean algebra, set theory, greedy, modular arithmetic, and more.

THE DAY!

I was literally so dramatic the day before the competition, I swear. I treated myself with a Ghibli film, played some arcade games, coded something in Rust (Prefic), and self-reflected so deep as if I was gonna leave the world the next day.. but fair enough, it was kind of relieving and crazy that I had gone that far—considering that I have no experience with Olympiads before.

Okay, now, here’s the fun part: the actual competition day.

We were given a free bread for breakfast, and then we got a bottle of cold mineral water—pretty interesting stuff. How did they even chill the water?

Afterwards, other students across subjects and I took formal pictures together. Then, we all went to our computer lab to take our respective exams. I sat down and wrote down my username and password. When they finally gave us our exam token, I gracefully typed it out and started the exam.

The Exam Itself

Pop! I snapped into the exam questions. And what I saw the first time? *An image-based question*.

Wow, thanks, TOKI! Thank you for giving image-based questions that we have to copy to our paper first if we ever want to annotate it. Very much convenient.

And then there were more image-based questions, and other questions with pretty long lore that I had to read first. I absolutely hated the math and logic section—I was pretty unlucky there—making a few annoying mistakes I could have otherwise noticed if the exam didn’t have a time limit.

For instance, there’s this really annoying combinatorics problem. It was supposedly not too hard, but due to me dabbling with some harder similar problems the days before, my brain’s cache was pretty messed up. I started to analyze the question unnecessarily. I couldn’t finish that problem—dang it! It was quite literally a normal Fundamental Principle of Counting problem. I went galaxies away from that..

And then, I got into the code interpretation section. I was genuinely pissed off at that point, because it turned out that the math and logic part DID NOT CONTAIN TOPICS THAT I STUDIED REALLY HARD, like boolean algebra and set theory. However, I was soon relieved, because the code reading part is way easier—much, MUCH better than last year’s problem set. There’s only one problem: I didn’t have much time left! And while I did not skip any of the code reading problems initially, I could not do the last three ones because I only had 3 minutes left. It was so infuriating! I wish that I had started from the back of the page.

And then, 15 minutes before the exam ends, my keyboard decided to die randomly while I was trying to type out my answer. I legit panicked and called out the supervisor immediately. But as a compsci™ student who knows the best hardware advice ever (turn it off and on again), I yanked out the keyboard’s USB interface and plugged it back—and thankfully, it arose from dead again. Phew.

And so, the exam ended just like that. I had no idea how to feel—months and months of preparations all poured into one single (messed up) day. However, I framed the exam as a milestone and not the end of anything. I’m proud that I took the courage to face the topics I was bad at, and even got hooked to them. That alone is more than good, right? :)

BONUS: Result

The results came out a few days ago. I ranked like 8th in my city and passed the exam LOL. Take that, whoever the hell rejected me from the computer club 💀 You were wrong about me.

Maybe I’ll write about OSN-P soon..

Introduction

DP is a really fascinating programming technique. It solves even the seemingly daunting problems in a linear time! Usually, problems that require you to calculate the amount of ways to solve a problem or to find the best way to solve a problem can be worked out with DP.

But, how does it work?

Well, actually, DP is an application of brute-forcing because it tries every single possible ways to solve a problem. However, this brute-force is optimized by storing the result of already solved sub-problems that the program previously encountered.

DP can be used in place of the greedy technique. The difference between the two, is that with DP, you’d have to map out every possible ways to solve a problem (and either pick the optimum one or count the ways), while with greedy, the optimum way to solve the problem is already known. An algorithm utilizing DP is easier to factual-check because it would’ve seen every of the possible ways to solve a problem, so it is guaranteed that you get the most optimum result.

There are two ways to implement dynamic programming:

• Top-down

  A top-down implementation of DP is done recursively by solving the biggest problem first where we don’t know the solution to our problem yet. We then recursively go solve each one of those, ensuring that we only try to calculate the function call with a particular parameter once. This is done using memoization.

• Bottom-up

  A bottom-up implementation of DP is done by solving the problem that we already know the solution of. Then, we work our way up until we go to our main/biggest problem. This is done by tabulating the result.

Approaching a DP Problem

Here are my steps to solve a problem with DP:

1. Think about how you would build the solution systematically by hand. Since DP is just a brute-forcing algorithm, do not worry about how unoptimized it is—it will be anyways :)
2. Write down the recursive formula for the problem, making use of what’s already known from the solved sub-problems.
3. Determine its base case, i.e a specific sub-problem whose solution is already known.
4. Implement its solution or calculate it.

Example Case: Building a Number String

Let’s go through an example problem.

Given an array {0, 1, 2}, How many ways are there to create N-length string using the three possible numbers for each character, where each character is only allowed to have at most 1 difference from its neighboring character?

Example (N = 2):

{0, 0}, {0, 1}, {1, 0}, {1, 1}, {1, 2}, {2, 1}, {2, 2} = 7 ways

Building By-Hand

How would one manually build a string of length N with the said rules?

We’d want to loop from the first character to the last one. For N = 1 (i.e same thing—the first character), we only have three ways: {0}, {1}, and {2}.

Now, notice that we’re going to have to take the next step(s) differently depending on which number we pick. If we had picked 0, we only have choices {0} and {1} for the next character. If we had picked {1}, we’d have {0}, {1}, and {2}. If we had picked {2}, we’d have {1} and {2}.

So now, when we try to map out the amount of possibilities that we’re gonna have, we get this:

And to get the amount of proper arrangements, we’d just have to calculate all the amount of nodes in that tree.

Recursive Formula

To get our formula, we’d first have to ask, what is our sub-problem exactly?

The main rule of the formula-crafting is that it must not discriminate between differences of parameter, i.e all those 0, 1, and 2’s must be of the same sub-problem.

A helpful way to get our sub-problem is to go to our last step. Assume we’re at the edge of our problem-solving, i.e we’re at the last character. What exactly are we going to do? We are writing the (last) possible character from the choices that we have. And that, is our sub-problem, because (see below) it is recursive (i.e you need to answer a similar sub-problem to get that answer).

Our new question would be: how many ways are there to write the last possible character from the choices that we have? Intuitively, it’s just the ways to append 0 + the ways to append 1 + the ways to append 2.

But, comes the next problems. We don’t even know how to calculate those. So let’s jump through all of them:

• To append 0

  We aren’t always able to write 0. We can only write 0 if our previous character was 0 or 1. Therefore, the total ways to write 0 when length is $ x $ is the ways to write 0 with length $ x-1 $ + the ways to write 1 with length $ x-1 $. Those are all the possibilities that make us able to write 0 at position $ x $.

• To append 1

  Same thing here, we can only write 1 if our previous character was 0, 1, or 2. The ways to write 1 when length is $ x $ is the ways to write 0 with length $ x-1 $ + the ways to write 1 with length $ x-1 $ + the ways to write 2 with length $ x-1 $.

• To append 2

  Also the same. The ways to write 2 when length is $ x $ is the ways to write 1 with length $ x-1 $ + the ways to write 2 with length $ x-1 $.

Let’s simplify a bit. Assume that the solution to our original question is defined as f(x). And:

• a(x): ways to append 0 with length x
• b(x): ways to append 1 with length x
• c(x): ways to append 2 with length x

Therefore:

• f(x) = a(x) + b(x) + c(x)
• a(x) = a(x-1) + b(x-1)
• b(x) = a(x-1) + b(x-1) + c(x-1)
• c(x) = b(x-1) + c(x-1)

Making Our Base Case(s)

We have to make our recursion finite, so we need a base case. A base case is a problem whose solution is already known.

Now, it’s helpful to go to the start of the problem instead in this case–when we don’t have anything yet. When we first append a character (this is f(x)), there’s only 3 choices: append 0, 1, or 2. Or, in other words, f(1) = 3.

But since f(x) is composed out of a(x), b(x), and c(x), it’s a lot more helpful to find the base cases for those functions:

• a(x)

  When x = 1, it means the amount of ways to append 0 with length 1. There’s nothing previously, so obviously, there’s only one way to append 0 which is our first step in building our string.

• b(x)

  Same thing as above. There’s only one way.

• c(x)

  Same thing as above.

Now this does check out, as f(x) = a(x) + b(x) + c(x) and f(1) = 1 + 1 + 1 = 3.

Our Formula

And

Calculating & Implementation

I’ll use bottom-up DP to fill a table, then display all the function call values (C++). Bottom-up approach is usually more preferred as we don’t get affected by function call overhead—and we can do a lot more interesting stuff with it!

Disclaimer: why C++? It’s nice for competitive programming scripts haha

#include <iostream>
using namespace std;

int main() {
	int N;
	cin >> N;
	int f[N+1];
	int a[N+1];
	int b[N+1];
	int c[N+1];

	a[1] = 1;
	b[1] = 1;
	c[1] = 1;

	f[1] = a[1] + b[1] + c[1];

	cout << "f(" << 1 << ") = " << f[1] << "\n";

	for (int i = 2; i <= N; i++) {
		a[i] = a[i-1] + b[i-1];
		b[i] = a[i-1] + b[i-1] + c[i-1];
		c[i] = b[i-1] + c[i-1];
		f[i] = a[i] + b[i] + c[i];
		cout << "f(" << i << ") = " << f[i] << "\n";
	}
}

So now, when we give some value for N:

$> ./program
10
f(1) = 3
f(2) = 7
f(3) = 17
f(4) = 41
f(5) = 99
f(6) = 239
f(7) = 577
f(8) = 1393
f(9) = 3363
f(10) = 8119

it will print the filled table.

Complexity Analysis

The time complexity of this is always O(N), as the loop iterates over N times. The space complexity, however, is O(N) as well because we store all the resulting solution of our sub-problems. We will optimize it in the next section.

Optimizing

Notice that we only need to access our previous result, because in all our recurrence relations, we only use the parameter $ x-1 $.

This means that storing the whole table is redundant, as we can simply only store the previous result:

#include <iostream>
using namespace std;

int main() {
	int N;
	cin >> N;
	int a_prev = 1;
	int b_prev = 1;
	int c_prev = 1;
	int f_prev = a_prev + b_prev + c_prev;

	int f, a, b, c;

	cout << "f(" << 1 << ") = " << f_prev << "\n";

	for (int i = 2; i <= N; i++) {
		a = a_prev + b_prev;
		b = a_prev + b_prev + c_prev;
		c = b_prev + c_prev;
		f = a + b + c;
		cout << "f(" << i << ") = " << f << "\n";

		a_prev = a;
		b_prev = b;
		c_prev = c;
		f_prev = f;
	}
}

And with this, we get O(N) time complexity and O(1) space complexity. Awesome!

References

• TOKI’s Competitive Programming Guidebook

The equipments for the booth had been prepared a few days back: a DSLR camera, some photo paper, a photo booth software, and my printer (like, I actually brought it to my school). We also got some props for use—most are from school but one of my team members asked their friend to bring a snake plush—best prop ever.

A Divine Intuition

We actually knew that our camera didn’t wanna communicate properly with our photo booth software, but I had figured out why—or at least, I thought so, because the next day while I was actually setting up the camera, it decided to not work again. And under that panic mode I hypothesized that maybe the software couldn’t read the raw files that the camera sent, so we changed the output format to JPEG from the camera and then everything went in peace again.

And that was weird, because I did not recall doing that the previous day. All I did was to set the camera mode to automatic and inserted an SD card to it. Oh well, at least we got it to work.

Racing Against Time

A few minutes before we opened the booth, I noticed a degradation of our print quality after some testing. I thought that it was my printer’s usual hiccups, as the colors would get messed up after a while of printer. Oh well, it was apparently because I forgot to unlock the cartridge after it was carried here. I quickly went to do some head cleaning, praying that it would be finished before anything actually starts.

Alas, the recess bell soon rang and people rushed to our place. Okay, not rush, there were just a few, but people were already waiting. My printer wasn’t done yet, but we could still take photos anyways so it was fine. And the moment I truly needed it to print, it actually worked. Phew, that was close. Then I professionally™ hit the print button and completed our first order.

Unending Stream of People

..and the orders went on endlessly during the second recess (when the rest of the Chinese events had started). Oh boy, that was fun. But for some reason my order sentence processing skills were so bad, I had to ask my friend to repeat what our friends wanted a few times. The words were like, all just nonsense numbers to me—because yes we have 3 photo strip designs, and I don’t know whose idea it was (mine) to label our designs by numbers instead of by their color—so each time somebody comes, the instruction given to me would sound like “two two once, one two twice” or “two three two, one one two” or whatever. Sure I do maths, numbers, but I just cannot cope with these. :cryingemoji:

The Peak Event

I went to watch some performance during the peak event with my friends. We were veryy late though which was disappointing. I forgot why, probably because I had some extra photo orders qwq

Heyy it’s a booth for five!

After the event is done we all got free dimsum provided by our school..! Totally the weirdest thing to get (at least when written like this), but we did. And let me tell ya they actually tasted good.

Okay, even after the whole event is already finished, there were still a queue of people. Urgh. So then I continued to stand by the booth while feasting on my dimsums.

Anyways, let’s get to the funnier part. One teacher proceeded to come with her whole class to take a picture at our place. They consisted of around 20 people or so. Heyy, it’s a booth for five! But a student from grade 11 (I assume from her homeroom?) brought their wide DSLR lens and swapped ours with their lens and saved the day :3 I had some talk with them and it turns out that they were one of the people who managed Excelsior’s photo booth last year (2024), aha.

And No, I’m Slightly Annoyed

So yeah thanks booth, I totally like not getting any time to spare for enjoying the Chinese New Year event for myself—it was the last event for 12 graders; I didn’t get a lot of time to spend for my 12 grade friends. Sad. But I mean, taking pictures is also fun, I guess :D And hey we raised like roughly a million Rupiahs (gross)!

I’ll rewind a bit though.

The Interview

It was a normal interview. Had it like last year. The results took forever to be announced. The interview was actually scary. They literally took notes about me there, judging various aspects bout me as I speak. Except that.. somehow the teacher didn’t pay attention haha. But anyways, I had prepared my strategies: pretend I love IT sooo much ;) (I do, but phrase everything in a really cool™ way). And plus, I was the coordinator for tech division back in middle school so I already got free plus points.

So Far So Good

Thankfully, this year, I don’t need to actually manage the Instagram account directly. I’m just a member. I actually expected a lot less work but it turned out that I was wrong! High school student council is dead serious.

Ah yeah, I didn’t write anything about my middle school student council experience. In a nutshell, I never got the positions I wanted. During the first year, I barely did anything meaningful and during the second year, I didn’t really enjoy working with my team as the coordinator.

Okay, back to high school student council. This organization is really dead serious. The amount of tasks I get is actually quite decent considering I’m the only grade 10 student in the tech team (the rest are from grade 11, okay I’m proud of that). So I’ve done like a few designs maybe? Not too many, I’m more involved with giving feedbacks and handling events. So far it’s great, we all work cooperatively together. Really nice team, I love it.

Catch: No Website??

Here’s the less exciting part of the tech team: we proposed to get a website for our student council but it was rejected. The reason? Somehow because “we already have official school site”. Yet, I saw another campus of my school having a site for their student council, written with React!!! And also by the way our Excelsior site exists. How is that fair? Back in middle school I got to make one. It’s here, by the way (in Indonesian). Depending on my future outlooks, I may or may not want to repropose that site again next year. Maybe if I’ll get trusted to be the coordinator.

The First Amazing Event

My first scbool event as a student council organizer was the Chinese New Year event. I don’t know why we have one, but we do somehow. It’s our debut actually, we didn’t have it previously. The tech division had two events there: our photo booth and a photography competition. I was the PIC of the photo booth. And I’ll talk about it on my following blog post! ;)

I quickly scrolled through each of the questions. I saw a decimal-to-binary base conversion question which I thought would be easy, so I gave it a shot. Well, it was only theoretically easy.

It was my end’s fault: I did not understand the second task of the question before starting to write the code. The second task was actually to count the longest repeating 1’s or 0’s for each of the test cases. They didn’t explicitly say “the longest”, though, so it baffled me for a while. I dismissed that part and proceeded to write the base conversion first.

I tried doing the calculation inside my recursive function, but it was a bit confusing, so I decided to opt for a string-generating function instead. Let’s say that I ended up having a function similar to this:

string convert_number(int number) {
	int n = number;
	string s;
	int num_pow = floor(log2(number));
	for (int i = num_pow; i >= 0; i--) {
        int pw = pow(2, i);
		int digit = n / pw;
		s.push_back(char(digit));
		n -= digit * pw;
	}
	return s;
};

Now, there’s a part I had to look up online: how to turn a single digit of number into an ASCII character. I quickly skimmed a guide and read about static_cast<char>(x) and char(x) which I thought was plausible.

And so I did that, only to get even more baffled because the string I was returning was literally empty. Or at least, I thought it was empty.

Don’t laugh at me. Yeah, that conversion literally translates the integer into the corresponding ASCII character based on the code. So the 0’s and 1’s turn into NULs and SOHs, respectively. But I was really in panic mode, so I didn’t notice that until like 30 minutes before the whole competition ends (we had 2 and a half hour). I should’ve added an offset to the resulting character (i.e '0' + x) to get the proper ASCII character.

Lesson learned: read an article with my eyes wide open even when I’m under pressure. Saves so much time and headache.

My Misfortune Doesn’t End..

After that one question, I looked for another good question. I grabbed a seemingly mind-boggling but short one. It’s usually better for me since I get easily overwhelmed with long questions.

This is roughly the question (with the story stripped away):

Given an N x N map matrix containing either 1 or 0 for each of the cells—where 1 represents land and 0 represents sea, determine the amount of islands that exist and the area of the largest island. Vertically and horizontally continuous 1’s are counted as one island.

Example:

N = 5

1 0 0 0 1

0 1 1 1 0

0 1 1 0 0

1 0 0 0 0

0 0 0 0 0

Answer: 4 islands and the largest area is 5.

Now for this one, I felt enlightened as if I ascended to some miraculous place and was told the answer by The Divine themself. Jokes aside, this is actually dead simple, so okay. Just travel the map while taking note of which cells have been visited and the size of an island when we found a land. But let me tell you, recursion is one of my weakest areas of programming, yet my hypothetical recursive algorithm from my imagination actually worked after just one try of implementation..

..plus one or two tries of debugging. Which took around 15 minutes. And, guess what, the code was complete 13 minutes after the competition had ended.

int check_tile(int w, int h, vector<vector<int>> &map, vector<vector<bool>> &travelled_list, int x, int y) {
    // beyond the edges
	if (x > w - 1 || x < 0 || y > h - 1 || y < 0) {
		return 0;
	}

    // travelled already
	if (travelled_list[x][y] == true) {
		return 0;
	}

    // no island
	if (map[x][y] == 0) {
		travelled_list[x][y] = true;
		return 0;
	} else {
        // there's an island
		travelled_list[x][y] = true;

        // size of a particular island is the size of the tile itself (1) plus the size of the island nearby.
		return 1 +
        check_tile(w, h, map, travelled_list, x - 1, y) +
        check_tile(w, h, map, travelled_list, x + 1, y) +
        check_tile(w, h, map, travelled_list, x, y - 1) +
        check_tile(w, h, map, travelled_list, x, y + 1);
	}

}

void solve(vector<vector<int>> map) {
    ...
	for (int i = 0; i < h; i++) {
		for (int j = 0; j < w; j++) {
			int area = check_tile(w, h, map, travelled_list, i, j);
			if (area > 0) {
				islands += 1;
				largest = std::max(largest, area);
			}
		}
	}
	cout << largest << " " << islands << "\n";
}

..goodbye I am so not getting into the finals. Answering only two questions out of eight and only submitting one? That’s stupid!

So in conclusion: humans can get pretty stupid under pressure. But also brilliant sometimes. You’re very lucky when the latter happens to you. The first one is rare. Experiencing both at the same time is even more rare but still sucks.

Wait, You’re With Your Team, Though?

Admittedly, they’re not that good at programming. They barely helped with anything meaningful yesterday. I still appreciate their efforts, though. It was still fun anyways :P However, I did not really enjoy the teamwork (there’s nearly none anyways for yesterday¹ in particular). Why are good or even decent programmers so rare yet so common?

Okay, I wouldn’t say that “recently”. For instance, Fedora 25 was released way back in 2016¹ and had already shipped GNOME with Wayland by default. The option to use X11 was still there though—up until the latest version (as of when I wrote this post), Fedora 41². In another case, Ubuntu shipped Wayland by default again with its 21.04 release after receiving negative feedback back when Canonical first poked with Wayland in 17.10³. It’s now kinda obvious that Wayland has only veeery recently becoming actually usable.

My first ever Linux distribution was Ubuntu 20.04 LTS which came with X11 by default. Funny enough, exactly 4 years ago (as of when I wrote this post) marks that date. I never really used Wayland in any meaningful way since then—at least up until recently. Maybe I did try GNOME and KDE Plasma under Wayland a few times back then, but honestly, I’m never really a big fan of full-fledged, out-of-the-box desktop environments where Wayland happens to be a lot more mature that time, so I had to rely on X11 to prevent myself from getting headache.

An Excuse to Try Wayland

A while ago, I was handed an ASUS VivoBook Flip 14. It’s around 4 years old, but definitely still usable. I then started to use it as a school laptop because my main laptop is quite massive. I was unsure about which distro I should use and how to configure my desktop though, as I’m not a big fan of simply copying from my old setup. Plus, my old i3/Qtile setup was mainly keyboard-focused and is pain to navigate with touchscreen. I went with Chimera Linux and GNOME for a fresh start, and it was surprisingly great for something that uses Wayland, musl, FreeBSD core utilities, and its own package repository. Truly impressive what desktop Linux has evolved into.

First Use of GNOME Under Wayland

At that point I was really enjoying modern GNOME (I had never used GNOME >=40 for a long time). I’m really impressed with how it handles my lid switch pretty well—the automatic on-screen keyboard works perfectly. My touchscreen works in majority of apps and actually makes sense, i.e it’s not just emulating a mouse but actually behaves like how you expect in phones/tablets. My stylus pen (which, by the way, uses Microsoft’s Pen Protocol) also works out of the box which was veery surprising for me.

Whoops, no video or anything, though. I did not have the plan to write this post back then :P

Piecing Together A Desktop with Wayland

Unfortunately, I gotta admit, Chimera is simply too annoying for daily use. As something that I only use once or twice a week it is actually more than perfect, but they flat out refuse to package old software (like Qt 5) and therefore their dependents (like Krita). As time goes on, I started to use this ASUS laptop more and more often, and I then decided to hop into something more usable for now. I was a bit overwhelmed about the choices available at first, but I decided to just go with Artix Linux since it’s what I daily drive on my other laptop.

Again, as I do not like out-of-the-box desktop environments because of its “learn to use” rather than “define how to use” approach, I had to make another confusing choice of which window manager I should use. My friend began experimenting with Hyprland quite some time ago, and then I recommended it to my other friend (somehow it was his first taste of Linux desktop, he’s a madman). After seeing that they both have 0 complaint I decided to try Hyprland for myself.

It wasn’t my first time with Hyprland, though. Quite some time ago, I tried CachyOS and went with Hyprland as well (on my other laptop), but I stopped customizing it after I failed to configure plug-ins through hyprpm. It kept on complaining about unmet dependencies despite me having everything it mentioned already. After some digging of the source code, it turned out that hyprpm did not mention pkgconf as its dependency -_- But don’t worry, that’s fixed already as of now.

So then, after having everything ready, I started ricing my setup =D Not too big of a tweak, I only changed key-binds and customized my Waybar status bar with relevant information. I also used hy3 to match how i3 manages windows. After a while, my desktop is ready for use!

..well, almost. The problem is that, this is barely leveraging the fact that the laptop is a convertible. I still have touchscreen gestures and on-screen keyboard to take care of.

Gestures

Hyprgrass is an awesome Hyprland plug-in that provides you the ability to assign dispatchers to touch events. I have these:

hyprgrass-bind = , swipe:4:d, hy3:killactive
hyprgrass-bind = , swipe:4:u, fullscreen, 0
hyprgrass-bind = , swipe:4:r, hy3:movewindow, r, visible
hyprgrass-bind = , swipe:4:l, hy3:movewindow, l, visible
hyprgrass-bind = , swipe:3:d, exec, $menu

I definitely do not plan on using my window manager solely with my fingers since that sounds hilarious (or not really, but still), so that’s more than enough for me.

Oh yeah, speaking of touchscreen, I used nwg-drawer for my app/power menu ($menu above) since it’s the most touchscreen friendly standalone solution that I know of.

I can do these:

(Ignore the keyboard for now, I will talk about that under the next section!)

On-Screen Keyboard

I found Squeekboard which is originally written for Phosh, GNOME’s mobile environment. It actually worked out-of-the-box, except for the automatic triggers which I had to take care of myself.

Squeekboard follows the rule that it will show up when an input field is focused and the screen-keyboard-enabled has its value set to true under org.gnome.desktop.a11y.applications in the user’s dconf configuration schema. The first point is straightforward, but the second one we need to tweak a bit with gsettings:

gsettings set org.gnome.desktop.a11y.applications screen-keyboard-enabled true

With that set and Squeekboard launched, an on-screen keyboard should appear under compatible apps (all GTK+ apps and several others).

Now, I need to set that dconf value to false when I’m not rotating it to use it like a tablet. This was automatic under GNOME but I’m not sure about Hyprland, so I just looked for sources of events.

Apparently, you can use libinput to listen to events emitted by the lid switch (you can use libinput list-devices to get the event device path):

$> sudo libinput debug-events --device /dev/input/event20
-event20  DEVICE_ADDED                Intel HID switches                seat0 default group1  cap:S
 event20  SWITCH_TOGGLE               +0.000s	switch tablet-mode state 1
 event20  SWITCH_TOGGLE               +1.496s	switch tablet-mode state 0

Now with a little bit of shell script magic I can write a magic ““daemon”” that toggles the dconf configuration value:

#!/bin/sh
# Tablet mode daemon.
TMPFILE="/tmp/.squeektablet"

if [[ -f "$TMPFILE" ]]
then
	echo "Daemon already running. Remove $TMPFILE to proceed."
	exit 1
fi

cleanup() {
	rm "$TMPFILE"
}

touch "$TMPFILE"
trap cleanup SIGINT SIGABRT

dev="$(libinput list-devices | grep "HID switches" --context 1 | tail -n 1 | awk -F '           ' '{print $2}')"

# If this is being executed the first time then the user must have
# triggered the tablet mode to on.
# May also not be the case, but we don't want
# inefficiencies.
toggle-squeekboard "tablet"

# Sleep to make sure the device is already available
sleep 2s
libinput debug-events --device "$dev" | while read log
do
	echo "$log" >> /tmp/squeekboardd_log
	if echo "$log" | grep "state 1" &>/dev/null
	then
		toggle-squeekboard "tablet"
	elif echo "$log" | grep "state 0" &>/dev/null
	then
		toggle-squeekboard "disable"
	fi
done

Where the toggle-squeekboard just comes from:

#!/bin/sh

status="$(gsettings get org.gnome.desktop.a11y.applications screen-keyboard-enabled)"

if [[ $# == 0 ]]
then
	if [[ "$status" == "true" ]]
	then
		gsettings set org.gnome.desktop.a11y.applications screen-keyboard-enabled false
	else
		gsettings set org.gnome.desktop.a11y.applications screen-keyboard-enabled true
	fi
	exit
fi

if [[ "$1" == "tablet" ]]
then
	gsettings set org.gnome.desktop.a11y.applications screen-keyboard-enabled true
else
	gsettings set org.gnome.desktop.a11y.applications screen-keyboard-enabled false
fi

The toggling logic in the script, is uhm, weird, but it’s fine for me. Definitely customizable if you’re willing to copy my approach.

However, I found out that simply launching the daemon does not work well. This is because the input device is not registered before I actually rotate my lid by 360°, as you can see with this kernel message example:

[   40.320906] intel-hid INT33D5:00: switch event received, enable switches supports
[   40.321033] input: Intel HID switches as /devices/platform/INT33D5:00/input/input28

and only then the input path would actually exist. This meant that I have to start the daemon after the input has been registered. Sounds like a udev rule moment, doesn’t it?

/etc/udev/rules.d/30-tablet.rules:

ACTION=="add", SUBSYSTEM=="input", ATTRS{name}=="Intel HID switches", RUN+="/usr/bin/user-squeekboard"

and lastly, the user-squeekboard is a hacky script that switches to my user and executes the actual Squeekboard daemon (because otherwise it would get executed under the root user):

#!/bin/bash
PATH="/usr/bin" XDG_RUNTIME_DIR=/run/user/1000 su cikitta -c 'hyprctl -i 0 dispatch exec squeekboardd' &> /tmp/.squeekboard_daemon__log
exit $?

All those sound really janky and dirty, but at least it works :) Maybe one day I will write a daemon that executes a user-defined command while listening to input device events, that’s going to be useful for standalone window managers/compositors.

(Bonus) Alternative Input Method?

I was trying to set up several input methods that use IBus and I had set up all the needed environment variables under /etc/environment:

/etc/environment:

GTK_IM_MODULE=ibus
QT_IM_MODULE=ibus
XMODIFIERS=@im=ibus

However, I realized that it broke my Squeekboard instead. Spent hours of debugging just to found out that it was a few lines of variables that’s messing up my entire workflow! Ughh… I’m not really sure how to set IBus alongside it, let me know under the comments section if you do know how to! :)

Is It Perfect?

I haven’t encountered any major issues so far. But yeah, touchscreen support is still slightly whacky. For example, I can’t even properly double-click to enter a directory in Thunar :P But other than that I don’t think anything is hindering me from daily driving it.

Under The Hood Look

First Impressions about Wayland

Wayland handles inputs reaaaalllly well⁴. I am especially impressed with the touchscreen, lid switch, and stylus handling (although I haven’t tried those in X11, so this isn’t really a comparison). I thought that I have to poke around with configuration files for exotic peripherals, like in X11. Yes, somehow it’s the 21st century and I still had to write X11 configurations (notably with my Huion graphics tablet)⁵.

The other thing I really like about Wayland is how it has protocols for specific features of a desktop. Or, honestly, Wayland is just a bunch of protocols anyways. For instance, think the virtual keyboard protocol. It is highly specialized on that specific virtual keyboard feature. Then, compositors can adapt and implement it.

On the contrary, X11 is mostly focused on the displaying side of the job and not other desktop environment-supporting features. Some things are kinda hacked together in X11, creating a Frankenstein desktop that consists of programs that work on their own way talking to the display server.

And also, one last thing I’m really impressed about is the fact that I can actually share my screen with Vencord under Hyprland with the helf of its XDG Portal. This is crazy cool.

Architecture Design

While it is true that Wayland is designed to replace X11⁶, it really is a reinvention of the wheel (just see the high-level overview of the architecture). As you probably already know, Wayland protocols removes the need for an extra display rendering middleman between applications and the kernel. Wayland allows applications to directly talk to its compositor (analogous to a window manager under X11), as opposed to X11 where applications need to talk to the display server and don’t directly communicate with the window manager. Wayland’s approach definitely increases performance and maintainability.

With this kind of architecture, each compositor would have to handle many, many things on its own: input, multi-monitors, etc. From the user’s perspective, this can cause slight annoyance as this means that they have to reconfigure every single compositor they attempt use for even the most basic settings like keyboard layout and input options. I wouldn’t say that it’s necessarily a major deal breaker, though. After all, it’s not like you switch compositor every month, right? Riiight? Having a centralized place to configure everything isn’t bad either—it’s sort of the kind of thing you expect from big, major operating systems.

Okay, What’s REALLY Wrong With Wayland Then?

In my opinion, there are really two reasons why Wayland is still a problem: lack of adoption and lack of agreement upon protocols and its details. The first one is certainly expected. With lack of support in several areas, Wayland became less usable, so some people are hesitant to use it, which then causes less adoption, and it loops. But more and more people are already doing the shift slowly! At one point it wouldn’t be a problem anymore. The last one, however, is really something worth looking at. As Wayland is still a big work in progress, it is still receiving a lot of updates and there has been a lot of disagreements throughout its development. Here’s an instance of a protocol disagreement. But all these really arose due to the large fragmentation in the Linux desktop, so it’s to be expected.

Final Thoughts

Wayland is finally mature enough for daily use and it’s fantastic. Even though its architecture and attempt at replacing the crusty X11 is still a really hot debate, I can see it having a big potential in becoming the next display architecture for modern Linux desktop as it contains native protocols (still work in progress) that support many features a modern desktop would have. I would totally recommend trying out Wayland.

Last year was crazy—I did some remarkable things. Kinda. There are always things to be disappointed about—as how humans always been, but I’m proud of myself nevertheless! I’m really thankful for everyone who has been part of my journey last year and I’m looking forward to write even more stories together! :) I wish to find new experiences in my life, meet new people, learn a bunch of new things, try to stay persistent and also be a lil more organized X)

My biggest goal for this year is probably to try to get my draft comic, Threaded!, published. It’s a lil comic that revolves around low level Linux. I think you’d like it :)

So, as usual, good luck everyone!!

Bonus Bits

My Holiday

Nothing special, really. I went camping again, as usual (I often do that, it’s almost an annual thing). The view there is nice:

Looking back at 2023

I have this whole time capsule thing where I dump random interesting things I may find interesting in the future. I’m supposed to open it at the very end of a year. This is the first time I’m able to open it, so I was very excited.

The problem is, I wasn’t at home during the last few days of 2024 and I forgot to bring my time capsule box, so I had to open it in 2025 which is a bit disappointing. But eh, it is what it is.

The box is hilarious to say the least. I actually do not remember writing some deep messages back then. Past me gave some really supportive and constructive messages it seems like. Past me also asked about some things in the future (well, now it’s now). My favorite questions from that are probably, “Do you like high school?” (oh heck yeah) and, “Did you get ranked in middle school?” (also kind of yes but not first). I also talked about my past concerns there, and it’s kinda awesome seeing that the things I once worried had come to fruition and I can finally answer all those uncertainties.

My favorite thing from the box is probably this.. let’s say a “handheld beach” ^o^ I don’t even remember where I collected the sand, corals, and shells from, but I think it predicted something in 2024 that’s sea-related (spoiler alert: my school event), ahaha.

Neo!

Neo turned a year old yesterday! (by the time I wrote this blog =D)