🌟 Advent of Code (AoC) 2023 🌟

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

#define MAXLINE 64
#define MAXHANDS 1000
#define NUMCARDS 13
#define HANDSIZE 5

// Datatype for problem description.
typedef struct Hand {
    char cards[HANDSIZE+1];
    int bid;
    int strength;
} Hand;

// Global variables for game rules.
char CARDS[NUMCARDS+1] = "23456789TJQKA";
char* JOKERCARDS = NULL;

// Function declarations.
int play(Hand* hands);
Hand* parseInput();
void score(Hand* h);
int typestrength(Hand* h);
int secondarystrength(Hand* h);
int countcards(Hand* h, char card);
int cmp(const void* a, const void* b);

int main()
{
    Hand* hands = parseInput();
    int part1 = play(hands);
    JOKERCARDS = "J23456789TQKA"; // Activates joker rules.
    int part2 = play(hands);
    free(hands);
    printf("Part 1: %i\nPart 2: %i\n", part1, part2);
}

int play(Hand* hands)
{
    int result = 0, numhands = 0;
    // Update score for each hand, also count number of hands.
    while (numhands<MAXHANDS && hands[numhands].cards[0] != '\0')
        score(&hands[numhands++]);
    // Sort based on scores, and sum the winnings.
    qsort(hands, numhands, sizeof (Hand), cmp);
    for (int i=0; i<MAXHANDS && hands[i].cards[0] != '\0'; ++i)
        result += (i+1)*hands[i].bid;
    return result;
}

Hand* parseInput()
{
    Hand* hands = calloc(MAXHANDS, sizeof (Hand));
    int i = 0;
    char line[MAXLINE];
    FILE* fptr = fopen("input", "r");
    while (fgets(line, sizeof line, fptr) != NULL) {
        strncpy(hands[i].cards, line, HANDSIZE);
        hands[i].cards[HANDSIZE] = '\0';
        hands[i++].bid = atoi(line + 6);
    }
    fclose(fptr);
    return hands;
}

// Calculate and store the relative strength of a hand.
void score(Hand* h)
{
    h->strength = typestrength(h) + secondarystrength(h);
}

// The primary hand strength, based on hand type.
int typestrength(Hand* h)
{
    int first = 0; // Number of cards in the first group.
    int snd = 0; // Number of cards in 2nd first group.
    int jokers = JOKERCARDS ? countcards(h, 'J') : 0;
    for (int i=0; i<NUMCARDS; ++i) {
        if (JOKERCARDS && CARDS[i] == 'J')
            continue;
        int num = countcards(h, CARDS[i]);
        if (num >= first) {
            snd = first;
            first = num;
        }
        else if (num > snd)
            snd = num;
    }
    if (first + jokers >= 5) return 6e6; // Five of a kind.
    if (first + jokers >= 4) return 5e6; // Four of a kind.
    if (first + snd + jokers >= 5) return 4e6; // Full house.
    if (first + jokers >= 3) return 3e6; // Three of a kind.
    if (first + snd + jokers >= 4) return 2e6; // Two pair.
    if (first + jokers >= 2) return 1e6; // One pair.
    return 0;
}

// In a given hand h, return the number of cards equal to c.
int countcards(Hand* h, char c)
{
    int count = 0;
    for (int i=0; i<HANDSIZE; ++i)
        count += h->cards[i] == c;
    return count;
}

// The strength based on card values, used to break ties.
int secondarystrength(Hand* h)
{
    int str = 0;
    char* card_order = JOKERCARDS ? JOKERCARDS : CARDS;
    for (int i=0; i<HANDSIZE; ++i)
        str = NUMCARDS*str + strchr(card_order, h->cards[i]) - card_order;
    return str;
}

// Help function to qsort, compares hand strengths.
int cmp(const void* a, const void* b)
{
    return ((const Hand*)a)->strength - ((const Hand*)b)->strength;
}

