-
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.
-
SaaSHub
SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives
-
AdventOfCode
My Advent of Code solutions. I also upload videos of my solves: https://www.youtube.com/channel/UCuWLIm0l4sDpEe28t41WITA
-
adventofcode
Advent of Code solutions of 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 and 2023 in Scala (by sim642)
-
AoC2022
A collection for my Advent of Code (https://adventofcode.com/) solutions using the Nim programming languages (https://nim-lang.org/) (by genius487)
-
Advent-of-Code-Solutions
This repository includes my solutions to the Advent of Code puzzles using *python*. (by Fransandi)
-
Advent-of-Code
Advent of Code https://adventofcode.com/2020 My world of trying new stuff (by amitk1990)
-
AdventOfCode2022
Discontinued My solutions to Advent of Code 2022 https://adventofcode.com/ (by PetchyAL)
-
aoc2022
Discontinued Advent of Code 2022 solutions [Moved to: https://github.com/deafpolygon/advent-of-code] (by deafpolygon)
-
advent_of_code
This repository contains my solutions for the Advent of Code programming challenges. (by GabrielTorland)
-
programming-challenges
My attempts at solving various programming challenges. Leetcode, codewars, adventofcode, etc (by x-zvf)
-
advent_of_code_2022
My daily solutions to the Advent of Code 2022 programming puzzles. (by szmate00)
-
AdventOfCodeTI83
As many Advent of Code problems as possible, done in Z80 assembly language for the TI83 graphing calculator.
-
Advent-of-Code-2022
Discontinued This is my answers to resolve the problems of the competition Advent of the code (by EdwinMakRouts)
-
advent-of-code-2022
Solutions to Advent of Code 2022 puzzles https://adventofcode.com/2022 (by Lysander6)
-
AdventOfCode2022
This is my attempt to solve AdventOfCode2022 (https://adventofcode.com/2022/) and learn some Rust (by samoylenkodmitry)
-
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)
-
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.
-
AdventOfCode
Discontinued My adventofcode.com solutions [Moved to: https://github.com/d-hain/advent_of_code] (by d-hain)
-
advent-of-code-go
All 8 years of adventofcode.com solutions in Go/Golang; 2015 2016 2017 2018 2019 2020 2021 2022
-
AdventOfCode-Day3-RucksackPrioritization
C# console app that solves the AdventOfCode - Day 3 - Rucksack Prioritization Puzzle
-
SaaSHub
SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives
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Ā³).
Runnable links here: https://github.com/remy/advent-of-code-solved/blob/main/2022/