Our great sponsors
-
InfluxDB
Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
-
WorkOS
The modern identity platform for B2B SaaS. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.
-
AdventOfCode
My Advent of Code solutions. I also upload videos of my solves: https://www.youtube.com/channel/UCuWLIm0l4sDpEe28t41WITA
-
QDirStat
QDirStat - Qt-based directory statistics (KDirStat without any KDE - from the original KDirStat author)
-
advent-of-code
My Advent of Code submissions. For 2021 and before, these are the original code I used, without any modifications after-the-fact. As such, they are probably not as efficient or short as they should be, because I want a working solution faster, not a better solution. For 2022 and after, these are the solutions uploaded to my YouTube channel.
-
advent-of-code-scala
Complete 2022 to 2015 entries for the annual Advent of Code challenge, written in concise idiomatic functional Scala.
-
adventofcode
Advent of Code solutions of 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 and 2023 in Scala (by sim642)
-
AdventOfCode
Hacky solutions for [Advent of Code](https://adventofcode.com), working on past problems (by AllanTaylor314)
-
AOC
Solutions for Advent of Code, written in multiple languages, 2015/2020 done in C++, 2021 done in Rust (by Blakeinstein)
-
aoc2022
Trying to solve Advent of Code 2022 in 25 different languages (1 day = 1 language) (by GoldsteinE)
-
advent-of-code-2022
The solutions that I came up with for the Advent of Code 2022 in Ruby (by coding-bunny)
-
adventofcode
This repo contains (almost) all of my solutions for adventofcode problems. (by kiriDevs)
-
advent-of-code-2022
My solutions for the Advent of Code for 2022. https://adventofcode.com (by tanuki-billie)
-
AdventOfCode2022
This is my attempt to solve AdventOfCode2022 (https://adventofcode.com/2022/) and learn some Rust (by samoylenkodmitry)
-
Advent-of-Code-2021
Made it through all 25 days of Advent of Code for the second time! (by Leftfish)
-
AdventOfCode2022
Solutions to all 25 Advent of Code 2022 in Rust 🦀 Less than 100 lines per day, total runtime of less than 1 second. (by AxlLind)
-
advent-of-code-2022
I will be attempting Advent of Code 2022 with Rust, a language I have never learned before. (by grhkm21)
-
Advent-Of-Code-2022
My solutions for Advent Of Code 2022. Every day is written in another language, chosen randomly. (by Jomy10)
-
-
AoC.2022
Advent of Code 2022, I'm going to try to use Excel. First with LAMBDA, then maybe VBA or OfficeScripts.
-
advent-of-code-2022
Joel Eisner's completed TypeScript code challenges for "Advent of Code" 2022 (by joeleisner)
-
AdventOfCode2022
Repository for advent of code code to find solutions. This year in Go. (by BlaximusIV)
-
AdventOfCode-Day7-SpaceAnalyser
C# .NET Core console app that solves the AdventOfCode Day 7 - Space Analyser puzzle.
-
-
SaaSHub
SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives
Mine is similar but I keep a stack of abspaths (q07.py). I don't quite understand how you are able to get away without doing that in the accumulate - are you implicitly assuming subdirectory basenames are unique?
Here's my version in PHP. I used a Tree representation for building the filesystem structure.
F# - Was able to get the answer by only parsing 'cd' and 'file' lines. A single fold and then sum/min from aggregated data.
First (slower) version using zippers. I absolutely had to use them because I just learned about clojure.zip recently and this puzzle seemed to be a perfect victim for me having fun creating a huge tree structure.
Here it is if you'd like to see: https://github.com/hugseverycat/aoc2022/blob/main/day7attempt2.py
Yeah, I spend a lifetime (I'm tired sorry) wrestling with the borrow checker until I stumbled upon Rc and RefCell, I'm new so I did not know about it, and after a few rewriting I finally managed to get a real tree with ref inside. I probably would have finished 3 hours sooner if I tried the Hashmap approach, but I wanted that damn tree (code)
Python3, 9/4! Video. Code. I'm happy to make the top 10!
It's used by several disk usage utilities like https://github.com/shundhammer/qdirstat
Go/Golang | 1417/2403
Part 1
Code
Code
C# .NET GitHub
Code
Here is the GitHub page if you wanna look closer. Definitely open to improvements.
My solution in Scala
Kotlin Day 06 I went the tree route, and build up a directory structure as I went along
object oriented crystal: https://github.com/robacarp/advent_of_code/blob/master/2022/7/solution.cr
Code Here
Ruby 4028/3734
python 3.11
Scala (2973 / 2888)
My Scala solution.
PowerShell 7
Python [1810/1396] (with and without recursive structures), then Google Sheets. The flat data structure was useful for working with the sheet (I don't think spreadsheets are designed for recursion)
[Rust](https://github.com/iDoEverything/adventofcode22)
My Haskell solution https://github.com/clatisus/advent-of-code-y2022/blob/master/src/Day7.hs
Clojure - Code
I remember the first time I needed to close(cmd) too - I was so frustrated until I worked it out (much longer than 40 mins!). Here's my solutions: 1 and 2. The gotcha for me today was that I had been using the name of the directories as array indices, without checking to see if the directory names were reused... which they were.
My solutions in python and rust. The python version is my original and the rust version is after checking what some other people were doing. For some ungodly reason rust-analyzer thinks the scan_fmt! macro is invalid because I'm asking it for a String, but the rust compiler compiles it without issue. If anyone has a clue what's going on here I'd love to know.
Elixir — code, reflections
My dart solution is here: https://github.com/definev/AOC/blob/main/dart/day07.dart
GitHub
Finally got around to doing it in a language I've never used before for the day. Today's language of choice is Jakt, solution here.
rust, not good
Typescript
Python https://github.com/Pokemaster69/AOC2022/blob/main/day7.py
part 1 & part 2
Here is my python solution: https://github.com/VictorOnink/Advent-of-Code-2022/blob/master/Day_7_No_Space_Left_On_Device/day_7_file.py
Day 7
Rust (repo). Nice to brush up on tree structures again. No idea if it was the fastest method but the code is easy to follow at least.
Part 1 took a significant amount of time, since I had to develop the input parser; I assumed that the input was a pre-order traversal through the filesystem. I defined a struct to represent a tree node, and wrote the constructor for both struct variants. My parser looked at the input stream, and expected to see $ ls (as an internal correctness check). After it saw that, it looked ahead and counted the number of entries in this directory (.countEntryLoop). I then allocated space to hold those entries. Next, I parsed each entry (.parseEntryLoop). Finally, for each directory I saw, I skipped the cd to that directory and then recursed. Finally, I calculated the size of this directory as the sum of the sizes of its entries. I then skipped the cd .. at the end of the current directory entry (if there was any; I would have skipped past the end of the file for /, but I don't look after that anyways). Then, I had to do a standard structurally recursive traversal through the tree, summing those directory nodes whose size was more than 10,000. It's more difficult to write recursive functions in assembly, since you've got to be very careful to set up your arguments and prevent clobbering of registers you currently have in use.
Julia. Finally too many new things to learn at once in Julia to avoid getting ugly.
no_std Rust targetting 8-bit MOS6502: https://github.com/mrk-its/aoc2022/blob/main/day07/src/main.rs Computed in 11275620 cpu cycles
solution (GitHub): https://github.com/coding-bunny/advent-of-code-2022/blob/main/day_7.rb
Julia (GitHub)
First attempt
C, some annoying input parsing and then very straightforward tree walking. Was expecting something a lot harder in part 2, so originally over-engineered, and ended up ripping a bunch of stuff out when part 2 was just another walk of directory sizes. ¯_(ツ)_/¯ [Github]
Github
Github
Ugly as hell but ended up working. Will improve later on. Javascript solution
Here's my PHP solution : https://github.com/mariush-github/adventofcode2022/blob/main/07.php
C preprocessor: https://github.com/camel-cdr/boline/blob/main/aoc22/aoc7.c
I would need some help, since no matter what I do, it seems like i get wrong anwser? Is there some "joke" or trick that I should account for, that the example doesn't contain? github
Python 3.8 solution
Calculate part 1 in one pass and do a second only over the sizes for part 2 (because we know the size of / only at the very end). Hot runs take ~13 µs on a Core i9-12900K, including I/O. Code is here.
Python @ github
Rust
Solution
Here's is a GitHub link to my solution for today challenge.
Solution
TypeScript, this one was pretty fun
you can find whole code here, I will show you the most interesting bit with traversing the instruction list with current path stored in pth column. parsed as ( select 'root' as t, '/' as nm, null as bytes, json_array('/') as pth, 1 as step union all select preparsed.t, case when preparsed.t = 'dir' or preparsed.t = 'file' then json_insert(pth, '$[#]', preparsed.nm) else preparsed.nm end as nm, preparsed.bytes, case when preparsed.t = 'cd' then json_insert(pth, '$[#]', preparsed.nm) when preparsed.t = 'dc' then json_remove(pth, '$[#-1]') else pth end as pth, step + 1 as step from parsed inner join preparsed on n = step ), only_dirs as ( select json_remove(nm, '$[#-1]') as nm, sum(bytes) as bytes from parsed where t = 'file' group by json_remove(nm, '$[#-1]') ), all_dirs_counted as ( select json_each.value as dirnm, sum(bytes) as bytes from only_dirs, json_each(only_dirs.nm) group by json_extract(nm, printf('$[%s]', iif(json_each.key > 0,json_each.key - 1, 0))) || json_each.value order by nm )
Python 3.11
Javascript
Also had to copy the maths for part 2 off someone as my brain melted before I could finish. Here's the whole thing so far and I did in JavaScript..
my solution for day7 in rust https://github.com/Sreyas-Sreelal/aoc-2022/blob/master/day7/src/main.rs I think I can write a better solution
Typescript: github
I went with a tree and recursive function, and no assumptions about the maximum number of dirs/files/levels. So that took me a while, haha. Runs in 1.5 ms on a Raspberry Pi 4. https://github.com/ednl/aoc2022/blob/main/07.c Possible further optimisation: store dir sizes in the struct for re-use in part 2. But meh, I spent enough time!
Python - Day 7
Day 7, Part 1
Java 8 Solution
I haven't yet seen a tree parser that uses a recursive parser instead of a parent pointer, so I thought I'd throw my solution into the mix: Scala
github link
I'm building a tree structure of custom [file](https://github.com/micod-liron/advent-of-code/blob/main/AdventOfCode2022/AOCFile.class.st) and [directory](https://github.com/micod-liron/advent-of-code/blob/main/AdventOfCode2022/AOCDir.class.st) types and then folding over it. Smalltalk's dynamic nature and duck typing were really handy.
C++ Implementation (written by a Python guy): https://github.com/Mereep/advent_of_code_2022_cpp
Full code: https://github.com/afcasco/AdventOfCode/tree/main/src/main/java/com/adventofcode/y2022/day07
I solved it with just a stack and a list and no recursion in ~80 lines: https://github.com/lhecker/adventofcode_2022/blob/master/src/day07/main.rs
Solution for both parts in Rust:
Solved in some 50 lines of Rust, using just a flat HashMap to represent the file system: https://github.com/frjonsen/aoc2022/blob/master/day7/part2/src/main.rs
Probably too long to post, GitHub
Rust: https://github.com/ChiefMilesEdgeworth/advent-of-code-2022/blob/main/src/bin/07.rs
[Rust my repo]
Java GitHub
c++ repo
Not pretty, but I believe efficient enough. Uses a few Strings and a HashMap, but does avoid recursion. Interestingly enough latest version with some heap allocations is still better than a few of my attempts to use only the stack (with things like arrays, tinyvec). Performance is okay on my machine, but it's the slowest day so far [ref].
Python: GitHub
C# solution
My Python answer on Github
Golf in Ruby (207 Bytes) (GitHub)
Go
My Rust solution with tuple pattern matching. Tried to write it as idiomatic as I could, any advice?
github link
This one hurt, oof. Source here
[Source](https://github.com/Timmoth/AdventOfCode2022/blob/main/Solutions/Day7.cs)
Rust https://github.com/samoylenkodmitry/AdventOfCode2022/blob/master/src/day7.rs I am new to Rust, I am pretty proficient in java and kotlin, but how you can effectively implement graph-like structures in Rust? That didn't work for me ;(
My Python solutions involving Graphs part_1 part_2
No recursion, no maps, just a pair of vectors. Complete with compile-time tests. Github.
https://github.com/philipwhiuk/advent-of-code/tree/master/src/main/java/org/whiuk/philip/adventOfCode/twentytwentytwo/Seven.java I assumed it would matter at some point.
Github
This Lua code is run by loading the solver as a plugin, and then open the input file in neovim and run :AoC 2022 07 1. Haven't really befriended Lua yet though https://github.com/EmilOhlsson/advent-of-code/blob/main/lua/advent-of-code/2022/07.lua
Using strings, not a very elegant but it works Ruby
I totally recommend trying - it's going to be a lot of fun and you'll understand the structure better. I'm not a pro and I never studied CS - that's just my experience from last year (day 18).
I have actually made two versions of solution for D7. First, initial, which is more verbose and second in which, I've tried to compress my ideas but without losing too much of clarity.
Rust: https://github.com/dehan-jl/adventofcode-2022/blob/main/day7-alternate/src/main.rs
Based on the code by u/supersmurfen (https://github.com/AxlLind/AdventOfCode2022/blob/main/src/bin/07.rs).
[Here](https://github.com/grhkm21/advent-of-code-2022/blob/master/day-07/src/main.rs) is my implementation. I probably should create a `Tree` struct that wraps a `TreeNode` as well, but... I am kind of lazy. Note that `.dfs` doesn't allow returning any references e.g. `.dfs(|node| node)` will not work, since that runs into lifetime issues of closures, as they are not declarable. (I am beginner to Rust too, sorry for wrong termonology).
Went with a recursive data structure as well. Github link: Day 7.cs + Day7Classes
My Python 3 solution
Go
Today is Go
As usual, code on Github, recording on Twitch.
This comes from three unpublished crates (aoc/aoc-derive/aoc-build) that I implemented last year. You can read their source code on https://github.com/samueltardieu/aoc, and see how they are used by cloning https://github.com/samueltardieu/aoc2022.
This comes from three unpublished crates (aoc/aoc-derive/aoc-build) that I implemented last year. You can read their source code on https://github.com/samueltardieu/aoc, and see how they are used by cloning https://github.com/samueltardieu/aoc2022.
Rust
Python 3- Parts 1 & 2: GitHub. No imports, 10 lines, 362 characters including file name. Not insanely proud, as I wanted to be more concise (who needs readability), but it works.
But this worked for both parts GitHub.
C# straight forward going line by line, adding folders in a list, files in another and then looping through both lists to calculate size of folders (sum of all files starting with that path). GitHub
18 micro seconds! That's insane. I was happy at 40 microseconds although I CBA to optimise down to as_bytes shenanigans
My Kotlin solution: https://github.com/Dantaro/adventofcode2022/tree/main/src/main/kotlin/day07
Excel VBA, just make the file system and write the files, make a collection of folder objects, and output the full path and .size of each folder. TIL that a blank line in Windows/ASCII is 2 bytes. GitHub
Rust solution. https://github.com/adamchalmers/aoc22/blob/main/day7/src/main.rs
After I had realized that I can pattern match on slices with Rust an elegant solution (nearly) wrote itself :)
Overengineered but educational (for me) Haskell solution using zippers and recursion schemes
OCaml, pure functional. This is the interesting tree-builder part, the rest is on github.
Rust: https://github.com/Fektoer/advent2022/blob/main/day7/src/main.rs
Dlang solution, part 2. I'm embarrassed by this code but I'm sharing it because it took a lot of effort to write it. Previous solutions are available in this repo
Racket/Scheme
Source
C#: my first experience using something like trees. It was exhausting (complete solution in my repo)
Annotated code and video of it running. Running my actual input took ~7 minutes.
JavaScript Day 7
Solution implemented in Go, using a tree and recursion. I'm new to Go, coming from C#. I created a monster and would love any feedback to make it cleaner and more idiomatic!
Solution in C#
OOP Python solution
https://github.com/djotaku/adventofcode/blob/45ab63cf7679e1b6ce61f32a61e03da384d57295/2022/Day_07/Python/solution.py
anyway here is the link to my github
Kotlin solution, yeah!
Part 1 and 2
Python3. Full code. Pretty good excuse for structural pattern matching:
Not optimal, but needed an excuse to have "fun" with immutable trees
Kotlin solution with recursion and iterator for the file tree https://github.com/DDihanov/Advent-Of-Code-2022-Kotlin/blob/master/src/main/kotlin/day7/Day7.kt
Part 1
https://github.com/kevinluo201/aoc/blob/main/2022/day7/day7.rb Basically, I build a class to handle each directory.
git repo
My solution in Rust, I expected to have a very hard time on this and was actually pleasantly surprised that I was able to complete it in only a few hours. That being said, my solution is probably horrible
C# Solution using Switch, LINQ & Recursive calculation of sub-directories - nothing fancy :/. code
python
Julia 11/737, which is my best placement yet, and second ever points.
My solution for day 7: https://github.com/AlexanderNenninger/AoC2022/blob/master/src/days/day07.rs. I used Rust's sum types in a finite state machine for parsing input. This solutions also demonstrates how to use an explicit buffer for multiple mutating references.
JavaScript https://github.com/ilsubyeega/aoc2022/blob/main/day07.js \ I think this problem was a little overwhelming for me, who is graduating as a high school student soon. Hope I can refactor this in the future.
Blog Walkthrough of a Serial Solution | Late-Breaking Code for a Parallel Solution
Here is my code: Github
Here's the repo, its way too long for here!
7b Code
Here's my solution having all things immutable and emulating the file system using recursive types. But yes, trees are not something I do every day :/
Solution using tree python
Gitlab