🌟 Advent of Code (AoC) 2023 🌟

lines = open('data/day1.txt', 'r').readlines()

digitMap = {"one": 1, "two": 2, "three": 3, "four": 4, "five": 5, "six": 6, "seven": 7, "eight": 8, "nine": 9}

sum = 0
for line in lines:
    digits = list(filter(str.isdigit, line))
    sum += int(digits[0] + digits[-1])

print(f"Part 1: {sum}")

sum = 0
for line in lines:
    digits = []
    pos = 0

    while (partialLine := line[pos:]):
        if partialLine[0].isdigit():
            digits.append(partialLine[0])
        else:
            for k,v in digitMap.items():
                if partialLine.startswith(k):
                    digits += str(v)
#                    pos += len(k) - 1
                    break
        pos += 1

    sum += int(digits[0] + digits[-1])

print(f"Part 2: {sum}")

print([sum([(lambda line, numbers: 
             (min([(i, d) for n,d in numbers if (i := line.find(n)) != -1])[1] * 10 + 
              max([(line.rfind(n), d) for n,d in numbers])[1]))
            (line, [("1", 1),("2", 2),("3", 3),("4", 4),("5", 5),
                    ("6", 6),("7", 7),("8", 8),("9", 9)] + n) 
            for line in open("input01.txt").readlines()]) 
      for n in [[],[("one", 1),("two", 2),("three", 3),("four", 4),("five", 5),
                    ("six", 6),("seven", 7),("eight", 8),("nine", 9)]]])

import re

values = []
total = 0

with open('input.txt', 'r') as file: 
    for row in file:
        values.append(re.sub('\D', '',row))
        total = total + int(values[-1][0])*10 + int(values[-1][-1])

print (total)

import re

values = []
total = 0
new_values = []
 
with open('input.txt', 'r') as file:
    for row in file:
        values.append(row.replace('one','on1e').replace('two','tw2o').replace('three','th3ree')
                         .replace('four','fo4ur').replace('five','fi5ve').replace('six','si6x').replace('seven','sev7en')
                         .replace('eight','eig8ht').replace('nine','ni9ne'))
        new_values.append(re.sub('\D', '', values[-1]))
        total = total + int(new_values[-1][0])*10 + int(new_values[-1][-1])
        
print (total)

param(
    $inputfile
)
if( -not $inputfile ){ $inputdata = Get-Content -Path "$PSScriptRoot\input.txt" }
else { $inputdata = Get-Content -Path $inputfile }

function Get-Numbers {
    param(
        [array]$inputdata
    )
    $returnArray = @()
    $inputdata | ForEach-Object {
        $returnArray += [pscustomobject]@{
            original = $psitem
            numbersOnly = $( -join( (($PSItem -replace "[^0-9]" , '').ToCharArray() | Select-Object -First 1), (($PSItem -replace "[^0-9]" , '').ToCharArray() | Select-Object -Last 1) ) )
        }
    }
    return $returnArray
}

$part2 = $inputdata -replace "one","o1e"
$part2 = $part2 -replace "two","t2o"
$part2 = $part2 -replace "three","t3e"
$part2 = $part2 -replace "four","f4r"
$part2 = $part2 -replace "five","f5e"
$part2 = $part2 -replace "six","s6x"
$part2 = $part2 -replace "seven","s7n"
$part2 = $part2 -replace "eight","e8t"
$part2 = $part2 -replace "nine","n9e"

Write-Host "Part 1: $( ((Get-Numbers -inputdata $inputdata).numbersOnly | measure-object -sum).sum)"
Write-Host "Part 2: $( ((Get-Numbers -inputdata $part2).numbersOnly | measure-object -sum).sum)"

/*
  Advent of Code 2023 - Day 1 | By WebbKodsLärlingen 2023-12-01 kl.22:06
  Part 1
*/
// All Input from Day 1 | https://adventofcode.com/2023/day/1/input
// All lines there, so not included fully!
// Just make sure it starts with `9dlvndqbddghpxc
// and last line ends with zvhzgfpkhkone93nine`;
const day1Input = `9dlvndqbddghpxc...
zvhzgfpkhkone93nine`;

