🌟 Advent of Code (AoC) 2023 🌟

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

#define MAXLINE 256
#define MAXSEEDS 20
#define NMAPS 7
#define NFIELDS 3
#define NRULES 64
#define DEST 0
#define SRC 1
#define RANGE 2
#define EMPTY -1
#define FORWARD 0
#define BACKWARD 1
#define MIN(a,b) ((a) < (b) ? (a) : (b))

void readproblemfile(long int seeds[MAXSEEDS], long int maps[NMAPS][NRULES][NFIELDS]);
void readlist(char* str, long int* list);
long int lookup(long int val, long int map[NRULES][NFIELDS], int dir);
int isseed(long int s, long int seeds[MAXSEEDS]);
long int part1(long int seeds[MAXSEEDS], long int maps[NMAPS][NRULES][NFIELDS]);
long int part2(long int seeds[MAXSEEDS], long int maps[NMAPS][NRULES][NFIELDS]);

int main()
{
    long int seeds[MAXSEEDS];
    memset(seeds, 0xFF, sizeof seeds); // Set all to EMPTY.
    long int maps[NMAPS][NRULES][NFIELDS];
    memset(maps, 0xFF, sizeof maps); // Set all to EMPTY.
    readproblemfile(seeds, maps);
    printf("Part 1: %li\nPart 2: %li\n", part1(seeds, maps), part2(seeds, maps));
}

// For part 1, just check the location of each seed.
long int part1(long int seeds[MAXSEEDS], long int maps[NMAPS][NRULES][NFIELDS])
{
    long int result = LONG_MAX;
    for (int i=0; i<MAXSEEDS && seeds[i] != EMPTY; ++i) {
        long int loc = seeds[i];
        for (int m = 0; m < NMAPS; ++m)
            loc = lookup(loc, maps[m], FORWARD);
        result = MIN(loc, result);
    }
    return result;
}

// For part 2, it is faster to search backwards (location to
// seed) instead of forwards (seed to location).
// Also, start with a step size about the size of the smallest
// seed range and use a logarithmic search pattern.
long int part2(long int seeds[MAXSEEDS], long int maps[NMAPS][NRULES][NFIELDS])
{
    long int seed, location = 0;
    int stepsign = 1, stepsize = INT_MAX;
    for (int i=1; i<MAXSEEDS && seeds[i] != EMPTY; i+=2)
        stepsize = MIN(stepsize, seeds[i]);
    while (1) {
        location += stepsign * stepsize;
        seed = location;
        for (int m = NMAPS-1; m >= 0; --m)
            seed = lookup(seed, maps[m], BACKWARD);
        if (stepsign != (isseed(seed, seeds) ? -1 : 1)) {
            if (stepsize == 1)
                return stepsign == 1 ? location : location + 1;
            stepsize /= 2;
            stepsign *= -1;
        }
    }
}

// Read the problem data from file.
void readproblemfile(long int seeds[MAXSEEDS], long int maps[NMAPS][NRULES][NFIELDS])
{
    char line[MAXLINE];
    FILE* fptr = fopen("input", "r");
    // First read list of seeds.
    if (fgets(line, sizeof line, fptr) != NULL)
        readlist(line + 7, seeds); // "+7" skips prefix "Seeds: ".
    // Then read all the various maps.
    int i_map = -1, i_rule = 0;
    while (fgets(line, sizeof line, fptr) != NULL) {
        long int dst, src, range;
        if (strstr(line, "map:") != NULL) {
            ++i_map;
            i_rule = 0;
        }
        else if (sscanf(line, "%li %li %li", &dst, &src, &range) == 3) {
            maps[i_map][i_rule][DEST] = dst;
            maps[i_map][i_rule][SRC] = src;
            maps[i_map][i_rule][RANGE] = range;
            ++i_rule;
        }
    }
}

// Convert string to list of numbers.
void readlist(char* str, long int* list)
{
    int i = 0, num_read;
    while (1) {
        if (sscanf(str, "%li %n", &list[i++], &num_read) != 1)
            break;
        str += num_read;
    }
}

// Look up a value in a map. direction dir can be 
// 0 or FORWARD: find destination from source.
// 1 or BACKWARD: find source from destination.
long int lookup(long int val, long int map[NRULES][NFIELDS], int dir)
{
    for (int i = 0; i < NRULES && map[i][0] != EMPTY; ++i) {
        if (val >= map[i][SRC-dir] && val < map[i][SRC-dir] + map[i][RANGE]) {
            val += map[i][dir-DEST] - map[i][SRC-dir];
            break;
        }
    }
    return val;
}

