-🎄- 2022 Day 3 Solutions -🎄-

So close to the leaderboard today! Thought I was fast but was still just outside of it. Oh well.

no smart hacks https://github.com/Fadi88/AoC/blob/master/2022/day03/code.py

Yeah, I tried ended up falling back to vectors as well, but I went back afterwords and redid it with the hashsets. My code is not quite a compact, but here is my hashset solution: https://github.com/Quillbert/AdventOfCode/blob/master/2022/day03b/src/main.rs

Very similar to my solution, which I also like how it turned out :)

Looks really convoluted to me, with all those libraries. Of course, things like vec_t might come in handy later this year, but I didn't feel any need for them so far. (Is the repo complete? You include data.h but I only see data.txt.) I am more used to programming C in an embedded style. Today took about 60 lines in one file: https://github.com/ednl/aoc2022/blob/main/03.c

I used Pascal today too but yours is much more concise than mine. Nice job!

Kotlin solution, no sets!

Python3 116/50. Video. Code. Got a wrong answer on part1 :(

Straight forward iteration that bails as fast as possible code here

Python 62/93

Done in Rust.

Cleaned up code

Go / Golang | 6562/5999

For day 3, I tried LDPL. Solution here.

C++ not very compact

Kotlin github link

Noulith, 23/7

Ruby code, map-reduce ftw

Jelly (put the input in the first command line argument):

But it got the job done. Here's mine: https://github.com/UnicycleBloke/aoc2022/blob/main/day03/day03.cpp. I think I really ought to spend some time learning to use the ranges library this time.

In part 1, I read each string, then split it in half, passing it to a subroutine (that I honestly should have inlined). This subroutine then called a new library function - searchc - my other character finding function, findc, assumed that the character would eventually be found. I managed to do some assembly optimization via interprocedural analysis - I saw that searchc would not clobber anything except rax, so I could keep the same values in the same registers. This is the first time I've written code better than a compiler usually does - compilers have trouble doing these sort of interprocedural analyses across translation units. Once I had the common item, I could use a lookup table to compute the priority. Unlike last time, this was a one-dimensional lookup table, and I couldn't rely on registers being cleared how I wanted, so I saved the table as a table of quadwords instead of a table of bytes - this let me remove a cast.

Kotlin for Day 3 https://github.com/jdvp/AdventOfCode2022/blob/main/src/main/kotlin/me/jdvp/adventofcode/daily/Day3.kt

linq https://github.com/encse/adventofcode/blob/master/2022/Day03/Solution.cs

link, feel pretty good, couldn't make the leaderboard tho.

nim https://github.com/ahungry/adventofcode-2022/blob/master/d3e2.nim

[Golang](https://github.com/schamanegeist/advent-of-code-2022/blob/main/bin/challenge3/go/main.go)

part1 { input -> input.lines.sumOf { line -> val (left, right) = line.chunked(line.length / 2).map { it.toSet() } left.intersect(right).single().priority } } part2 { input -> input.lines.chunked(3) { group -> val (first, second, third) = group.map { line -> line.toSet() } first.intersect(second).intersect(third).single().priority }.sum() } ``` https://github.com/patrick-elmquist/Advent-of-Code-2022/blob/main/src/main/kotlin/Day3.kt

Elixir solution: https://github.com/sreetamdas/advent-of-code/blob/main/lib/2022/day_03/day_03.ex

The whole code can be found here: https://github.com/Seishin/AoC2022/blob/master/day3/solutions.py

Rust: PART 1 PART 2

My Scala solution.

Elixir, on GitHub. Below I've elided the implementation of common (builds a MapSet of items shared by all arguments) and only_element.

GitHub - day3.rb

APL: https://github.com/chenson2018/advent-of-code/blob/main/2022/03/apl/03.apl

After cleaning it up this is what I came up with: Code

I learned a lot since previous years. I like this solution.

GitHub repo with both parts

Ref: https://github.com/Fransandi/Advent-of-Code-Solutions/blob/main/2022/solutions/day3.py

Solution.

Elixir solution

Part 1: https://github.com/ashishjh-bst/aoc2022/blob/master/day3/part1.go Part 2: https://github.com/ashishjh-bst/aoc2022/blob/master/day3/part2.go

C++ solution: https://github.com/tigerManBot/advent_of_code_22/blob/main/day3/day3.cpp

My Nim solution for today using sets: Github

GitHub Repository

pretty simple one. I use some old helper functions I have from previous years. If anyone has interest on seeing how they are implemented: https://github.com/blfuentes/AdventOfCode_2022

Kotlin code Perfect task for using power of collections

Here's a short Scala solution: https://github.com/stewSquared/advent-of-code/blob/master/src/main/scala/2022/Day03.worksheet.sc

Kotlin → https://github.com/spyroid/puzzles/blob/main/src/aoc/y2022/day3/day3.kt

python here is the link

My solution for part II in readable bash script. (All my solutions are on my github)

There are some helper classes that handles the input data. Full solution can be found here: repo

Dyalog APL ⎕IO←1 ⋄ p←(⎕A,⍨⎕C ⎕A)∘⍳¨⊃⎕NGET'p3.txt'1 +/⊃¨(2÷⍨≢¨p)(↑∩↓)¨p ⍝ part 1 +/⊃¨⊃¨∩/¨p⊂⍨1 0 0⍴⍨≢p ⍝ part 2

JAVA this year (I miss python)

C - we don't need no stinking sets! Because we have uint64_ts and masking. [Github]

Python

code on GitHub

I used this Template

day03.go

Python solutions

My python solution: https://github.com/PetchyAL/AdventOfCode2022/blob/286472bfad5e339c0e6ac4c082aa3de01e20ea77/solutions/day3/day3.py

Advice very welcome! github

Python 3.11

Python 3.10

C++17 (solution online: https://github.com/deafpolygon/aoc2022/blob/main/3/day3.cpp)

The code is also available on my GitHub (here).

I haven't written any clojure since last year's AoC, so I am a bit rusty. github ```clojure (require 'clojure.string) (require 'clojure.set)

Full program on GitHub

Rust 3a: use day_03::{intersect, priority}; fn main() { let input = include_bytes!("../../../input/day_03.txt"); let sum_of_priorities = input .split(|&byte| byte == b'\n') .map(|line| line.split_at(line.len() / 2)) // split into equally sized compartments .map(|(l, r)| intersect([l.iter().copied(), r.iter().copied()])) // find the intersection of the compartments .map(priority) // map to priorities .sum::(); println!("{}", sum_of_priorities); } 3b: use day_03::{intersect, priority}; fn main() { let input = include_bytes!("../../../input/day_03.txt"); let lines = input.split(|&byte| byte == b'\n').collect::>(); let sum_of_priorities = lines .chunks(3) .map(|chunks| intersect(chunks.iter().map(|chunk| chunk.iter().copied()))) .map(priority) // map to priorities .sum::(); println!("{}", sum_of_priorities); } shared code (module: `day_03`): use std::collections::HashSet; pub fn intersect(sets: I) -> u8 where I: IntoIterator, Set: IntoIterator, { let common = sets .into_iter() .map(|set| { let set: HashSet = HashSet::from_iter(set); set }) .reduce(|l, r| &l & &r); *common.unwrap().iter().next().unwrap() } pub fn priority(item: u8) -> u32 { (if item >= b'a' { item + 1 - b'a' } else { item + 27 - b'A' }) as u32 } repo: https://github.com/foresterre/advent-of-code-2022

Haskell, runs in 4 ms. I feel a little dirty using S.findMin and M.!, but it surely does work pretty good when the input is clean.

But to be honest, I like my Clojure solution even more.

Link to github

F#

Javascript / NodeJS: Source Diff for Day3 here

(source here)

Source Code (2 Solutions)

Someone started a repo for "advent of code golfing", i've added more explanations there. https://github.com/Starwort/advent-of-golf-2022/

Full solution

c# PartOneAndTwo

I have it in a repo on Github, but it's still very experimental.

My Java solution that im quite happy with: https://github.com/Suicolen/AdventOfCode2022/blob/main/src/main/java/suic/days/Day03.java

Part 1: https://github.com/clalos/AoC-2022/blob/main/day3a/main.zig

rust

Lua Part 1 and 2

c++ : https://github.com/xNymia/AoC22/blob/master/Day3/main.refactor.cpp

Repo

RUST Started learning Rust, comments are welcome! :)

C# (Link)

My template for JS and TS: AoC Runner

Swift. Algorithms contains chunks(ofCount: 3) but I had to write chunks(totalCount:) myself.

Part 1

Github Solution

Day 3

Python3:

Code | Blog Post

Day 3

Rust nothing too fancy, I'm open to any optimization recommandations (haven't done any here)

C++: https://github.com/Toxe/advent-of-code-2022/blob/main/src/day03/day03.cpp

No proofs, does not pass totality check, still had a lot of fun

Z80 Assembly Ran on a TI-83 Graphing calculator.

Python Solution

Me and clojure are getting along pretty well so far.

Elixir MapSets made this one really simple and quick

My rust solution using only iterators, no for loops. It's close to a one liner, but imo pretty readable. ```rust use std::fs::File; use std::io::{self, prelude::*, BufReader};

30 minutes or less solution in Julia - time elapsed 22:07

I liked this one, solution in python (part2)

Day 3 using Racket https://github.com/dougfort/racket-advent22

PowerShell https://github.com/kirkhofer/adventofcode/blob/main/2022/day03/posh/day03.ps1

Find all my solutions on Github

github

F# - Single fold and iteration for both the parts

My solution still smells a bit like python: https://github.com/fnands/advent_of_code_2022/tree/main/day_3

C# Repo

Github

Java 17 solution: github

my solution in typescript: github

Getting some practice with decorator factory pattern in Python 3 (read: pretending like I write modular code on the reg).

Obfuscated, but concise python solution

Day 3 solution in Rust🦀: github. Quite satisfied with how it came out

F#. Using sets made this very easy.

The full code can be found here: Github

Rust ugly solution https://github.com/samoylenkodmitry/AdventOfCode2022/blob/master/src/day3.rs

A Kotlin solution: https://github.com/Ostkontentitan/Advent-of-Kotlin-2022/blob/main/src/main/kotlin/day1/dayThree.kt

Otherwise, this was just some straightforward nested iteration between strings. Here's an annotated version of part 2.

The helper function is available in my Day 1 post. All solutions are available here.

Trying to do as many days as I can as one-liners in C# on my GitHub!

Still working on part two. Repo: DDamianoff/Aoc2022

Code

github

I later learned that CL has an intersection function that works on lists, so I didn't have to use fset at all. The new version is here: https://github.com/atgreen/advent-of-code-2022/blob/main/03.lisp

Here's my Common Lisp solution hacked together iteratively in an Emacs scratch buffer.

Github

c++ beginner solution. code

Ugly groovy solution: GitHub

My solution in Rust. As I'm still learning Rust part 2 was a struggle because of fights with the borrow checker and type system.

Bash, with as much pipes as possible: https://github.com/Thiht/advent-of-code/tree/master/2022/03

In Lisp :P

The first half I even simplified a bit more on my GitHub by using MAP instead of BYROW. I hadn’t realized that MAP supports multiple columns.

Day 3 of learning Rust... too many for loops. GitHub

Rust using some of the bytes logic that I saw from other people's code from days 1 and 2: https://github.com/michael-long88/advent-of-code-2022/blob/main/src/bin/03.rs

View on github

Repo link.

Ansible

Python 3 Solution

Back with a seriously over-engineered DI C# solution with test library. See on GitHub.

Part 1 Solution in Ryelang (ryelang.blogspot.com)

Python soution on Github

Node + TypeScript

Day 03

C# solution using LINQ, Repo

Part 1

My first BASIC implementation of an exercice. It's one with an O(n²) algorithm and string manipulation inside, making it, I think, O(n³).