// Convert multiline to array by array split
const day1InputArr = day1Input.split("\n");

// Store all correctly pushed numbers here!
let summarizedCollection = [];

// Loop through each Line | FOR PART 1
day1InputArr.forEach((line) => {
  // Extract all digits separated into an array with Regex
  let extractDigits = line.match(/(\d)/g); // Only one digit per array element!

  console.log("Digits: ", extractDigits); // Remove if you do not wanna see what is happening
  // Insert first and last integer (converted from string)
  if (extractDigits.length > 1) {
    summarizedCollection.push(
      parseInt(
        extractDigits[0].toString() +
          extractDigits[extractDigits.length - 1].toString()
      )
    );
  }
  // Insert duplication of the single integer (converted from string) otherwise
  else {
    summarizedCollection.push(
      parseInt(extractDigits[0].toString() + extractDigits[0].toString())
    );
  }
});

// Use Array Reduce Method to summarize all elements now!
const summarizedCollectionSum = summarizedCollection.reduce((a, b) => a + b, 0);
console.log(summarizedCollectionSum); // Final answer! o7 (PART 1 ONLY!)

const sumPart1 = summarizedCollectionSum;
console.log("Day 1, Part 1: ", summarizedCollectionSum);

// PART 2 ONLY!!! (Part 1 ended at line="console.log("Day 1, Part 1: ", summarizedCollectionSum);"
summarizedCollection = []; // Empty summarized collection of array elements again!

const spelledoutNumbers = [
  "one",
  "two",
  "three",
  "four",
  "five",
  "six",
  "seven",
  "eight",
  "nine",
];

// Loop through each Line | FOR PART 2
day1InputArr.forEach((line) => {
  // Extract all digits separated into an array with Regex
  // By first replacing all stringers with their respective numberts from that array
  console.log("Line first: ", line);
  line = line.replaceAll(
    /one|two|three|four|five|six|seven|eight|nine/g,
    function (x) {
      return spelledoutNumbers.indexOf(x) !== -1
        ? spelledoutNumbers.indexOf(x) + 1
        : x; // When a match from | is found, return its index + 1 (since array starts at 0 but value at one=1)
    }
  );
  console.log("Line after: ", line);
  // And then extracting the digits as usual!
  let extractDigits = line.match(/(\d)/g); // Only one digit per array element!
  console.log("Digits: ", extractDigits);
  // Insert first and last integer (converted from string)
  if (extractDigits.length > 1) {
    summarizedCollection.push(
      parseInt(
        extractDigits[0].toString() +
          extractDigits[extractDigits.length - 1].toString()
      )
    );
  }
  // Insert duplication of the single integer (converted from string) otherwise
  else {
    summarizedCollection.push(
      parseInt(extractDigits[0].toString() + extractDigits[0].toString())
    );
  }
});

summarizedCollectionSum = summarizedCollection.reduce((a, b) => a + b, 0);
console.log("Day 1, Part 1: ", sumPart1);
console.log("Day 1, Part 2: ", summarizedCollectionSum);

#!/bin/bash
sed 's/twone/t21e/g ; s/oneight/o18t/g ; s/eightwo/e82o/g ; s/eighthree/e83e/g ; s/fiveight/f58t/g ; s/sevenine/s79e/g ; s/nineight/n98t/g ; s/one/1/g ; s/two/2/g ; s/three/3/g ; s/four/4/g ; s/five/5/g; s/six/6/g; s/seven/7/g ; s/eight/8/g; s/nine/9/g ; s/[^0-9]*//g' $1 > /tmp/foo
while read -r line; do
  sum=$((`echo ${line:0:1}${line: -1}` + sum))
done < /tmp/foo
echo $sum
rm /tmp/foo

