🌟 Advent of Code (AoC) 2022 🌟

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

type Section struct {
	Start int
	End int
}

type Pair struct {
	Left Section
	Right Section
}

func getPartOne(pairs []Pair) int {
	count := 0
	for i := range pairs {
		pair := pairs[i]
		if  (pair.Left.Start <= pair.Right.Start && pair.Right.End <= pair.Left.End) ||
			(pair.Right.Start <= pair.Left.Start && pair.Left.End <= pair.Right.End){
			count++
		}
	}
	return count
}

func getPartTwo(pairs []Pair) int {
	count := 0
	for i := range pairs {
		pair := pairs[i]
		numbers := make([]int,100)
		for j := pair.Left.Start; j <= pair.Left.End; j++ {
			numbers[j]++
		}
		for j := pair.Right.Start; j <= pair.Right.End; j++ {
			if(numbers[j]) == 1 {
				count++
				break
			}
		}
	}
	return count
}

func getRows(filename string) []Pair {
	file, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	scanner := bufio.NewScanner(file)
	rows := make([]Pair, 0)
	for scanner.Scan() {
		row := scanner.Text()
		fields := strings.Split(row, ",")
		pair := Pair{}
		left := strings.Split(fields[0], "-")
		pair.Left.Start, _ = strconv.Atoi(left[0])
		pair.Left.End, _ = strconv.Atoi(left[1])
		right := strings.Split(fields[1], "-")
		pair.Right.Start, _ = strconv.Atoi(right[0])
		pair.Right.End, _ = strconv.Atoi(right[1])
		rows = append(rows, pair)
	}
	return rows
}

func main() {
	fmt.Println("Part one:", getPartOne(getRows("../input.txt")))
	fmt.Println("Part two:", getPartTwo(getRows("../input.txt")))
}

#include <stdio.h>

unsigned
parse_num(FILE *fp)
{
    unsigned num = 0;

    for (;;) {
        const int ch = getc(fp);
        if (ch >= '0' && ch <= '9') {
            num = num * 10 + ch - '0';
        }
        else {
            ungetc(ch, fp);
            break;
        }
    }

    return num;
}

int
skip_to_next_num(FILE *fp)
{
    int nl_count = 0;
    for (;;) {
        const int ch = getc(fp);
        if (ch == '\n') {
            nl_count += 1;
        }
        else if (ch >= '0' && ch <= '9') {
            ungetc(ch, fp);
            return nl_count;
        }
        else if (ch == EOF) {
            return 0;
        }
    }
}

unsigned
parse_calories_entry(FILE *fp)
{
    unsigned cur_calories = 0;
    do {
        cur_calories += parse_num(fp);
    } while (skip_to_next_num(fp) == 1);
    return cur_calories;
}

void
update_top_calories(unsigned *top_calories, unsigned top_size, unsigned value)
{
    unsigned tmp;
    for (unsigned i = 0; i < top_size; ++i) {
        if (value > top_calories[i]) {
            tmp = value;
            value = top_calories[i];
            top_calories[i] = tmp;
        }
    }
}

int
main(void)
{
    unsigned top3_calories[3] = {};

    do {
        const unsigned calories = parse_calories_entry(stdin);
        update_top_calories(top3_calories, 3, calories);
    } while (!feof(stdin));

    printf("Most calories: %u.\n", top3_calories[0]);
    printf("Top 3 calories sum: %u.\n", top3_calories[0] + top3_calories[1] + top3_calories[2]);

    return 0;
}

include prelude
import std / [strscans]

proc readInput(input: string): seq[(HSlice[int, int], HSlice[int, int])] =
  for line in input.splitLines:
    let (success, a1, b1, a2, b2) = scanTuple(line, "$i-$i,$i-$i")
    assert success
    result.add (a1 .. b1, a2 .. b2)
    
proc fullyContained(r1, r2: HSlice[int, int]): bool =
  (r1.a in r2 and r1.b in r2) or (r2.a in r1 and r2.b in r1) 

proc part1(input: string) =
  let ranges = readInput(input)
  var nFullyContained = 0
  for (r1, r2) in ranges:
    if fullyContained(r1, r2):
      nFullyContained += 1
  
  echo "Part 1: ", nFullyContained
  