val path  = """8.txt"""
val input = Using.resource(Source.fromFile(path))(_.getLines().toVector)

lazy val instructions: LazyList[Char] = input.head.to(LazyList) #::: instructions

val network = input
   .drop(2)
   .map:
      case s"$from = ($toL, $toR)" => from -> (toL, toR)
   .toMap

def solve(net: Map[String, (String, String)], instr: LazyList[Char], start: String, goal: String => Boolean) =
   def recur(instr: LazyList[Char], curr: String, steps: Int): Int =
      if goal(curr) then steps
      else
         val next = instr.head match
            case 'L' => net(curr)._1
            case 'R' => net(curr)._2
         recur(instr.tail, next, steps + 1)
   recur(instr, start, 0)

// del 1:
solve(network, instructions, "AAA", _ == "ZZZ")

def lcm(a: Long, b: Long): Long =
   def gcd(a: Long, b: Long): Long =
      if b == 0 then a
      else gcd(b, a % b)
   (a * b) / gcd(a, b)

// del 2:
network.keysIterator
   .filter(_.endsWith("A"))
   .map(start => solve(network, instructions, start, _.endsWith("Z")).toLong)
   .reduce(lcm)

I ← ⊜□≠@\n.&fras "1.txt"
D ← +@0⇡10
W ← {"zero""one""two""three""four""five""six""seven""eight""nine"}
/+≡(⋕⊏0_¯1▽∊:D.°□) I   # del1
/+≡(/+×10_1⊏0_¯1▽≠0./+↥∩(×⇡10)∩(≡⊐⌕)D,W¤) I   # del2

I ← ⊜□≠@\n.&fras "2.txt"
C ← ⊠(/↥≡(⋕⊏1)regex $"(\\d+) _") "rgb" I
/++1⊚/↧≤12_13_14 C # del1
/+/× C             # del2

import fs from 'fs'

const FILE_PATH = './src/resources/08.txt'

type NodeValue = string

interface Node {
  value: NodeValue
  leftNode: NodeValue
  rightNode: NodeValue
}

const START_NODE = 'AAA'
const FINAL_NODE = 'ZZZ'

const TYPE_INSTRUCTION = ['L', 'R']
type Instruction = typeof TYPE_INSTRUCTION[number]

export default function findCorrectNode (): void {
  const lines = fs.readFileSync(FILE_PATH, 'utf-8').trim().split('\n')

  // First line is our instructions
  const instructions: Instruction[] = getInstructions(lines[0])

  const nodes: Node[] = createNodes(lines)

  const steps: number = getStepsBetweenNodes(START_NODE, FINAL_NODE, nodes, instructions)
  console.log('Total step: ', steps)
}

function getInstructions (line: string): Instruction[] {
  const instructions: Instruction[] = []
  for (const char of line) {
    if (TYPE_INSTRUCTION.includes(char)) {
      instructions.push(char)
    }
  }
  return instructions
}

function createNodes (lines: string[]): Node[] {
  const nodes: Node[] = []

  lines.slice(1).forEach((line, index) => {
    const values = line.replace(/\s/g, '').split(/[=(),]/).filter(Boolean)
    if (values.length === 0) return
    nodes.push({
      value: values[0],
      leftNode: values[1],
      rightNode: values[2]
    })
  })
  return nodes
}

function getStepsBetweenNodes (start: NodeValue, end: NodeValue, nodes: Node[], instructions: Instruction[]): number {
  let currentNode: Node = getNodeWithValue(nodes, start)

  let steps = 0
  let currentInstructionIndex = 0

  while (currentNode?.value !== end) {
    steps++

    // Move on to the left or right node depending on instruction
    if (instructions[currentInstructionIndex] === 'R') {
      currentNode = getNodeWithValue(nodes, currentNode.rightNode)
    } else if (instructions[currentInstructionIndex] === 'L') {
      currentNode = getNodeWithValue(nodes, currentNode.leftNode)
    }

    currentInstructionIndex++
    // Restart if we passed the end of our instructions
    if (currentInstructionIndex >= instructions.length) currentInstructionIndex = 0
  }

  return steps
}