fid=fopen('day1.txt');
sum1 = 0;
sum2 = 0;
while ~feof(fid)
    line = fgetl(fid);
    %% Task 1
    numbers = cell2mat(extract(line,digitsPattern(1)));
    sum1 = sum1 + str2num([numbers(1)  numbers(end)]);

    %% Task2
    numberNames = ["one", "two", "three", "four", "five", "six", ...
        "seven", "eight", "nine"];
    digitTable = []; % Table of digits and their position in the string

    % Add spelled numbers to table
    for name = numberNames
        if contains(line, name) 
            digitTable = [digitTable [strfind(line, name); ...
                ones(1, length(strfind(line, name))) * ...
                find(matches(numberNames, name))]];              
        end
    end

    % Add digits to table
    for index = strfind(line, digitsPattern(1))
        digitTable = [digitTable [index; str2num(line(index))]];
    end

    % Sort the table according to position in string
    [~, I] = sort(digitTable(1, :));
    digitTable=digitTable(:, I);
    sum2 = sum2 + digitTable(2, 1) * 10 + digitTable(2, end);
end
fclose(fid);
disp(['Task 1: ' num2str(sum1)])
disp(['Task 2: ' num2str(sum2)])

open System
open System.Text.RegularExpressions

type Reveals = { Blue: int; Green: int; Red: int; }
type Game = { Id : int; Reveals : Reveals list }

let parseLine (input:string) =
    let parts = input.Split(":")
    let id = Int32.Parse(parts[0].Split(" ")[1])
    let parseReveal (round:string) =
        let rx = Regex("([0-9]+) (blue|red|green)")
        let matches = rx.Matches(round)
        let getColorCount color =  matches |> Seq.toList |> List.tryFind (fun c -> c.Groups[2].Value = color) |> Option.map (fun c -> Int32.Parse(c.Groups[1].Value)) |> Option.defaultValue 0
        let reds = getColorCount "red"
        let greens = getColorCount "green"
        let blues = getColorCount "blue"
        {Blue = blues; Red = reds; Green = greens }
    let reveals = parts[1].Split(";") |> List.ofSeq |> List.map parseReveal
    { Id = id; Reveals = reveals }
    
let filterGame (game:Game) = game.Reveals |> List.exists (fun c -> c.Red > 12 || c.Green > 13 || c.Blue > 14)
    
let cubeSize (game:Game) =
    let maxReds = game.Reveals |> List.map (fun c -> c.Red) |> List.max
    let maxBlues = game.Reveals |> List.map (fun c -> c.Blue)  |> List.max
    let maxGreens = game.Reveals |> List.map (fun c -> c.Green) |> List.max
    maxReds*maxBlues*maxGreens
    
let input = System.IO.File.ReadAllLines "input.txt" |> List.ofSeq
let games = input |> List.map parseLine
let task1 = List.filter (fun c -> not (filterGame c))
let task2 = List.map cubeSize


printfn $"Task 1: %A{task1 games |> List.sumBy (fun c -> c.Id)}"
printfn $"Task 2: %A{task2 games |> List.sum}"

const numbersMap = new Map<string, number>([
    ['one', 1],
    ['two', 2],
    ['three', 3],
    ['four', 4],
    ['five', 5],
    ['six', 6],
    ['even', 7],
    ['eight', 8],
    ['nine', 9]
])

const parseLintPart2 = (line: string) => {
    for (const number of numbersMap.keys()) {
        if(line.includes(number)) {
            line = line.replace(number, `${number}${numbersMap.get(number)!.toString()}${number}`)
        }
    }

    return line
}

const solver = (input: string[], part: number) =>
    input.reduce((acc, line) => {
        const newLines = part === 1 ? line : parseLintPart2(line)

        const numbers: number[] = []
            for(const char of newLines) {
                if(Number(char)) numbers.push(parseInt(char))
            }

        if(numbers.length >= 1) {
            acc += (numbers[0] * 10) + numbers[numbers.length - 1]
        }
        return acc
    }, 0)

import { parseInput } from "../parseInput"