proc partiallyContained(r1, r2: HSlice[int, int]): bool =
  (r1.a in r2 or r1.b in r2) or (r2.a in r1 or r2.b in r1) 

proc part2(input: string) =
  let ranges = readInput(input)
  var nPartiallyContained = 0
  for (r1, r2) in ranges:
    if partiallyContained(r1, r2):
      nPartiallyContained += 1

  echo "Part 2: ", nPartiallyContained

when isMainModule:
  let input = readFile("input.txt")
  part1(input)
  part2(input)

namespace AOC2022.Puzzles;

internal class Puzzle4 : Puzzle<int>
{
    protected override void Solve(string[] lines)
    {
        var overlaps = lines
            .Select(x => x.Split(',')
                .Select(range => range.Split('-').Select(int.Parse).ToList())
                .ToList())
            .Where(ranges => ranges[0][0] <= ranges[1][1] && ranges[1][0] <= ranges[0][1])
            .ToList();

        One = overlaps.Count(ranges => (ranges[0][0] <= ranges[1][0] && ranges[0][1] >= ranges[1][1]) ||
            (ranges[1][0] <= ranges[0][0] && ranges[1][1] >= ranges[0][1]));
        Two = overlaps.Count;
    }
}

public class DayFour {
	public static void main(String[] args) {

		List<String> pair = new ArrayList<>();
		try {  
			File file = new File("C:\\AoC 22\\inputDay4.txt");
			FileReader filereader = new FileReader(file);
			BufferedReader bufferedreader = new BufferedReader(filereader);
			String line;  
			while((line = bufferedreader.readLine()) != null) {  
				pair.add(line);
			}
			filereader.close();
		} catch(IOException e) { 
			e.printStackTrace();
		}

		int counter = 0;
		for(int i = 0; i < pair.size(); i++) {
			String first = pair.get(i).substring(0,pair.get(i).indexOf(','));
			String last = pair.get(i).substring(pair.get(i).indexOf(',')+1,pair.get(i).length());
							
			int firstStart = Integer.parseInt(first.substring(0,first.indexOf('-')));
			int firstEnd = Integer.parseInt(first.substring(first.indexOf('-')+1,first.length()));
			int lastStart = Integer.parseInt(last.substring(0,last.indexOf('-')));
			int lastEnd = Integer.parseInt(last.substring(last.indexOf('-')+1,last.length()));
			
			if(firstStart >= lastStart && firstEnd <= lastEnd) {
				counter++;
			} else if(lastStart >= firstStart && lastEnd <= firstEnd) {
				counter++;					
			}
		}
		System.out.println("amount of fully containing pairs: " + counter);
	
		int counterNew = 0;
		for(int i = 0; i < pair.size(); i++) {
			String first = pair.get(i).substring(0,pair.get(i).indexOf(','));
			String last = pair.get(i).substring(pair.get(i).indexOf(',')+1,pair.get(i).length());
			
			int firstStart = Integer.parseInt(first.substring(0,first.indexOf('-')));
			int firstEnd = Integer.parseInt(first.substring(first.indexOf('-')+1,first.length()));
			int lastStart = Integer.parseInt(last.substring(0,last.indexOf('-')));
			int lastEnd = Integer.parseInt(last.substring(last.indexOf('-')+1,last.length()));
		
			if((firstStart >= lastStart && firstStart <= lastEnd) || (firstEnd <= lastEnd && firstEnd >= lastStart)) {
				counterNew++;
			} else if(firstStart >= lastStart && firstEnd <= lastEnd) {
				counterNew++;
			} else if(lastStart >= firstStart && lastEnd <= firstEnd) {
				counterNew++;					
			} 
		}
		System.out.println("amount of overlapping pairs: " + counterNew);
	}
}

#include <stdio.h>

#define ROW_LEN_MAX 5

enum {
    PART_ONE,
    PART_TWO
} part;

__uint8_t getIndex(char inp)
{
    if (inp == 'A' || inp == 'X')
    {
        return 0;
    } 
    else if (inp == 'B' || inp == 'Y')
    {
        return 1;
    }
    return 2;
}