function getNodeWithValue (nodes: Node[], value: NodeValue): Node {
  return (nodes.find((node) => node.value === value) ?? { value: '', leftNode: '', rightNode: '' })
}

import fs from 'fs'
import { findLCM } from '../helpers/array_helpers'

const FILE_PATH = './src/resources/08.txt'

type NodeValue = string

interface Node {
  value: NodeValue
  leftNode?: Node
  rightNode?: Node
}

const START_NODE_LAST_VALUE = 'A'
const FINAL_NODE_LAST_VALUE = 'Z'

const TYPE_INSTRUCTION = ['L', 'R']
type Instruction = typeof TYPE_INSTRUCTION[number]

export default function findCorrectNodesSimultaneously (): void {
  const lines = fs.readFileSync(FILE_PATH, 'utf-8').trim().split('\n')

  // First line is our instructions
  const instructions: Instruction[] = getInstructions(lines[0])

  const nodes: Node[] = createNodes(lines)

  const nodeStepsToFinnish: number[] = []
  const startNodes: Node[] = nodes.filter((node) => node.value.endsWith(START_NODE_LAST_VALUE))
  startNodes.forEach((node) => {
    nodeStepsToFinnish.push(getStepsBetweenNodes(node, FINAL_NODE_LAST_VALUE, nodes, instructions))
  })

  console.log('Minimum number of steps: ', findLCM(nodeStepsToFinnish))
}

function getInstructions (line: string): Instruction[] {
  const instructions: Instruction[] = []
  for (const char of line) {
    if (TYPE_INSTRUCTION.includes(char)) {
      instructions.push(char)
    }
  }
  return instructions
}

function createNodes (lines: string[]): Node[] {
  const nodes: Node[] = []

  const rawValues: string[][] = []

  lines.slice(1).forEach((line, index) => {
    const values = line.replace(/\s/g, '').split(/[=(),]/).filter(Boolean)
    if (values.length === 0) return

    rawValues.push(values)

    nodes.push({
      value: values[0]
    })
  })

  rawValues.forEach((value) => {
    const index = nodes.findIndex((node) => node.value === value[0])
    nodes[index].leftNode = nodes.find((node) => node.value === value[1])
    nodes[index].rightNode = nodes.find((node) => node.value === value[2])
  })

  return nodes
}

function getStepsBetweenNodes (start: Node, end: NodeValue, nodes: Node[], instructions: Instruction[]): number {
  let currentNode: Node | undefined = start

  let steps = 0
  let currentInstructionIndex = 0

  while (true) {
    steps++

    // Move on to the left or right node depending on instruction
    if (instructions[currentInstructionIndex] === 'R') {
      currentNode = currentNode?.rightNode
    } else if (instructions[currentInstructionIndex] === 'L') {
      currentNode = currentNode?.leftNode
    }

    currentInstructionIndex++
    // Restart if we passed the end of our instructions
    if (currentInstructionIndex >= instructions.length) currentInstructionIndex = 0

    // We found the end
    if (currentNode?.value[2] === end) break
  }

  return steps
}

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

#define MAXLINE 300
#define MAXLINES 1000
#define NODENAMELEN 4
#define MAXLOOPS 10

typedef struct Node {
    char name[NODENAMELEN];
    struct Node* left;
    struct Node* right;
} Node;

typedef struct Problem {
    char path[MAXLINE];
    int pathlen;
    Node nodes[MAXLINES];
    int numnodes;
} Problem;

int part1(Problem* p);
long int part2(Problem* p);
Problem* parseInput(char* filename);
void findloop(Problem* p, int n, long int* loopstart, int* looplen);
Node* setlocation(Problem* p, char* dst);

