AdventOfCode/C/2024/Day_1/main.c

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

#define IMP
#include "../../file.h"

size_t cstr_char_count(const char *cstr, char c);
int cmp_sort(const void *this, const void *other);

int
main(int argc, char *argv[])
{
	enum file_err ferr;
	size_t line_num = 0;
	size_t i = 0;
	long res = 0;

	long *left = NULL;
	size_t left_size = 0;

	long *right = NULL;
	size_t right_size = 0;

	char *raw_input = NULL;
	size_t raw_input_size = 0;
	raw_input = (char *) file_read_all("./input.txt", 
					   &raw_input_size,
					   &ferr);
	if ( ferr != FILE_ERR_OK ) {
		fprintf(stderr, "Failed to open file: %s\n", 
			file_err_to_cstr(ferr));
		exit(EXIT_FAILURE);
	}

	line_num = cstr_char_count(raw_input, '\n');

	left = calloc(line_num+1, sizeof(*left));
	right = calloc(line_num+1, sizeof(*right));

	{
	long ret = -1;
	char *str = raw_input;
	char *nstr = NULL;
	long *doing = left;
	size_t *doing_size = &left_size;

	while ( true ) {
		ret = strtol(str, &nstr, 10);
		if ( ret == 0 ) {
			break;
		}
		str = nstr;

		doing[(*doing_size)++] = ret;

		if ( doing == left ) {
			doing = right;
			doing_size = &right_size;
		} else {
			doing = left;
			doing_size = &left_size;
		}
	}
	}

	if ( left_size != right_size ) {
		printf("Sizes differ");
		exit(EXIT_FAILURE);
	}

	if ( argc == 1 ) {
		qsort(left, left_size, sizeof(*left), cmp_sort);
		qsort(right, right_size, sizeof(*right), cmp_sort);

		for ( i = 0; i < left_size; ++i ) {
			res += labs(left[i] - right[i]);
		}
	} else {
		for ( i = 0; i < left_size; ++i ) {
			size_t j = 0;
			long it = left[i];
			long count = 0;
			for ( j = 0; j < right_size; ++j ) {
				count += ( it == right[j] );
			}

			res += it * count;
		
		}
	}


	printf("Result: %ld\n", res);

	free(left);
	free(right);

	free(raw_input);

	(void) argc; (void) argv;
	return 0;
}

size_t 
cstr_char_count(const char *cstr, char c)
{
	size_t ret = 0;
	while ( *cstr != '\0' ) {
		ret += ( *cstr == c );
		cstr++;
	}
	return ret;
}

int 
cmp_sort(const void *this, const void *other)
{
	long this_ = *((long*) this);
	long other_ = *((long*) other);

	return (int) (this_ - other_);
}