AdventOfCode 2025

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define TEST false
#include "./../aoclib.h"


// #define REAL_INPUT "./../input.txt"
// #define TEST_INPUT "./test_input.txt"

int main() {
    char input[1 << 16];
    read_file(input);
    char row[1024];
    int input_cur = 0;

    int zeroes = 0;
    int dial_value = 50;

    while (read_line(row, input, &input_cur)) {
        printf("Line read == %s\n", row);
        // printf("input_cur == %i\n", input_cur);
        bool right = row[0] == 'R' ? true : false;
        int value = atoi(&row[1]);
        int direction_multiplier = right ? 1 : -1;
        int movement = direction_multiplier * value;
        dial_value = (dial_value + movement + (100 * 100)) % 100;
        printf("dial = %i\n", dial_value);
        if (dial_value == 0) {
            zeroes++;
        }
        printf("zeroes = %i\n", zeroes);
    }
    printf("Final zeroes count = %i\n", zeroes);

    printf("\n");
    return 0;
}

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define TEST false
#include "./../aoclib.h"


// #define REAL_INPUT "./../input.txt"
// #define TEST_INPUT "./test_input.txt"

int main() {
    char input[1 << 16];
    read_file(input);
    char row[1024];
    int input_cur = 0;

    int zeroes = 0;
    int dial_value = 50;

    while (read_line(row, input, &input_cur)) {
        printf("Line read == %s\n", row);
        // printf("input_cur == %i\n", input_cur);
        bool right = row[0] == 'R' ? true : false;
        int value = atoi(&row[1]);
        int direction_multiplier = right ? 1 : -1;
        for (int idx = 0; idx < value; idx++) {
            dial_value += direction_multiplier;
            dial_value %= 100;
            if (dial_value == 0) {
                zeroes++;
            }
        }
        printf("dial = %i\n", dial_value);
        printf("zeroes = %i\n", zeroes);
    }
    printf("Final zeroes count = %i\n", zeroes);

    printf("\n");
    return 0;
}

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define REAL_INPUT "./input.txt"
#define TEST_INPUT "./test_input.txt"
#if TEST
#define FILENAME TEST_INPUT
#else
#define FILENAME REAL_INPUT
#endif

#define DEBUG false


bool read_line(char* buffer, char* source, int* cur) {
    // printf("cur before = %i\n", *cur);
    if (source[*cur] == EOF || source[(*cur) + 1] == EOF) {
        return false;
    }
    int buffer_cur = 0;
    while (source[*cur] != '\n' && source[*cur] != EOF) {
        buffer[buffer_cur] = source[*cur];
        (*cur)++;
        buffer_cur++;
    }
    while (source[*cur] == '\n') {
        (*cur)++;
    }
    buffer[buffer_cur] = '\0';
    // printf("cur after = %i\n", *cur);
    return true;
}

int read_to_delim(char* buf, char* string, char* delim, int start) {
    int buf_cur = 0;
    // if (DEBUG) printf("b+s %i\n", buf_cur + start);
    int delim_len = strlen(delim);
    if (DEBUG) printf("string: [%s]\ndelim: [%s]\nstart: [%i]\n", &string[start], delim, start);
    while (string[buf_cur + start] != '\0') {
        if (string[buf_cur + start] == delim[0]) {
            if (DEBUG) printf("delim check at %i\n", buf_cur + start);
            if (DEBUG) printf("strncmp returned %i\n", strncmp(&(string[buf_cur + start]), delim, delim_len));
            if (strncmp(&(string[buf_cur + start]), delim, delim_len) == 0) {
                buf_cur += delim_len;
                break;
            }
        }
        if (DEBUG) printf("read a %c\n", string[buf_cur + start]);

        buf[buf_cur] = string[buf_cur + start];
        buf_cur++;
    // if (DEBUG) printf("b+s %i\n", buf_cur + start);
    }
    // if (DEBUG) printf("b+s %i\n", buf_cur + start);
    buf[buf_cur] = '\0';
    if (string[buf_cur] == '\0') {
        return -1;
    }
    // if (DEBUG) printf("b+s %i\n", buf_cur + start);
    char temp;
    // scanf("%c", &temp);
    // if (DEBUG) printf("b+s %i\n", buf_cur + start);
    if (DEBUG) printf("returning %i\n", buf_cur + start);
    return buf_cur + start;
}