// Return 1 if s is a seed according to rules of part 2.
int isseed(long int s, long int seeds[MAXSEEDS])
{
    for (int i=0; i+1<MAXSEEDS; i+=2)
        if (seeds[i] != EMPTY && s >= seeds[i] && s < seeds[i] + seeds[i+1])
            return 1;
    return 0;
}

import fs from 'fs'

const BOAT_SPEED = 1

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

interface Race {
  time: number
  distanceToBeat: number
}

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

  const allRaces: Race[] = getAllRaces(lines)

  const amountOfPossibleWins: number[] = []
  allRaces.forEach((race) => {
    amountOfPossibleWins.push(findWinCombinations(race))
  })

  console.log(
    'Sum of total win possibilities',
    amountOfPossibleWins.reduce((sum, next) => sum * next)
  )
}

function findWinCombinations (raceToBeat: Race): number {
  const { distanceToBeat, time } = raceToBeat

  let winCount = 0

  for (let i = 1; i < time; i++) {
    const boatCurrentSpeed = i * BOAT_SPEED
    const totalDistanceTraveled = (time - i) * boatCurrentSpeed

    if (totalDistanceTraveled > distanceToBeat) winCount++
  }

  return winCount
}

function getAllRaces (lines: string[]): Race[] {
  const races: Race[] = []

  const numRegeex: RegExp = /\d+/g
  const timesMatches = lines[0].match(numRegeex) // times
  const distanceMatches = lines[1].match(numRegeex) // distance

  if (timesMatches !== null && distanceMatches !== null) {
    for (let i = 0; i < timesMatches.length; i++) {
      races.push({
        time: parseInt(timesMatches[i]),
        distanceToBeat: parseInt(distanceMatches[i])
      })
    }
  }

  return races
}

import fs from 'fs'

const BOAT_SPEED = 1

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

interface Race {
  time: number
  distanceToBeat: number
}

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

  const allRaces: Race[] = getAllRaces(lines)

  const amountOfPossibleWins: number[] = []
  allRaces.forEach((race) => {
    amountOfPossibleWins.push(findWinCombinations(race))
  })

  console.log(
    'Sum of total win possibilities',
    amountOfPossibleWins.reduce((sum, next) => sum * next)
  )
}

function findWinCombinations (raceToBeat: Race): number {
  const { distanceToBeat, time } = raceToBeat

  let winCount = 0

  for (let i = 1; i < time; i++) {
    const boatCurrentSpeed = i * BOAT_SPEED
    const totalDistanceTraveled = (time - i) * boatCurrentSpeed

    if (totalDistanceTraveled > distanceToBeat) winCount++
  }

  return winCount
}

function getAllRaces (lines: string[]): Race[] {
  const races: Race[] = []

  const numRegeex: RegExp = /\d+/g
  const timesMatches = lines[0].match(numRegeex) // times
  const distanceMatches = lines[1].match(numRegeex) // distance

  if (timesMatches !== null && distanceMatches !== null) {
    let raceTime: string = ''
    let distance: string = ''
    for (let i = 0; i < timesMatches.length; i++) {
      raceTime += timesMatches[i]
      distance += distanceMatches[i]
    }
    races.push({
      time: parseInt(raceTime),
      distanceToBeat: parseInt(distance)
    })
  }

  return races
}

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

#define MAXLINE 128
#define MAXRACES 4

// Data structure to hold problem details.
typedef struct Race {
    long int time;
    long int distance;
} Race;

// Function declarations.
int part1(Race*);
int part2(Race*);
int ways_to_win(Race r);
Race* parseInput();
void readlist(char* str, int* list);
long int concat(long int a, long int b);

int main()
{
    Race* races = parseInput();
    printf("Part 1: %i\nPart 2: %i\n", part1(races), part2(races));
    free(races);
}

int part1(Race* races)
{
    int result = 1;
    for (int i = 0; i < MAXRACES && races[i].time > 0; ++i)
        result *= ways_to_win(races[i]);
    return result;
}

int part2(Race* races)
{
    Race r = { .time = 0, .distance = 0 };
    for (int i = 0; i < MAXRACES && races[i].time > 0; ++i) {
        r.time = concat(r.time, races[i].time);
        r.distance = concat(r.distance, races[i].distance);
    }
    return ways_to_win(r);
}

// Return the number of ways to win a race.
// Solved as a quadratic equation.
int ways_to_win(Race r)
{
    double t = r.time;
    double d = r.distance;
    double tmp = sqrt(t*t/4 - d);
    return ceil(t/2+tmp) - floor(t/2-tmp) - 1;
}

