291 lines
8.0 KiB
C
291 lines
8.0 KiB
C
/* aoc-c.c: Advent of Code 2019, day 4 parts 1 & 2
|
|
*
|
|
* Copyright (C) 2021 Bruno Raoult ("br")
|
|
* Licensed under the GNU General Public License v3.0 or later.
|
|
* Some rights reserved. See COPYING.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with this
|
|
* program. If not, see <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
|
|
*
|
|
* SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include <malloc.h>
|
|
#include <getopt.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "debug.h"
|
|
#include "pool.h"
|
|
|
|
/**
|
|
* As the character set is [1-9A-Z], the trie arrays size will be 26 + 9 = 35,
|
|
* organized as:
|
|
* char: 1 2 ... 8 9 A B ... Y Z
|
|
* index: 0 1 ... 7 8 9 10 ... 33 34
|
|
*/
|
|
#define TRIESIZE ('Z' - 'A' + 1 + '9' - '1' + 1)
|
|
#define c2index(c) ((c) >= 'A'? (c) - 'A' + 9: (c) - '1')
|
|
#define index2c(c) ((c) >= 9? (c) + 'A' - 9: (c) + '1')
|
|
|
|
/**
|
|
* object_t - object representation
|
|
* @parent: a pointer to the object we orbit around
|
|
* @sibling: a list of objects orbiting around @parent
|
|
* @child: a list of object orbiting around this object
|
|
* @name: the object name
|
|
*/
|
|
typedef struct object {
|
|
struct object *parent;
|
|
struct list_head sibling, child;
|
|
char name[8];
|
|
} object_t;
|
|
|
|
/**
|
|
* trie_t - trie node
|
|
* @child: array of pointers to node_t children of current node
|
|
* @str: current string (for debug)
|
|
* @is_object: 1: this is an object, 0 if not
|
|
* @data: pointer to an object
|
|
*/
|
|
typedef struct trie {
|
|
struct trie *child[TRIESIZE];
|
|
//char str[8];
|
|
int is_object;
|
|
object_t data;
|
|
} trie_t;
|
|
|
|
/**
|
|
* parent_t - list of parents for an object
|
|
* @object - address of parent object
|
|
* @list - next parent
|
|
*
|
|
* For example, if A orbits around B, which orbits around COM, list will be:
|
|
* head -> COM -> B -> A
|
|
*/
|
|
typedef struct {
|
|
object_t *object;
|
|
struct list_head list;
|
|
} parent_t;
|
|
|
|
static pool_t *pool_tries, *pool_parents;
|
|
|
|
static trie_t *trie_get(trie_t *parent, char *name, int pos)
|
|
{
|
|
trie_t *trie;
|
|
static int count = 0;
|
|
count++;
|
|
|
|
log_f(3, "parent=%p name=%s pos=%d\n", parent, name, pos);
|
|
if ((trie = pool_get(pool_tries))) {
|
|
for (int i = 0; i < TRIESIZE; ++i)
|
|
trie->child[i] = NULL;
|
|
//*trie->str = 0;
|
|
trie->is_object = 0;
|
|
if (parent) {
|
|
int index = c2index(name[pos]);
|
|
parent->child[index] = trie;
|
|
log(3, "setting parent %p[%c] to %p\n", parent, name[pos], trie);
|
|
//strncpy(trie->str, name, pos + 1);
|
|
}
|
|
}
|
|
log(3, "\tnew trie=%p total = %d\n", trie, count);
|
|
return trie;
|
|
}
|
|
|
|
static void trie_print(trie_t *trie, int depth)
|
|
{
|
|
if (depth == 0)
|
|
log_f(3, "root=%p depth=%d\n", trie, depth);
|
|
if (trie->is_object) {
|
|
printf("%*sOBJECT %s parent=%s\n", depth * 4, "", trie->data.name,
|
|
trie->data.parent? trie->data.parent->name: "NIL");
|
|
}
|
|
for (int i = 0; i < TRIESIZE; ++i) {
|
|
if (trie->child[i]) {
|
|
printf("%*s+%c\n", depth * 4, "", index2c(i));
|
|
trie_print(trie->child[i], depth + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void tree_print(object_t *object, int depth)
|
|
{
|
|
if (depth == 0)
|
|
log_f(3, "root=%p depth=%d\n", object, depth);
|
|
printf("%*sOBJECT %s\n", depth * 4, "", object->name);
|
|
if (!list_empty(&object->child)) {
|
|
object_t *cur;
|
|
list_for_each_entry(cur, &object->child, sibling) {
|
|
tree_print(cur, depth + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int orbit_count(object_t *object, int depth)
|
|
{
|
|
int ret = depth;
|
|
if (!list_empty(&object->child)) {
|
|
object_t *cur;
|
|
list_for_each_entry(cur, &object->child, sibling) {
|
|
ret += orbit_count(cur, depth + 1);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static trie_t *trie_find(trie_t *root, char *name)
|
|
{
|
|
int len = strlen(name);
|
|
trie_t *cur = root;
|
|
|
|
for (int i = 0; i < len; ++i) {
|
|
int ind = c2index(name[i]);
|
|
cur = cur->child[ind] ?
|
|
cur->child[ind]:
|
|
trie_get(cur, name, i);
|
|
}
|
|
if (!cur->is_object) {
|
|
cur->data.parent = NULL;
|
|
cur->is_object = 1;
|
|
strcpy(cur->data.name, name);
|
|
INIT_LIST_HEAD(&cur->data.child);
|
|
INIT_LIST_HEAD(&cur->data.sibling);
|
|
}
|
|
return cur;
|
|
}
|
|
|
|
static object_t *object_find(trie_t *root, char *object)
|
|
{
|
|
object_t *ret = &trie_find(root, object)->data;
|
|
log_f(3, "object = %p - %s\n", ret, ret->name);
|
|
return ret;
|
|
}
|
|
|
|
static int count_path(trie_t *root, char *name1, char *name2)
|
|
{
|
|
object_t *obj1 = object_find(root, name1);
|
|
object_t *obj2 = object_find(root, name2);
|
|
parent_t *parent, *parent1, *parent2;
|
|
LIST_HEAD(list1);
|
|
LIST_HEAD(list2);
|
|
int count1 = 0, count2 = 0;
|
|
while (obj1->parent) {
|
|
count1++;
|
|
obj1 = obj1->parent;
|
|
parent = pool_get(pool_parents);
|
|
parent->object = obj1;
|
|
list_add(&parent->list, &list1);
|
|
}
|
|
while (obj2->parent) {
|
|
count2++;
|
|
obj2 = obj2->parent;
|
|
parent = pool_get(pool_parents);
|
|
parent->object = obj2;
|
|
list_add(&parent->list, &list2);
|
|
}
|
|
parent1 = list_first_entry_or_null(&list1, parent_t, list);
|
|
parent2 = list_first_entry_or_null(&list2, parent_t, list);
|
|
while (parent1->object == parent2->object) {
|
|
count1--;
|
|
count2--;
|
|
parent = parent1;
|
|
parent1 = list_next_entry(parent1, list);
|
|
//list_del(parent1->list.prev);
|
|
parent2 = list_next_entry(parent2, list);
|
|
//list_del(parent2->list.prev);
|
|
}
|
|
printf ("common ancestor = %s\n", parent->object->name);
|
|
printf("count1 = %d count2 = %d\n", count1, count2);
|
|
return count1 + count2;
|
|
}
|
|
|
|
static void object_link(trie_t *root, char *star, char *planet)
|
|
{
|
|
object_t *st, *pl;
|
|
log_f(3, "linking planet %s to star %s\n", planet, star);
|
|
st = object_find(root, star);
|
|
pl = object_find(root, planet);
|
|
pl->parent = st;
|
|
list_add(&pl->sibling, &st->child);
|
|
}
|
|
|
|
static void parse(trie_t *root)
|
|
{
|
|
char *star, *planet;
|
|
|
|
size_t alloc = 0;
|
|
ssize_t buflen;
|
|
char *buf = NULL;
|
|
|
|
while ((buflen = getline(&buf, &alloc, stdin)) > 0) {
|
|
star = strtok(buf, ")\n");
|
|
planet = strtok(NULL, ")\n");
|
|
printf ("read [%s][%s]\n", star, planet);
|
|
object_link(root, star, planet);
|
|
//hash = hash_string(NULL, star, strlen(star));
|
|
//log(3, "hash(%s) = %u\n", star, hash);
|
|
|
|
}
|
|
free(buf);
|
|
}
|
|
|
|
static int usage(char *prg)
|
|
{
|
|
fprintf(stderr, "Usage: %s [-d debug_level] [-p part]\n", prg);
|
|
return 1;
|
|
}
|
|
|
|
int main(int ac, char **av)
|
|
{
|
|
int opt, part = 1;
|
|
|
|
while ((opt = getopt(ac, av, "d:p:")) != -1) {
|
|
switch (opt) {
|
|
case 'd':
|
|
debug_level_set(atoi(optarg));
|
|
break;
|
|
case 'p': /* 1 or 2 */
|
|
part = atoi(optarg);
|
|
if (part < 1 || part > 2)
|
|
default:
|
|
return usage(*av);
|
|
}
|
|
}
|
|
if (optind < ac)
|
|
return usage(*av);
|
|
pool_tries = pool_create("tries", 1024, sizeof(trie_t));
|
|
pool_parents = pool_create("parents", 1024, sizeof(parent_t));
|
|
|
|
trie_t *root = trie_get(NULL, NULL, 0);
|
|
/*
|
|
printf("size = %d\n", TRIESIZE);
|
|
printf("0 = %d\n", c2index('0'));
|
|
printf(" 0 = %c\n", index2c(0));
|
|
printf("1 = %d\n", c2index('1'));
|
|
printf(" 1 = %c\n", index2c(1));
|
|
printf("9 = %d\n", c2index('9'));
|
|
printf(" 8 = %c\n", index2c(8));
|
|
printf("A = %d\n", c2index('A'));
|
|
printf(" A = %c\n", index2c(9));
|
|
printf("Z = %d\n", c2index('Z'));
|
|
printf(" Z = %c\n", index2c(34));
|
|
*/
|
|
//trie_find(root, "COM");
|
|
//trie_find(root, "CAM");
|
|
//trie_print(root, 0);
|
|
//exit(0);
|
|
parse(root);
|
|
object_t *root_obj = object_find(root, "COM");
|
|
trie_print(root, 0);
|
|
tree_print(root_obj, 0);
|
|
printf("%s : res=%d\n", *av,
|
|
part == 1 ? orbit_count(object_find(root, "COM"), 0) :
|
|
count_path(root, "YOU", "SAN"));
|
|
//ancestor_find(root, "YOU", "SAN");
|
|
pool_destroy(pool_tries);
|
|
exit (0);
|
|
}
|