const blueRegex = /(\d+)\sblue/g;
const redRegex = /(\d+)\sred/g;
const greenRegex = /(\d+)\sgreen/g;

const getMaxColor = (line: string, colorRegex: RegExp) => {
    const matches = [...line.matchAll(colorRegex)];
    return matches.length > 0 ? Math.max(...matches.map(match => parseInt(match[1]))) : 0;
}

const getMaxColors = (line: string) => {
    return {
        maxBlue: getMaxColor(line, blueRegex),
        maxRed: getMaxColor(line, redRegex),
        maxGreen: getMaxColor(line, greenRegex)
    };
}

const part1 = (input: string[]) =>  input.reduce((acc, line, index) => {
        const {maxBlue, maxRed, maxGreen } = getMaxColors(line)

        if(maxBlue <= 14 && maxRed <= 12 && maxGreen <= 13) {
            acc += index + 1
        }
        return acc
    }, 0)


const part2 = (input: string[]) => input.reduce((acc, line, index) => {
    const {maxBlue, maxRed, maxGreen } = getMaxColors(line)
    const product = maxBlue * maxRed * maxGreen

    return acc + product
  }, 0)


const parsedInput = parseInput('part1')
console.log(part1(parsedInput))
console.log(part2(parsedInput))

package main

import (
	"fmt"
	"os"
	"strconv"
	"strings"
)

type Cubes struct {
	Red   int
	Green int
	Blue  int
}

func (cubes *Cubes) StoreMaxCount(color string, count int) {
	colorCount := map[string]*int{
		"red":   &cubes.Red,
		"green": &cubes.Green,
		"blue":  &cubes.Blue,
	}[color]
	if *colorCount < count {
		*colorCount = count
	}
}

func (cubes *Cubes) IsPossible(limit Cubes) bool {
	return cubes.Red <= limit.Red && cubes.Green <= limit.Green && cubes.Blue <= limit.Blue
}

func (cubes *Cubes) Power() int {
	return cubes.Red * cubes.Green * cubes.Blue
}

func SumPossible(cubesForGames []Cubes) int {
	sum := 0
	limit := Cubes{Red: 12, Green: 13, Blue: 14}
	for i, cubes := range cubesForGames {
		if cubes.IsPossible(limit) {
			sum += i + 1
		}
	}
	return sum
}

func SumPower(cubesForGames []Cubes) int {
	sum := 0
	for _, cubes := range cubesForGames {
		sum += cubes.Power()
	}
	return sum
}

func ParseReveal(reveal string) (string, int) {
	colorCount := strings.Split(reveal, " ")
	count, _ := strconv.Atoi(colorCount[0])
	return colorCount[1], count
}

func ParseCubes(input []string) []Cubes {
	cubesForGames := []Cubes{}
	for _, line := range input {
		reveals := strings.Split(strings.ReplaceAll(strings.ReplaceAll(line[strings.Index(line, ": ")+2:], ";", ","), ", ", ","), ",")
		cubes := Cubes{}
		for _, reveal := range reveals {
			cubes.StoreMaxCount(ParseReveal(reveal))
		}
		cubesForGames = append(cubesForGames, cubes)
	}
	return cubesForGames
}

func main() {
	input, _ := os.ReadFile("day2.txt")
	cubes := ParseCubes(strings.Split(string(input), "\n"))
	fmt.Println(SumPossible(cubes))
	fmt.Println(SumPower(cubes))
}

import re
from functools import reduce

print(
(lambda f1, f2, l: (f1(l), f2(l)))
(lambda l: sum([t[0] for t in l if t[1] <= 12 and t[2] <= 13 and t[3] <= 14]),
 lambda l: sum(t[1] * t[2] * t[3] for t in l),
 [reduce(lambda a,b : tuple(map(max, zip(*map(lambda v: map(lambda s: int('0' + str(s)), v), [a, b])))), m)
  for m in [[matches for matches in re.findall(r"Game (\d+)|(\d+) red|(\d+) green|(\d+) blue", line)]
            for line in open("input02.txt").readlines()]])
)