// Read problem from input file.
Race* parseInput()
{
    Race* races = calloc(MAXRACES, sizeof (Race));
    char line[MAXLINE];
    FILE* fptr = fopen("input", "r");
    if (fgets(line, sizeof line, fptr) != NULL) {
        int* tmp = calloc(MAXRACES, sizeof (int));
        readlist(line + 10, tmp);
        for (int i = 0; i < MAXRACES; ++i)
            races[i].time = tmp[i];
    }
    if (fgets(line, sizeof line, fptr) != NULL) {
        int* tmp = calloc(MAXRACES, sizeof (int));
        readlist(line + 10, tmp);
        for (int i = 0; i < MAXRACES; ++i)
            races[i].distance = tmp[i];
    }
    return races;
}

// Read list of numbers from string: "1 2 3" -> {1, 2, 3}
void readlist(char* str, int* list)
{
    int i = 0, num_read;
    while (1) {
        if (sscanf(str, "%i %n", &list[i++], &num_read) != 1)
            break;
        str += num_read;
    }
}

// Concatenate two numbers, so that concat(12, 34) == 1234.
long int concat(long int a, long int b)
{
    return a * pow(10, ceil( log10( b ))) + b;
}

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

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

type Card = string
const CardStrength = {
  '1': 1,
  '2': 2,
  '3': 3,
  '4': 4,
  '5': 5,
  '6': 6,
  '7': 7,
  '8': 8,
  '9': 9,
  'T': 10,
  'J': 11,
  'Q': 12,
  'K': 13,
  'A': 14
}

const handType = [
  'FIVE_OF_KIND',
  'FOUR_OF_KIND',
  'FULL_HOUSE',
  'THREE_OF_KIND',
  'TWO_PAIR',
  'ONE_PAIR',
  'HIGH_CARD'
] as const
type HandType = typeof handType[number]

interface Hand {
  cards: Card[]
  bid: number
  type?: HandType
  rank?: number
}

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

  let hands: Hand[] = buildHandsArray(lines)

  hands = determineHandsRank(hands)

  let total = 0
  hands.forEach((hand) => {
    total += hand.bid * (hand.rank ?? 0)
  })
  console.log('Total winnings: ', total)
}

function buildHandsArray (lines: string[]): Hand[] {
  const returnHands: Hand[] = []
  const numRegex: RegExp = /\d+/g

  lines.forEach((line) => {
    const hand = line.substring(0, 5)
    const bid = line.substring(5).match(numRegex)
    const cards: Card[] = []

    for (const card of hand) {
      cards.push(card)
    }

    if (bid !== null) {
      const hand: Hand = { cards, bid: parseInt(bid[0]) }
      returnHands.push({ ...hand, type: getHandType(hand) })
    }
  })

  return returnHands
}

function getHandType (hand: Hand): HandType {
  const groupedCards = groupBy(hand.cards, (card) => card)

  const amountOfSimilarCards: number[] = []

  groupedCards.forEach((group) => {
    amountOfSimilarCards.push(group.length)
  })

  if (amountOfSimilarCards.includes(5)) { return 'FIVE_OF_KIND' }
  if (amountOfSimilarCards.includes(4)) { return 'FOUR_OF_KIND' }
  if (amountOfSimilarCards.includes(3) && amountOfSimilarCards.includes(2)) { return 'FULL_HOUSE' }
  if (amountOfSimilarCards.includes(3)) { return 'THREE_OF_KIND' }
  if (amountOfSimilarCards.filter((el) => el === 2).length === 2) { return 'TWO_PAIR' }
  if (amountOfSimilarCards.includes(2)) { return 'ONE_PAIR' }
  return 'HIGH_CARD'
}

function determineHandsRank (hands: Hand[]): Hand[] {
  const returnHands: Hand[] = []
  const handsGroupedByType = groupBy(hands, (hand) => hand.type)
  let rank = hands.length

  handType.forEach((type) => {
    new Map([...handsGroupedByType].filter(([k, v]) => k === type)).forEach((hands) => {
      const sortedHands = hands.sort(sortCards)

      sortedHands.forEach((hand) => {
        returnHands.push({ ...hand, rank })
        rank--
      })
    })
  })

  return returnHands
}

const sortCards = (cardA, cardB): number => {
  for (let i = 0; i < 5; i++) {
    const valueA = CardStrength[cardA.cards[i]]
    const valueB = CardStrength[cardB.cards[i]]

    if (valueA < valueB) {
      return 1
    } else if (valueA > valueB) {
      return -1
    }
  }

  return 0
}

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

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