void read_file(char* buffer) {
    char filename[] = FILENAME;
    printf("Reading %s\n", filename);
    signed char c = 1;
    int idx = 0;
    FILE* file = fopen(filename, "r");
    if (file == NULL) {
        printf("Error: File not found! (%s)\n", filename);
        buffer = NULL;
        return;
    }
    while (c != EOF && c != '\0') {
        c = getc(file);
        // printf("Read a %c\n", c);
        buffer[idx] = c;
        idx++;
    }
    buffer[idx] = '\0';
    printf("%i bytes read from %s\n", idx, filename);
    fclose(file);
}

#!/usr/bin/env python3

import argparse

arg_parser = argparse.ArgumentParser()
arg_parser.add_argument("-t", "--test", action="store_true")
args = arg_parser.parse_args()
TEST = args.test

print(args)
print(f"TEST {'enabled' if TEST else 'disabled'}")

import itertools
from enum import Enum


filename = "./05/test_input.txt" if TEST else "./05/input.txt"


class range_set_node:
    def __init__(self, value, is_start):
        self.value = value
        self.is_start = is_start

    def __lt__(self, other):
        if self.value == other.value:
            return self.is_start
        return self.value < other.value
        
    def __gt__(self, other):
        if self.value == other.value:
            return not self.is_start
        return self.value > other.value
    def __int__(self):
        return self.value


class range_set:
    def __init__(self):
        self.nodes = []

    def cleanup(self):
        new_nodes = []
        depth = 0
        skip_next = False
        for node, next_node in itertools.pairwise(self.nodes):
            if skip_next:
                skip_next = False
                continue
            if node.value == next_node.value and (not node.is_start) and (next_node.is_start):
                skip_next = True
                continue
            if node.is_start:
                depth += 1
                if depth == 1:
                    new_nodes.append(node)
            else:
                if next_node.is_start and next_node.value == node.value + 1:
                    skip_next = True
                    continue
                depth -= 1
                if depth == 0:
                    new_nodes.append(node)
        new_nodes.append(self.nodes[-1])
        self.nodes = new_nodes

    def __len__(self):
        total = 0
        for start,end in itertools.batched(self.nodes, 2):
            total += int(end) - int(start) + 1
        return total

    def add(self, start, end):
        self.nodes.append(range_set_node(start, True))
        self.nodes.append(range_set_node(end, False))
        # self.nodes.sorted()
        self.nodes = sorted(self.nodes)
        self.cleanup()

    def __contains__(self, other):
        if not isinstance(other, int):
            raise TypeError("Not an int")
        depth = 0
        if self.nodes[0].value > other or self.nodes[-1].value < other:
            return False
        for start_node,end_node in itertools.batched(self.nodes,2):
            if int(start_node) > other:
                return False
            if int(end_node) >= other:
                return True
    def __str__(self):
        out_string = []
        for start,end in itertools.batched(ranges.nodes, 2):
            out_string.append(f"{start.value} -")
            out_string.append(f"{end.value};")
        return "\n".join(out_string)


with open(filename, "r") as f:
    input_text = f.read().strip()

input_p1, input_p2 = input_text.split("\n\n")
input_p1 = input_p1.split("\n")
input_p2 = input_p2.split("\n")

ranges = range_set()

for line in input_p1:
    start, end = line.split("-")
    start, end = (int(start), int(end))
    # range_group.add(nrange(start, end))
    ranges.add(start, end)

fresh_count = 0

for line in input_p2:
    food_id = int(line)
    if food_id in ranges:
        fresh_count += 1


