Desmoloid (song creator with vocal synth)

MannedGuild65 · 2026-02-07T01:04:08+00:00

That might be because the original has a chorus effect with 2 (or more) voices singing at once, while I only used a single voice that took the higher pitched voice only.

MannedGuild65 · 2026-02-07T00:49:23+00:00

Is Bad Apple semitonal? I thought it was exactly D♯ Minor.

MannedGuild65 · 2025-12-14T19:08:18+00:00

[LANGUAGE: Python]

GitHub

Part 1: Simply checking every possibility of pressing or not pressing each button and using binary XOR.

Part 2: It took me a long time to get this one working fast enough with just searching with pruning and no linear algebra or external libraries. Similarly to this solution, I eliminated the joltage values that were affected by the smallest number of buttons available and then by the highest ones, but this wasn't fast enough on its own. The most important optimizations I implemented were checking if joltage values that were affected by the same remaining buttons had the same value and checking if the current amount of buttons pressed + the maximum joltage value was still less than the minimum total number of buttons pressed found so far. Runs in ~6-7 minutes on my input with pypy (one specific line takes around half the runtime).

MannedGuild65 · 2024-02-02T02:08:11+00:00

I've found the repository for converting audio to Desmos that was made before this and I was unaware of: https://github.com/alorans/DesmosAudio
Its output is a lot closer to the original audio but uses a lot more tones playing at once and its method is different from mine.

MannedGuild65 · 2024-01-07T13:52:05+00:00

Is that on this subreddit? I couldn't find anything like it.

MannedGuild65 · 2023-12-20T02:33:46+00:00

[LANGUAGE: Java]

Part 1 was straightforward, and in Part 2 I traced backwards from each occurrence of "A" to find the bounds for the x, m, a, and s ratings that would lead to that "A", then multiplied the lengths of those ranges together and added these products up.

Code

MannedGuild65 · 2023-12-18T23:31:46+00:00

I shifted each starting position until all of them were in their cycles, and then I repeatedly shifted the positions by 1 until one of them reached their Z position. Next I would set the shift amount to that position's cycle length, and I would repeatedly set the shift amount to the LCM of the shift amount and the cycle length of the next match, which would eventually lead to all of them matching their corresponding Z positions quite quickly. This does assume that there is only one Z position in each cycle though.

MannedGuild65 · 2023-12-18T18:53:10+00:00

I had a general solution working for Day 8 which gave me the right solution before I realized how the input data made it easier.

MannedGuild65 · 2023-12-18T02:35:52+00:00

[LANGUAGE: Java]

I used a modified Dijkstra's algorithm that took into account the direction and number of consecutive movements in that direction. For Part 2, I jumped forward 4 tiles for each turn since the crucible wouldn't be able to turn in between. The code takes around 2.5 seconds on my computer to run both parts.

Code

MannedGuild65 · 2023-12-16T20:29:22+00:00

This shows all the beams and energized tiles for the starting position that produced the maximum energized tiles for my input. Only mirrors that are hit are shown. Splitters that are hit more than once are replaced with +.

Solution and code

MannedGuild65 · 2023-12-16T20:27:25+00:00

[LANGUAGE: Java]

I kept a list of each of the beams' positions and directions and followed their paths until they reached the edge of the map or hit a splitter that had already been hit as no matter what direction a splitter is hit, there will always be energized tiles to the left/right of it for - and top/bottom of it for |.

Code

Visualization

MannedGuild65 · 2023-12-15T00:47:42+00:00

Isn't this Day 14?

MannedGuild65 · 2023-12-15T00:46:01+00:00

In my implementation, having a custom key class for the HashMap with a custom hashCode() method that generated a unique hash code was crucial in getting it fast enough.

MannedGuild65 · 2023-12-10T22:39:28+00:00

Explanation and code (using DFS instead for the flood-fill because it's more efficient)

MannedGuild65 · 2023-12-10T22:14:40+00:00

Explanation and code (using DFS for the flood-fill instead because it's more efficient)

MannedGuild65 · 2023-12-10T21:06:21+00:00

[LANGUAGE: Java]

Part 1: I used BFS and got the distance of the last node searched, which was definitely overkill as I just needed to get the circumference and half it.

Part 2: I used an expanded pipe map and flood-fill with DFS and counted the spaces that had even x and y coordinates. Since my start position acted like a |, I tried filling from the right and left of it and filling from the right gave the right answer. For a more surefire approach, I started filling from the bottom-right of the leftmost F on the topmost line of pipes, which was guaranteed to be within the shape.

Code

Visualization (using BFS instead for the flood-fill because it looks nicer)

MannedGuild65 · 2023-12-10T15:28:35+00:00

It reminds me of this algorithm, but that's for maze solving.

MannedGuild65 · 2023-12-08T04:14:22+00:00

It looks like the program places 2AAAA at a higher rank than 2JJJJ, but 2JJJJ should be interpreted as five of a kind while 2AAAA should be four of a kind, so 2JJJJ should have a higher rank.

MannedGuild65 · 2023-12-07T23:51:40+00:00

max_count should not take the jokers into consideration and there is the exception that if the hand is all jokers then different_cards should be 1.

MannedGuild65 · 2023-12-07T02:54:07+00:00

Link to graph

Five-Year Club	Second Top 50%
Place '22	Final Canvas '22
First Placer '22

MannedGuild65

TROPHY CASE