type Card = string
const CardStrength = {
  'J': 1,
  '1': 2,
  '2': 3,
  '3': 4,
  '4': 5,
  '5': 6,
  '6': 7,
  '7': 8,
  '8': 9,
  '9': 10,
  'T': 11,
  'Q': 12,
  'K': 13,
  'A': 14
}

const JOKER_CARD = 'J'

const handType = [
  'FIVE_OF_KIND',
  'FOUR_OF_KIND',
  'FULL_HOUSE',
  'THREE_OF_KIND',
  'TWO_PAIR',
  'ONE_PAIR',
  'HIGH_CARD'
] as const
type HandType = typeof handType[number]

interface Hand {
  cards: Card[]
  bid: number
  type?: HandType
  rank?: number
}

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

  const hands: Hand[] = buildHandsArray(lines)

  const totalWinnings: number = hands.reduce<number>((acc, currentHand) => {
    return acc + currentHand.bid * (currentHand.rank ?? 0)
  }, 0)
  console.log(`Total winnings with joker: ${totalWinnings}`)
}

function buildHandsArray (lines: string[]): Hand[] {
  const returnHands: Hand[] = []
  const numRegex: RegExp = /\d+/g

  lines.forEach((line) => {
    const hand = line.substring(0, 5)
    const bid = line.substring(5).match(numRegex)
    const cards: Card[] = []

    for (const card of hand) {
      cards.push(card)
    }

    if (bid !== null) {
      const hand: Hand = { cards, bid: parseInt(bid[0]) }
      returnHands.push({ ...hand, type: getHandType(hand) })
    }
  })

  return determineHandsRank(returnHands)
}

function countRepeatsWithJoker (input: string): Array<Map<string, number>> {
  const possibilities: Array<Map<string, number>> = []

  // Iterate over each character in the input
  for (let i = 0; i < input.length; i++) {
    const char = input[i]

    // Create a map to store counts for this iteration
    const counts = new Map<string, number>()

    // Count occurrences, considering "J" as a wildcard
    for (let j = 0; j < input.length; j++) {
      const currentChar = input[j] === JOKER_CARD ? char : input[j]
      counts.set(currentChar, (counts.get(currentChar) ?? 0) + 1)
    }

    // Add the counts map to the possibilities array
    possibilities.push(counts)
  }

  return possibilities
}

function getHandType (hand: Hand): HandType {
  let handString = ''
  hand.cards.forEach((card) => { handString += card })

  const mappedPossibleSolutions = countRepeatsWithJoker(handString)

  let previousType: HandType = 'HIGH_CARD'

  // Convert each Map entry to an array for easy iteration
  mappedPossibleSolutions.map(map => Array.from(map.values())).every((currentHandPossibility, index) => {
    if (previousType === 'FIVE_OF_KIND') return false

    const currentType: HandType = decideHand(currentHandPossibility)

    if (handType.indexOf(currentType) < handType.indexOf(previousType)) {
      previousType = currentType
    }

    return true
  })

  return previousType
}

function decideHand (arrayOfHighestDuplicates: number[]): HandType {
  if (arrayOfHighestDuplicates.includes(5)) { return 'FIVE_OF_KIND' }
  if (arrayOfHighestDuplicates.includes(4)) { return 'FOUR_OF_KIND' }
  if (arrayOfHighestDuplicates.includes(3) && arrayOfHighestDuplicates.includes(2)) { return 'FULL_HOUSE' }
  if (arrayOfHighestDuplicates.includes(3)) { return 'THREE_OF_KIND' }
  if (arrayOfHighestDuplicates.filter((el) => el === 2).length === 2) { return 'TWO_PAIR' }
  if (arrayOfHighestDuplicates.includes(2)) { return 'ONE_PAIR' }
  return 'HIGH_CARD'
}

function determineHandsRank (hands: Hand[]): Hand[] {
  const returnHands: Hand[] = []
  const handsGroupedByType = groupBy(hands, (hand) => hand.type)
  let rank = hands.length

  handType.forEach((type) => {
    new Map([...handsGroupedByType].filter(([k, v]) => k === type)).forEach((hands) => {
      const sortedHands = hands.sort(sortCards)

      sortedHands.forEach((hand) => {
        returnHands.push({ ...hand, rank })
        rank--
      })
    })
  })

  return returnHands
}

const sortCards = (cardA, cardB): number => {
  for (let i = 0; i < 5; i++) {
    const valueA = CardStrength[cardA.cards[i]]
    const valueB = CardStrength[cardB.cards[i]]

    if (valueA < valueB) {
      return 1
    } else if (valueA > valueB) {
      return -1
    }
  }

  return 0
}