print(
# 13. Apply part 1 and part 2 on the list
(lambda f1, f2, l: (f1(l), f2(l)))
# 12. Part 1 Accumulate game (t[0]) if the element was possible
(lambda l: sum([t[0] for t in l if t[1] <= 12 and t[2] <= 13 and t[3] <= 14]),
 # 13. Sum the power for each element in the list
 lambda l: sum(t[1] * t[2] * t[3] for t in l),
 # 4. Reduce "accumulates" a list by applying a function to the accumulator 
 #    and each element in the list. Here we want to collect the max of each
 #    match in list to get the highest values. To compute the max of two 
 #    matches (a and b) we want to apply max to each pair of elements in a 
 #    and b. Max does work for strings, but unfortunately "5" is greater 
 #    than "15" so we have to convert the values to integers first. It gets
 #    a bit messy.
 #
 # 11. Apply 10 to each element in the list to compute the max values for
 #     game, red, green, and blue. The result is a list with all the max
 #     values per line.
 #                          # 10. Apply max to each pair in (a[0], b[0]), 
 #                                (a[1], b[1]),...
 [reduce(lambda a,b : tuple(map(max,
                                # 9 Zip a and b together, now we get 
                                #   (a[0], b[0]), (a[1], b[1]),...
                                zip(
                                    # 8. The * operator converts the list 
                                    #    in zip([A, B]) to zip(A, B)
                                     # 7. Map the match conversion function 
                                     #    (6) to both a and b
                                         # 6: Map the conversion function 
                                         #    (5) to each game, red, green,
                                         #    blue component in a match. Now 
                                         #    the red 6 match is on the 
                                         #    form [0, 6, 0, 0]
                                    *map(lambda v: 
                                         # 5. Convert a value to an int. The 
                                         #    "0" part ensures '' gets the 
                                         #    value 0 and str(s) converts the 
                                         #    integer value in the accumulator 
                                         #    to a string so it can be 
                                         #    concateted with the '0'. Convert 
                                         #    the string to an int.
                                         map(lambda s: int('0' + str(s)), v), 
                                         [a, b])))), 
        m)
  #   3. Collect all the matches per line in m
  #          2: Per number in the input line the regex produces a match on the
  #             form (game, red, gren, blue). All the non-matched entries are
  #             empty strings so 'red 6' would generate ('', '6', '', '').
  for m in [re.findall(r"Game (\d+)|(\d+) red|(\d+) green|(\d+) blue", line)
            # 1: Read all lines in the imput file
            for line in open("input02.txt").readlines()]])
)

import re
import math
from collections import defaultdict

lines = open('data/day2.txt', 'r').read().splitlines()

GAME_REGEX = re.compile('[:;] ')
COLOR_REGEX = re.compile('(\d+) (red|green|blue)')

MAX_ALLOWED = {'red': 12, 'green': 13, 'blue': 14}

game_id_sum = 0
power_sum = 0

for game in lines:
    id, *picks = GAME_REGEX.split(game)
    id = int(id[5:])
    game_possible = True
    min_required = defaultdict(int)

    for pick in picks:
        color_map = defaultdict(int)

        # Split picks into a list e.g. [(3, 'red'), (2, 'green')],
        # and transform into a dict e.g. {'red': 3, 'green': 2}
        for color_matches in COLOR_REGEX.findall(pick):
            v, k = color_matches
            color_map[k] = int(v)

        # Part 1
        if any(color_map[color] > MAX_ALLOWED[color] for color in ('red', 'green', 'blue')):
            game_possible = False

        # Part 2
        min_required = {color: max(min_required[color], color_map[color]) for color in ('red', 'green', 'blue')}
    
    # Part 1
    if game_possible:
        game_id_sum += id

    # Part 2
    power = math.prod(min_required.values())
    power_sum += power

print(f'Part 1: {game_id_sum}')
print(f'Part 2: {power_sum}')