__uint8_t getIndexFromRes(__uint8_t inp, char res)
{
    if (res == 'Y')
    {
        return inp;
    }
    else if (res == 'X')
    {
        return (inp > 0)? (inp - 1) : 2;
    }
    return (inp < 2)? (inp + 1) : 0;
}

__uint16_t* solve_day_02()
{
    __uint8_t pointsTable[3][3] = {
        {4, 8, 3},
        {1, 5, 9},
        {7, 2, 6}
    };

    FILE* inputFile;
    char lineBuf[ROW_LEN_MAX];
    char you, me;
    static __uint16_t points[2] = {0, 0};

    inputFile = fopen("input/day_02.txt", "r");
    while(fgets(lineBuf, ROW_LEN_MAX, inputFile))
    {
        you = getIndex(lineBuf[0]);
        me = getIndex(lineBuf[2]);
        points[PART_ONE] += pointsTable[you][me];
        me = getIndexFromRes(you, lineBuf[2]);
        points[PART_TWO] += pointsTable[you][me];
    }
    fclose(inputFile);
    return &points[0];
}

int main(void)
{
    __uint16_t* res = solve_day_02();
    printf("**AoC-2022 day 2 part 1: %d **\n", res[PART_ONE]);
    printf("**AoC-2022 day 2 part 2: %d **\n", res[PART_TWO]);
}

use std::fs;

pub fn run() {
    let data = fs::read_to_string("dec_04.txt").expect("unable to read file");

    let mut overlaps = 0;
    let mut contains = 0;
    for line in data.lines() {
        let pairs: Vec<&str> = line.split(|c| c == '-' || c == ',').collect();

        let a1 = pairs[0].parse::<i32>().unwrap();
        let a2 = pairs[1].parse::<i32>().unwrap();
        let b1 = pairs[2].parse::<i32>().unwrap();
        let b2 = pairs[3].parse::<i32>().unwrap();

        if overlaps_at_all(a1, a2, b1, b2) {
            overlaps += 1;
        }

        if fully_contain(a1, a2, b1, b2) {
            contains += 1;
        }
    }
    println!("Part1 = {}", contains);
    println!("Part2 = {}", overlaps);
}

fn overlaps_at_all(a1: i32, a2: i32, b1: i32, b2: i32) -> bool {
    //If a ends in range b
    //Or a begins in range b
    //Or a is fully contained by b
    if a2 >= b1 && b2 >= a2 {
        return true;
    } else if a1 >= b1 && b2 >= a1 {
        return true;
    } else if a1 <= b1 && b2 <= a2 {
        return true;
    } else {
        return false;
    }
}
fn fully_contain(a1: i32, a2: i32, b1: i32, b2: i32) -> bool {
    if a1 <= b1 && b2 <= a2 {
        return true;
    } else if b1 <= a1 && a2 <= b2 {
        return true;
    } else {
        return false;
    }
}

use std::fs;

pub fn run() {
    let data = fs::read_to_string("dec_04.txt").expect("unable to read file");

    let mut overlaps = 0;
    let mut contains = 0;
    for line in data.lines() {

        let pairs: Vec<i32> = line
        .split(|c| c == '-' || c == ',')
        .filter_map(|s| s.parse::<i32>().ok())
        .collect();

        if overlaps_at_all(pairs[0], pairs[1], pairs[2], pairs[3]) {
            overlaps += 1;
        }

        if fully_contain(pairs[0], pairs[1], pairs[2], pairs[3]) {
            contains += 1;
        }
    }
    println!("Part1 = {}", contains);
    println!("Part2 = {}", overlaps);
}

fn overlaps_at_all(a1: i32, a2: i32, b1: i32, b2: i32) -> bool {
    //If a ends in range b
    //Or a begins in range b
    //Or a is fully contained by b
    if a2 >= b1 && b2 >= a2 {
        return true;
    } else if a1 >= b1 && b2 >= a1 {
        return true;
    } else if a1 <= b1 && b2 <= a2 {
        return true;
    } else {
        return false;
    }
}
fn fully_contain(a1: i32, a2: i32, b1: i32, b2: i32) -> bool {
    if a1 <= b1 && b2 <= a2 {
        return true;
    } else if b1 <= a1 && a2 <= b2 {
        return true;
    } else {
        return false;
    }
}

#include <stdio.h>
#include <string.h>
#include "common.h"

#define MAX_ROW_LEN 64

__uint16_t* solve_day_03(void)
{
    static __uint16_t result[2] = {0, 0};

    FILE* inputFile;
    char lineBuf[MAX_ROW_LEN];
    __uint64_t chars[2];
    __uint64_t group = ~0;
    __uint8_t prio;
    __uint8_t numInGroup = 0;
    
    inputFile = fopen("input/day_03.txt", "r");

    while (fgets(lineBuf, MAX_ROW_LEN, inputFile))
    {
        numInGroup++;
        chars[0] = 0;
        chars[1] = 0;

        for (int i = 0, n = strlen(lineBuf)-1; i < n; i++)
        {
            prio = (lineBuf[i] >= 'a')? (lineBuf[i] - 96) : (lineBuf[i] - 38);
            chars[i/(n/2)] |= (1ULL << prio);
            if ((chars[0] & chars[1]) && !(chars[0] & 1ULL))
            {
                result[0] += prio;
                chars[0] |= 1ULL;
            }
        }
        chars[0] &= ~1ULL;
        group &= (chars[0] |= chars[1]);
        
        if (numInGroup == 3)
        {
            numInGroup = 0;
            for (int i = 1; i < 53; i ++)
            {
                if (group & (1ULL << i))
                {
                    result[1] += i;
                    break;
                }
            }
            group = ~0;
        }
    } 
    return &result[0];   
}

int main(void)
{
    __uint16_t* res = solve_day_03();
    printf("**AoC-2022 day 2 part 1: %d **\n", res[PART_ONE]);
    printf("**AoC-2022 day 2 part 2: %d **\n", res[PART_TWO]);
    solve_day_03();
}

with open('Day4/data.txt') as file:
    data = file.readlines()

sunbset = 0
intersect = 0

for pairs in data:
    pairs = pairs.strip().replace("-",",").split(",")

    first_area = range(int(pairs[0]), int(pairs[1])+1)
    second_area = range(int(pairs[2]), int(pairs[3])+1)

    if set(first_area).issubset(second_area) or set(second_area).issubset(first_area):
        sunbset+=1
    
    if len(set(first_area).intersection(second_area)) > 0:
        intersect+=1


print(sunbset) #Part 1
print(intersect) #Part 2

package main

import (
	"bufio"
	"fmt"
	"os"
)

type Section struct {
	Start int
	End   int
}

type Pair struct {
	First  Section
	Second Section
}

func getPartOne(pairs []Pair) int {
	count := 0
	for _, pair := range pairs {
		if (pair.First.Start <= pair.Second.Start && pair.Second.End <= pair.First.End) ||
			(pair.Second.Start <= pair.First.Start && pair.First.End <= pair.Second.End) {
			count++
		}
	}
	return count
}

func getPartTwo(pairs []Pair) int {
	count := 0
	for _, pair := range pairs {
		if (pair.First.Start <= pair.Second.Start && pair.First.End >= pair.Second.Start) ||
			(pair.Second.Start <= pair.First.Start && pair.Second.End >= pair.First.Start) {
			count++
		}
	}
	return count
}

func getPartTwoUsingArray(pairs []Pair) int {
	count := 0
	for _, pair := range pairs {
		numbers := make([]bool, 100)
		for j := pair.First.Start; j <= pair.First.End; j++ {
			numbers[j] = true
		}
		for j := pair.Second.Start; j <= pair.Second.End; j++ {
			if numbers[j] {
				count++
				break
			}
		}
	}
	return count
}

func getPartTwoUsingSet(pairs []Pair) int {
	count := 0
	for _, pair := range pairs {
		numbers := make(map[int]bool, getMax(pair.First.End, pair.Second.End))
		for j := pair.First.Start; j <= pair.First.End; j++ {
			numbers[j] = true
		}
		for j := pair.Second.Start; j <= pair.Second.End; j++ {
			if _, ok := numbers[j]; ok {
				count++
				break
			}
		}
	}
	return count
}

func getMax(a int, b int) int {
	if a > b {
		return a + 1
	}
	return b + 1
}

func getRows(filename string) []Pair {
	file, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	scanner := bufio.NewScanner(file)
	rows := make([]Pair, 0)
	for scanner.Scan() {
		pair := Pair{}
		fmt.Sscanf(scanner.Text(), "%d-%d,%d-%d",
			&pair.First.Start, &pair.First.End, &pair.Second.Start, &pair.Second.End)
		rows = append(rows, pair)
	}
	return rows
}

func main() {
	fmt.Println("Part one:", getPartOne(getRows("../input.txt")))
	fmt.Println("Part two:", getPartTwo(getRows("../input.txt")))
}

package main

import "testing"



func BenchmarkPartOne(b *testing.B) {
	// run the Fib function b.N times
	rows := getRows("../input.txt")
	for n := 0; n < b.N; n++ {
		getPartOne(rows)
	}
}


func BenchmarkPartTwo(b *testing.B) {
	// run the Fib function b.N times
	rows := getRows("../input.txt")
	for n := 0; n < b.N; n++ {
		getPartTwo(rows)
	}
}

func BenchmarkPartTwoUsingArray(b *testing.B) {
	// run the Fib function b.N times
	rows := getRows("../input.txt")
	for n := 0; n < b.N; n++ {
		getPartTwoUsingArray(rows)
	}
}

func BenchmarkPartTwoUsingSet(b *testing.B) {
	// run the Fib function b.N times
	rows := getRows("../input.txt")
	for n := 0; n < b.N; n++ {
		getPartTwoUsingSet(rows)
	}
}

#include <errno.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define GENMASK(h, l) \
	(((~((__uint128_t)0)) - (((__uint128_t)1) << (l)) + 1) & \
	 (~((__uint128_t)0) >> (8*sizeof(__uint128_t) - 1 - (h))))

int parseInt(const char *str) {
	char *endptr;
	int ret;

	errno = 0;
	ret = strtol(str, &endptr, 10);

	if (errno != 0) {
		perror("Failed to parse string");
		exit(EXIT_FAILURE);
	}

	if (endptr == str) {
		fprintf(stderr, "No digits were found\n");
		exit(EXIT_FAILURE);
	}

	if (*endptr != '\0')
		printf("Warning: further characters after number: \"%s\"\n", endptr);

	return ret;
}

__uint128_t getBitMask(char *assignment) {
	int start, stop;
	char *tok;

	tok = strtok(assignment, "-\n");
	if (!tok) exit(EXIT_FAILURE);
	start = parseInt(tok);

	tok = strtok(NULL, "-\n");
	if (!tok) exit(EXIT_FAILURE);
	stop = parseInt(tok);

	return GENMASK(stop, start);
}

int main(void) {
	char *line = NULL;
	size_t len = 0;
	ssize_t nread;
	uint32_t totalCompleteOverlaps = 0;
	uint32_t totalAnyOverlaps = 0;

	FILE *fp = fopen("d4_input.txt", "r");
	if (!fp) {
		perror("Failed to open file");
		exit(EXIT_FAILURE);
	}

	while ((nread = getline(&line, &len, fp)) != -1) {
		char *assignment, *state;
		__uint128_t first, second, overlap;

		assignment = strtok_r(line, ",\n", &state);
		first = getBitMask(assignment);
		assignment = strtok_r(NULL, ",\n", &state);
		second = getBitMask(assignment);

		overlap = first & second;

		if (overlap == first || overlap == second)
			totalCompleteOverlaps += 1;

		// Part 2
		if (overlap)
			totalAnyOverlaps += 1;
	}

	free(line);
	fclose(fp);

	printf("Total complete overlappings: %"PRIu32"\n", totalCompleteOverlaps);
	printf("Total any overlappings: %"PRIu32"\n", totalAnyOverlaps);

	exit(EXIT_SUCCESS);
}