for start,end in itertools.batched(ranges.nodes, 2):
    print(f"{int(start)}-{int(end)};",end="")

print(ranges)

print(f"{fresh_count=}")
print(f"{(len(ranges))=}")

#!/usr/bin/env python3

import argparse
import itertools
from enum import Enum

arg_parser = argparse.ArgumentParser()
arg_parser.add_argument("-t", "--test", action="store_true")
args = arg_parser.parse_args()
TEST = args.test

DAY = "07"

filename = "test_input" if TEST else "input"

file_path = f"./{DAY}/{filename}.txt"

with open(file_path, "r") as f:
    full_input = f.read().strip("\n")

lines = full_input.split("\n")

beams = set()

for x, char in enumerate(lines[0]):
    if char == "S":
        beams.add(x)

splits = 0

for line in lines[1:]:
    new_beams = set()
    for x, char in enumerate(line):
        if x in beams:
            if char == "^":
                new_beams.add(x - 1)
                new_beams.add(x + 1)
                splits += 1
            else:
                new_beams.add(x)
    beams = new_beams

print(splits)

#!/usr/bin/env python3

import argparse
import itertools
from enum import Enum

arg_parser = argparse.ArgumentParser()
arg_parser.add_argument("-t", "--test", action="store_true")
args = arg_parser.parse_args()
TEST = args.test

DAY = "07"

filename = "test_input" if TEST else "input"

file_path = f"./{DAY}/{filename}.txt"

with open(file_path, "r") as f:
    full_input = f.read().strip("\n")

lines = full_input.split("\n")

beams = {}

for x, char in enumerate(lines[0]):
    if char == "S":
        beams[x] = 1

splits = 0

def increment_beam(beam_list,x,value):
    if x not in beam_list:
        beam_list[x] = 0
    beam_list[x] += value

for line in lines[1:]:
    new_beams = {}
    for x, char in enumerate(line):
        if x in beams:
            beam_count = beams[x]
            if char == "^":
                increment_beam(new_beams,x-1,beam_count)
                increment_beam(new_beams,x+1,beam_count)
                splits += 1
            else:
                increment_beam(new_beams,x,beam_count)
    beams = new_beams

print(splits)

print(sum(tuple(beams.values())))

#!/usr/bin/env python3

with open("./02/input.txt", "r") as f:
    input_data = f.read().strip()

cases = input_data.split(",")

total_sum = 0


def range_sum(minimum, maximum):
    length = len(str(minimum))

    low = sum(range(minimum, maximum + 1))
    high = low * pow(10, length)
    return low + high



def id_validation_bs(case):
    case_sum = 0
    print(f"handling {case}")
    minimum_str, maximum_str = case.split("-")
    min_len = len(minimum_str)
    if min_len % 2 == 1:
        min_len += 1
    digit_counts = [n for n in range(min_len, len(maximum_str) + 1, 2)]
    print(digit_counts)
    for digit_count in digit_counts:
        sub_count = digit_count // 2
        local_min = int("1" + ("0" * (sub_count - 1)))
        local_max = int("9" * sub_count)
        if digit_count == len(minimum_str):
            if int(minimum_str[:sub_count]) < int(minimum_str[sub_count:]):
                local_min = int(minimum_str[:sub_count]) + 1
            else:
                local_min = int(minimum_str[:sub_count])
        if digit_count == len(maximum_str):
            if int(maximum_str[:sub_count]) > int(maximum_str[sub_count:]):
                local_max = int(maximum_str[:sub_count]) - 1
            else:
                local_max = int(maximum_str[:sub_count])
        if local_min > local_max:
            print("skip!")
            continue
        print(f"range is from {local_min} to {local_max}")
        local_sum = range_sum(local_min, local_max)
        case_sum += local_sum
    return case_sum

for case in cases:
    total_sum += id_validation_bs(case)
print(f"sum is now {total_sum}")