int main()
{
    Problem* prob = parseInput("input");
    int p1 = part1(prob);
    long int p2 = part2(prob);
    printf("Part 1: %i\nPart 2: %li\n", p1, p2);
    free(prob);
    assert(p1 == 16531);
    assert(p2 == 24035773251517);
}

int part1(Problem* p)
{
    Node* loc = setlocation(p, "AAA");
    Node* dest = setlocation(p, "ZZZ");
    int count = 0;
    while (loc != dest) {
        loc = p->path[count%p->pathlen] == 'L' ? loc->left : loc->right;
        ++count;
    }
    return count;
}

/* For part 2, walk from each starting node until we can
 * identify a loop. For each loop, save its start point and
 * its length.
 */
long int part2(Problem* p)
{
    long int* loop = calloc(MAXLOOPS, sizeof (long int));
    int* step = calloc(MAXLOOPS, sizeof (int));
    // Find nodes ending with 'A' and loop.
    int numloops = 0;
    for (int n=0; n<p->numnodes; ++n)
        if (p->nodes[n].name[2] == 'A') {
            findloop(p, n, &(loop[numloops]), &(step[numloops]));
            ++numloops;
        }
    while (1) {
        // Check if we are done.
        int done = 1;
        for (int i = 1; i < numloops; ++i)
            if (loop[i] != loop[0])
                done = 0;
        if (done)
            break;
        // Step the loop least farthest along.
        int smallest = 0;
        for (int i = 1; i < numloops; ++i)
            if (loop[i] < loop[smallest])
                smallest = i;
        loop[smallest] += step[smallest];
    }
    return loop[0];
}

void findloop(Problem* p, int n, long int* loopstart, int* looplen)
{
    int i = 0;
    Node* loc = &(p->nodes[n]);
    while (1) {
        loc = p->path[i%p->pathlen] == 'L' ? loc->left : loc->right;
        ++i;
        if (loc->name[2] == 'Z') {
            if (*loopstart == 0)
                *loopstart = i;
            else if (*looplen == 0) {
                *looplen = i - *loopstart;
                return;
            }
        }
    }
}

// Set location to a name, rather than pointer.
Node* setlocation(Problem* p, char* dst)
{
    for (int n=0; n<p->numnodes; ++n)
        if (strncmp(p->nodes[n].name, dst, NODENAMELEN) == 0)
            return &(p->nodes[n]);
    return NULL;
}

Problem* parseInput(char* filename)
{
    Problem* p = calloc(1, sizeof (Problem));
    // Temporary storage for left/right names, do be
    // replaced with pointers when all names are read.
    char leftnames[MAXLINES][NODENAMELEN];
    char rightnames[MAXLINES][NODENAMELEN];
    memset(leftnames, 0, MAXLINES*NODENAMELEN);
    memset(rightnames, 0, MAXLINES*NODENAMELEN);
    FILE* fptr = fopen(filename, "r");
    if (fgets(p->path, MAXLINE, fptr) != NULL)
        p->path[strcspn(p->path, "\n")] = '\0';
    p->pathlen = strlen(p->path);
    fgetc(fptr); // Skip blank line.
    while (3 == fscanf(fptr, "%3s = (%3s, %3s)",
                p->nodes[p->numnodes].name,
                leftnames[p->numnodes],
                rightnames[p->numnodes]))
        ++p->numnodes;
    // When all node names are read, go back and update
    // left/right pointers.
    for (int i=0; i<p->numnodes; ++i) {
        for (int j=0; j<p->numnodes; ++j) {
            if (strncmp(leftnames[i], p->nodes[j].name, NODENAMELEN) == 0)
                p->nodes[i].left = &(p->nodes[j]);
            if (strncmp(rightnames[i], p->nodes[j].name, NODENAMELEN) == 0)
                p->nodes[i].right = &(p->nodes[j]);
        }
    }
    fclose(fptr);
    return p;
}

