Our great sponsors
-
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
-
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.
-
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!
-
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
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
-
adventofcode
Advent of Code solutions of 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 and 2023 in Scala (by sim642)
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
-
AoC2022
A collection for my Advent of Code (https://adventofcode.com/) solutions using the Nim programming languages (https://nim-lang.org/) (by genius487)
I learned a lot since previous years. I like this solution.
-
GitHub repo with both parts
-
-
-
-
-
Advent-of-Code-Solutions
This repository includes my solutions to the Advent of Code puzzles using *python*. (by Fransandi)
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
-
Advent-of-Code
Advent of Code https://adventofcode.com/2020 My world of trying new stuff (by amitk1990)
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
-
AdventOfCode2022
Discontinued My solutions to Advent of Code 2022 https://adventofcode.com/ (by PetchyAL)
My python solution: https://github.com/PetchyAL/AdventOfCode2022/blob/286472bfad5e339c0e6ac4c082aa3de01e20ea77/solutions/day3/day3.py
-
Advice very welcome! github
-
-
Python 3.11
-
Python 3.10
-
aoc2022
Discontinued Advent of Code 2022 solutions [Moved to: https://github.com/deafpolygon/advent-of-code] (by deafpolygon)
C++17 (solution online: https://github.com/deafpolygon/aoc2022/blob/main/3/day3.cpp)
-
advent_of_code
This repository contains my solutions for the Advent of Code programming challenges. (by GabrielTorland)
The code is also available on my GitHub (here).
-
-
programming-challenges
My attempts at solving various programming challenges. Leetcode, codewars, adventofcode, etc (by x-zvf)
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.
-
advent_of_code_2022
My daily solutions to the Advent of Code 2022 programming puzzles. (by szmate00)
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
-
AdventOfCodeTI83
As many Advent of Code problems as possible, done in Z80 assembly language for the TI83 graphing calculator.
Z80 Assembly Ran on a TI-83 Graphing calculator.
-
Advent-of-Code-2022
Discontinued This is my answers to resolve the problems of the competition Advent of the code (by EdwinMakRouts)
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
-
advent-of-code-2022
Solutions to Advent of Code 2022 puzzles https://adventofcode.com/2022 (by Lysander6)
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
-
AdventOfCode2022
This is my attempt to solve AdventOfCode2022 (https://adventofcode.com/2022/) and learn some Rust (by samoylenkodmitry)
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.
-
AdventOfCode2022
My C# solutions to Advent of Code 22. Trying to one-liner as many as possible but I've already failed at Day 5. (by joel-heath)
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
-
-
Advent-of-Code
This repo contains my solutions to the advent of code event. Learn more about advent of code at https://adventofcode.com (by AhmarTheRed)
-
AoC.2022
Advent of Code 2022, I'm going to try to use Excel. First with LAMBDA, then maybe VBA or OfficeScripts.
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
-
AdventOfCode
Discontinued My adventofcode.com solutions [Moved to: https://github.com/d-hain/advent_of_code] (by d-hain)
-
-
-
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
-
advent-of-code-go
All 8 years of adventofcode.com solutions in Go/Golang; 2015 2016 2017 2018 2019 2020 2021 2022
-
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
-
AdventOfCode-Day3-RucksackPrioritization
C# console app that solves the AdventOfCode - Day 3 - Rucksack Prioritization Puzzle
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³).
-
-
Runnable links here: https://github.com/remy/advent-of-code-solved/blob/main/2022/
-
SaaSHub
SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives
