Advent of code collection

Advent of Code is an annual set of Christmas-themed computer programming challenges that follow an Advent calendar.

Cloud IDEs

Benefits solving AOC problems

• Improve Java programming skills: Master modern Java features (Java 25), SOLID principles, Effective Java best practices, and clean code techniques

• Functional Programming & Design:

  • Sealed Interfaces & ADTs: Type-safe algebraic data types for pattern matching
    • MathOperator with sealed interface and record implementations
    • Instruction sealed interface for virtual machine instructions
    • Instruction sealed interface for Turing machine
  • Records: Immutable data carriers for state representation
    • Interval, RangeMergeState, ParsedData, Shape, Region
    • ProgramState, ExecutionResult, GridState, VaultState
  • Streams API: Declarative data transformations, Stream.iterate() for functional iteration, lazy evaluation
    • Range2, ShapePacking
    • Trampoline.run() uses Stream.iterate() for iterative evaluation
  • Pattern Matching: Switch expressions with sealed classes for exhaustive type checking
    • Instruction.from() uses switch expressions for instruction parsing
  • Trampoline Pattern: Converting deep recursion to iteration, preventing stack overflow
    • Trampoline sealed interface with Done and More records
    • AssembunnyInterpreter uses trampoline for safe deep recursion
    • ContainerCombination uses trampoline for backtracking
  • Pure Functions: Side-effect-free transformations, immutable data structures
    • Interval.contains(), Range2.mergeIntervals()
    • State transformation methods like ProgramState.withRegisters()
  • Higher-Order Functions: Function composition, method references, lambda expressions
  • Parallel Processing: Parallel streams for independent computations
    • ShapePacking with parallelStream() for region processing

• Data Oriented Programming (DOP):

  • Code-Data Separation: Instructions as data structures, execution logic separated from instruction representation
    • Instruction sealed interface separates instruction data from execution logic
    • Instruction for Turing machine instructions
  • Generic Data Structures: Flexible, reusable data representations
    • Generic Trampoline<T> for any computation type
  • Immutable Data: Records and sealed interfaces ensure data integrity
    • RangeProblemInput, GraphNode, GraphEdge
    • ProgramState with withRegisters() and withProgramCounter() transformation methods
  • Pure Data Manipulation: Transformations through pure functions, explicit data flow
  • Flat Data Models: Denormalized structures for efficient processing
  • Interleaved Arrays: Better cache locality for related data pairs
    • RationalMatrix with interleaved numerator/denominator storage

• Algorithms & Data Structures:

  • Graph Algorithms: BFS (Breadth-First Search), DFS (Depth-First Search), Dijkstra's shortest path, A* pathfinding with heuristics, memoized path counting (e.g., GraphPathCounter)
  • Dynamic Programming: Memoization for overlapping subproblems, optimal substructure exploitation (e.g., GraphPathCounter, BeamPathCounter)
  • Backtracking: Recursive search with pruning, constraint satisfaction (e.g., ShapePacking with bitmask optimization)
  • State Space Search: BFS/DFS for exploring solution spaces
    • RamRun BFS pathfinding, LavaHikingTrails2 BFS trail exploration, KeypadConundrum2 BFS shortest paths, LavaHikingTrails DFS trail rating, LanParty state-based Bron-Kerbosch algorithm
    • Elevator puzzles with state space search
  • Range Algorithms: Range merging, interval operations, coverage calculations (e.g., Range2, Interval)
  • Tree Traversal: File system navigation, hierarchical data processing
  • String Algorithms: Pattern matching, parsing, validation, hash generation
  • Grid Algorithms: 2D matrix manipulation, neighbor checking, cellular automata, pathfinding in grids (e.g., GridNeighbor2, BeamPathCounter)
  • Union-Find (DSU): Disjoint Set Union for connected components with path compression and union by size (e.g., DSU in PointCluster3)
  • Meet-in-the-Middle: Split-and-combine approach for exponential problems (e.g., Part1Solver with Gray Code optimization)
  • RREF (Reduced Row Echelon Form): Linear algebra for constraint optimization (e.g., RationalMatrix in Part2Solver)
  • Bitmask Optimization: Efficient 2D grid representation with O(1) bitwise operations (e.g., ShapePacking, ShapeVariant)
  • Primitive Collections: FastUtil and Eclipse Collections for performance-critical code (e.g., ObjectArrayList, LongIntHashMap)
  • Optimization Techniques: Big O analysis, complexity optimization, space-time tradeoffs, parallel execution
  • Virtual Machine Implementation: Instruction-based execution with state management
    • AssembunnyInterpreter with trampoline-based execution
    • Turing machine implementation with sealed instruction types

Testing & Benchmarking

• Unit Testing: Comprehensive test coverage with JUnit 5
• JMH Benchmarks: Performance benchmarking for algorithm comparison
  • Run benchmarks: ./mvnw clean test -Pbenchmarks -Dtest=DayXBenchmarkTest -D2025-dayX-benchmark=true -Dsurefire.failIfNoSpecifiedTests=false -pl 2025 -am
  • Available for Days 1, 2, 4, 5, 6, 8 (2025)
• Java Flight Recorder: Profiling data included in benchmark results
• Performance Analysis: See Big O Notation Documentation for complexity analysis

References

• https://openjdk.org/projects/code-tools/jol/
• https://jmh.morethan.io/
• https://inside.java/2024/05/23/dop-v1-1-introduction/
• https://adventofcode.com/
• https://www.reddit.com/r/adventofcode/
• https://www.reddit.com/r/adventofcode/?f=flair_name%3A%22Funny%22
• https://www.reddit.com/r/adventofcode/?f=flair_name%3A%22Visualization%22
• https://www.reddit.com/r/adventofcode/search/?q=flair_name%3A%22SOLUTION%20MEGATHREAD%22&restrict_sr=1
• https://github.com/forax/advent-of-code-2025

Acknowledgements

A heartfelt thanks to Frontier models for the insightful early morning (6:00 AM) discussions on design thinking and code refactoring, with a focus on functional approaches. I'm also deeply grateful to my friend Juan Antonio Medina for the continuous and inspiring conversations throughout the day, and to Rene van Putten for their invaluable inspiration.