I ← ⊜(⊜⋕≠@\s.)≠@\n.&fras "9.txt"
E ← /+≡(;⍢⊃(≡/-◫2|+⊢⇌)(/↥≠0):0)
E I   # del1
E ≡⇌I # del2

import { readFileSync } from 'fs'

const FILE_PATH = './src/resources/09.txt'

type Sequence = number[]

export default function (): void {
  const lines = readFileSync(FILE_PATH, 'utf-8').trim().split('\n')
  const sequences: Sequence[] = getValuesArray(lines)

  const predictions: number[] = []
  sequences.forEach((sequence) => {
    predictions.push(getPrediction(sequence))
  })
  console.log('Sum of predictions: ', predictions.reduce((acc, next) => acc + next))
}

function getPrediction (sequence: Sequence): number {
  const currentSequenceArray: Sequence[] = []
  currentSequenceArray.push(sequence)

  // Loops until every value of last sequence is 0
  while (!currentSequenceArray[currentSequenceArray.length - 1].every((val) => val === 0)) {
    const currentSeq: Sequence = currentSequenceArray[currentSequenceArray.length - 1]
    const newSeq: Sequence = []
    for (let i = 0; i < currentSeq.length - 1; i++) {
      const diff = currentSeq[i + 1] - currentSeq[i]
      newSeq.push(diff)
    }
    currentSequenceArray.push(newSeq)
  }

  let valueForNextIteration: number = 0
  const reversedArr = currentSequenceArray.reverse()
  for (let i = 0; i < reversedArr.length; i++) {
    const currentSequence: Sequence = reversedArr[i]

    const valueToAdd: number = currentSequence[currentSequence.length - 1] + valueForNextIteration
    valueForNextIteration = valueToAdd
  }

  return valueForNextIteration
}

function getValuesArray (lines: string[]): Sequence[] {
  const arr: Sequence[] = []
  lines.forEach((line) => {
    const values = line.split(' ')
    const currentSequence: Sequence = []
    values.forEach((value) => {
      currentSequence.push(parseInt(value))
    })
    arr.push(currentSequence)
  })

  return arr
}

import { readFileSync } from 'fs'

const FILE_PATH = './src/resources/09.txt'

type Sequence = number[]

export default function (): void {
  const lines = readFileSync(FILE_PATH, 'utf-8').trim().split('\n')
  const sequences: Sequence[] = getValuesArray(lines)

  const predictions: number[] = []
  sequences.forEach((sequence) => {
    predictions.push(getPrediction(sequence))
  })
  console.log('Sum of predictions: ', predictions.reduce((acc, next) => acc + next))
}

function getPrediction (sequence: Sequence): number {
  const currentSequenceArray: Sequence[] = []
  currentSequenceArray.push(sequence)

  // Loops until every value of last sequence is 0
  while (!currentSequenceArray[currentSequenceArray.length - 1].every((val) => val === 0)) {
    const currentSeq: Sequence = currentSequenceArray[currentSequenceArray.length - 1]
    const newSeq: Sequence = []
    for (let i = 0; i < currentSeq.length - 1; i++) {
      const diff = currentSeq[i + 1] - currentSeq[i]
      newSeq.push(diff)
    }
    currentSequenceArray.push(newSeq)
  }

  let valueForNextIteration: number = 0
  const reversedArr = currentSequenceArray.reverse()
  for (let i = 0; i < reversedArr.length; i++) {
    const currentSequence: Sequence = reversedArr[i]

    const valueToAdd: number = currentSequence[0] - valueForNextIteration
    valueForNextIteration = valueToAdd
  }

  return valueForNextIteration
}

function getValuesArray (lines: string[]): Sequence[] {
  const arr: Sequence[] = []
  lines.forEach((line) => {
    const values = line.split(' ')
    const currentSequence: Sequence = []
    values.forEach((value) => {
      currentSequence.push(parseInt(value))
    })
    arr.push(currentSequence)
  })

  return arr
}