I've completed "Restroom Redoubt" - Day 14 - Advent of Code 2024 #AdventOfCode https://adventofcode.com/2024/day/14

https://github.com/jeffmallozzi/AoC-2024-Rust/blob/master/src/days/day14.rs

I just completed all 25 days of Advent of Code 2015! #AdventOfCode https://adventofcode.com/

I presume that for people who use AI for private hobby programming projects the appeal of something like the Advent of Code is unfathomable?

Finished Advent of Code 2024.

25 days of exercises, parts 1 and 2. Done over a period of 1.5 months, mostly on weekends.

In COBOL.

Was it worth it?

Some exercises were tough! Some took several days. I wasn't sure I'd be able to complete it. The subreddit was helpful for those days!

So will I participate next year? Which language? Fortran?

My solutions (not very clean code! ): https://github.com/caarmen/aoc

2015 day 6 of Advent of Code in Ruby:

Amazing. A code golf solution in Ruby is twice as long as a solution that wasn't even intended to be golf, in the K language: https://www.reddit.com/r/adventofcode/comments/3vmltn/comment/cxp12nt

I feel like I'm passing by whole other universes.

One way to spend time instead of #doomscrolling has recentlt been #codewars

Bitesized problems of different difficulties for almost any language.

Not as big as #adventofcode, so I can riddle along on my mobile device as well (and be forced to code without an lsp)

https://www.codewars.com/dashboard

需要用到一點點數學，問題是不難的，今次Qwen3沒有跳步了，可以正常地用它將文字描述的邏輯寫成代碼，但是 #Rust 在這裏變得不太好用了，例如那些usize的運算需要手動關注和修一修

https://github.com/cosmoswafer/advent-of-code-2024/blob/main/src/bin/day8.rs

Today I spent a LOT of time solving AoC2024 day2 puzzle.

I solved it in three ways:
1. Javascript, just how I normally write it (somewhat functional programming)
2. A fully FP javascript solution
3. clojure solution

I realized some interesting things:
1. the functional programming js solution was very pretty and clean, and I think js is pretty good at FP. (I'm just learning FP so maybe I'm wrong)

2. the effective LOC of both clojure and js solution were exactly the same, and I think in the cleanliness and readability department they are very similar. But maybe that is because I'm much more used to js

3. The effective LOC of the functional solutions were almost half the LOC of the "normal" solution

Here are the solutions
https://github.com/alirezaalavi87/advent-of-code/tree/main/2024/day2

I started Advent of Code 2024 because I wanted to learn #clojure so I thought I would solve these puzzles with it.

GODDAMNIT the puzzles are so hard I can't even solve the puzzles with #javascript that I'm good at, let alone a language that I'm just learning.

I just completed all 25 days of Advent of Code 2019! #AdventOfCode https://adventofcode.com/

I just completed "Many-Worlds Interpretation" - Day 18 - Advent of Code 2019 #AdventOfCode https://adventofcode.com/2019/day/18

I just completed all 25 days of Advent of Code 2018! #AdventOfCode https://adventofcode.com/

I just completed "Experimental Emergency Teleportation" - Day 23 - Advent of Code 2018 #AdventOfCode https://adventofcode.com/2018/day/23

Reviving CVS for my #Retrocomputing needs for next #AdventOfCode:

https://www.uninformativ.de/blog/postings/2025-05-21/0/POSTING-en.html

Curious to see how well this will work.

I just completed "A Regular Map" - Day 20 - Advent of Code 2018 #AdventOfCode https://adventofcode.com/2018/day/20

I just completed "Beverage Bandits" - Day 15 - Advent of Code 2018 #AdventOfCode https://adventofcode.com/2018/day/15

I've finally got around to learning Python, and I'm currently working through some of the Advent Of Code '24 puzzles to get some hands on experience.

I appreciate some of what I think are Python's claims to fame. It's the first language in which I've worked with comprehensions. They're fun, but I'm not sure I see them as more than semi-arcane syntactic sugar for map() and filter(). Clearly, python's dynamic typing applied to list, tuple, comprehension, and generator is extremely powerful. Figuring out that I could just unpack all the elements from a short known-length list into a tuple has been handy.

The standard distro has modules for a great many things, and the package index has most everything else. On the other hand, how much is most? Maybe I'm missing something, but I can't find a module defining range_inclusive(start, stop) anywhere. Yes, I know it's trivial to write myself, but that seems at odds with Python's "batteries included" philosophy. All the research I've done seems to suggest the standard idiom is just to call range(start, stop + 1).

I love having access to a REPL again during code writing. It makes me miss the days of writing LISP in Emacs. I'm using PyCharm, which, of course, has the ability to load the current file directly into a new interpreter.

Probably my biggest gripe is that the language enforces so little and leaves so much to convention. Sure, it's higher-level than C, but it leaves you so many opportunities to shoot yourself in the foot at runtime. I had to laugh when reading up on classes, attributes, and scopes. Clearly, the moral was to define your data attributes inside the __init__ or you'll get some pretty bizarre bugs.

Oh! This one turned out to be super easy for me. Yeah!

#AdventOfCode at Easter.

https://functional.cafe/@lep/114369234063600841

I've completed "Claw Contraption" - Day 13 - Advent of Code 2024 #AdventOfCode #AoC #rust

I had Part 1 working fine but obviously Part 2 had other plans.
I don't mind a bit of cheating, I'm not doing this to learn linear algebra

https://github.com/jeffmallozzi/AoC-2024-Rust/blob/master/src/days/day13.rs
adventofcode.com/2024/day/13