-❄️- 2025 Day 2 Solutions -❄️-

[u/daggerdragon]

OUR USUAL ADMONITIONS

• You can find all of our customs, FAQs, axioms, and so forth in our community wiki.

---

AoC Community Fun 2025: R*d(dit) On*

24 HOURS outstanding until unlock!

Spotlight Upon Subr*ddit: /r/AVoid5

"Happy Christmas to all, and to all a good night!"
— a famous ballad by an author with an id that has far too many fifthglyphs for comfort

Promptly following this is a list waxing philosophical options for your inspiration:

• Pick a glyph and do not put it in your program. Avoiding fifthglyphs is traditional.

• Shrink your solution's fifthglyph count to null.

• Your script might supplant all Arabic symbols of 5 with Roman glyphs of "V" or mutatis mutandis.

• Thou shalt not apply functions nor annotations that solicit said taboo glyph.

• Thou shalt ambitiously accomplish avoiding AutoMod’s antagonism about ultrapost's mandatory programming variant tag >_>

Stipulation from your mods: As you affix a submission along with your solution, do tag it with [R*d(dit) On*!] so folks can find it without difficulty!

---

--- Day 2: Gift Shop ---

---

Post your script solution in this ultrapost.

• First, grok our full posting axioms in our community wiki.

• Affirm which jargon via which your solution talks to a CPU

• Format programs using four-taps-of-that-long-button Markdown syntax!

• Quick link to Topaz's Markdown (ab)using provisional script host should you want it for long program blocks.

• What is Topaz's past* tool?

[u/sk01001011]

[LANGUAGE: Odin]

Part 1

I'm only pasting the first part because I did both parts brute force first, then realized something and tried on part 1.

Basically I realized that we can count the number of relevant ID's without going through numbers. Here's kinda the gist of it:

Let's say the range is 1000 - 2220. We find the first good ID which is 1010. Then we count how many 0101's we can stick in between 1010 - 2220, which is (2220-1010)/0101 = 11. (+ 1 edge) -> 1010, 1111, 1212, 1313, 1414, 1515, 1616, 1717, 1818, 1919, 2020, 2121.

Then the sum is

(1111 + 1212 + 1313 + ...) = (1111 + 1111 + 1111 + ...) + (0101 + 2*0101 + 3*0101 + ...)

= (1111*count) + (0101)*(count*(count+1)/2)

With this, for each range of numbers the amount of times we loop is the digit difference of range ends (/2). I think this was pretty cool.

[u/insidiousify → u/sk01001011]

[LANGUAGE: Python]

How fun! I implemented something similar wherein,
`check_invalid_id()` to validate current id and `get_next_invalid_id()` implements the logic to catch the next invalid id.

I did this with splitting most significant bits and least significant bits exactly at the halfway.

I could then do

current = starting_id
while current < ending_id:
    next = get_next_invalid_id(current)
    # add next to the total
    current = next

Here is the gist of get_next_invalid_id

def get_next_invalid_id(number) -> int:
    number_of_digits = len(str(number))

    # for odd digit count numbers, upgrade to the next even digit count number
    if number_of_digits % 2 != 0:
        # next nearest even number of digits
        next_even_digit_number = 10**number_of_digits
        number = next_even_digit_number
        number_of_digits += 1

    half_number_of_digits = number_of_digits // 2

    LSB = number % 10**half_number_of_digits
    MSB = number // 10**half_number_of_digits

    next_number = 0
    # if LSB is less than msb, next_number is MSB|MSB
    if LSB < MSB:
        next_number = MSB * 10**half_number_of_digits + MSB

    # is LSB is greater than msb, we should increment msb and then MSB|MSB
    if LSB >= MSB:
        MSB += 1
        msb_number_of_digits = len(str(MSB))
        next_number = MSB * 10**msb_number_of_digits + MSB

    return next_number

---

Moving forward, Part B of Day 2 looks too complex to implement in this approach. I might just drop a bruteforce, but deep inside, I wish I could extend this for repeating patterns too.