🌟 Advent of Code (AoC) 2024 🌟

package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"sort"
	"strconv"
	"strings"
)

func readListsFromFile(filename string) ([]int, []int, error) {
	file, err := os.Open(filename)

	if err != nil {
		return nil, nil, fmt.Errorf("failed to open file: %w", err)
	}

	defer file.Close()

	scanner := bufio.NewScanner(file)

	leftValues := []int{}
	rightValues := []int{}

	for scanner.Scan() {
		columns := strings.Fields(scanner.Text())

		if len(columns) != 2 {
			return nil, nil, fmt.Errorf("wrong number of columns in line: %s", scanner.Text())
		}

		leftInt, err := strconv.Atoi(columns[0])
		if err != nil {
			return nil, nil, fmt.Errorf("not an integer: %s", columns[0])
		}

		rightInt, err := strconv.Atoi(columns[1])
		if err != nil {
			return nil, nil, fmt.Errorf("not an integer: %s", columns[1])
		}

		leftValues = append(leftValues, leftInt)
		rightValues = append(rightValues, rightInt)
	}

	if err := scanner.Err(); err != nil {
		return nil, nil, fmt.Errorf("error reading file: %w", err)
	}

	return leftValues, rightValues, nil
}

func calculateDistance(leftList []int, rightList []int) int {
	leftCopy := make([]int, len(leftList))
	rightCopy := make([]int, len(rightList))
	copy(leftCopy, leftList)
	copy(rightCopy, rightList)

	sort.Ints(leftCopy)
	sort.Ints(rightCopy)
	distance := 0
	for i := 0; i < len(leftCopy); i++ {
		distance += abs(leftCopy[i] - rightCopy[i])
	}

	return distance
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func calculateSimilarity(leftList []int, rightList []int) int {
	counts := map[int]int{}

	for _, v := range rightList {
		counts[v] += 1
	}

	total := 0
	for _, v := range leftList {
		total += v * counts[v]
	}

	return total
}

func main() {
	leftList, rightList, err := readListsFromFile("input.txt")

	if err != nil {
		log.Fatalf("Error: %s", err)
	}

	distance := calculateDistance(leftList, rightList)
	fmt.Printf("Part 1: %d\n", distance)

	similarity := calculateSimilarity(leftList, rightList)
	fmt.Printf("Part 2: %d\n", similarity)
}

from itertools import combinations

def decreasing_safely(l):
    return all(l[i] > l[i+1] > l[i] - 4 for i in range(len(l) - 1))

def increasing_safely(l):
    return all(l[i] < l[i+1] < l[i] + 4 for i in range(len(l) - 1))

def remove_one_level(l, f):
    return any(f(c) for c in combinations(l, len(l) - 1))

reports = [[int(r) for r in l.split()] for l in open("input02.txt", "r").readlines()]
print(sum([increasing_safely(r) or decreasing_safely(r) for r in reports]),
      sum([remove_one_level(r, increasing_safely) or remove_one_level(r, decreasing_safely) for r in reports]))

public class Puzzle_2024_2 : Puzzle
{
    public override object PartOne(string data)
    {
        var parsed = data
            .Split(Environment.NewLine)
            .Select(line => line.Split(" ", StringSplitOptions.RemoveEmptyEntries))
            .Select(l => l.Select(int.Parse).ToList())
            .ToList();

        return parsed.Count(record => AllAscending(record) || AllDescending(record));
    }

    public override object PartTwo(string data)
    {
        var parsed = data
            .Split(Environment.NewLine)
            .Select(line => line.Split(" ", StringSplitOptions.RemoveEmptyEntries))
            .Select(l => l.Select(int.Parse).ToList())
            .ToList();
        return parsed.Count(record => AllAscendingDampener(record) || AllDescendingDamper(record));
    }

    private static bool AllAscending(List<int> record)
    {
        return record.Zip(record.Skip(1), (l, r) => l != r && Math.Abs(l - r) <= 3 && l < r).All(b => b);
    }

    private static bool AllAscendingDampener(List<int> record)
    {
        return AllDescending(record) ||
               record.Select((t, i) => record.Where((_, j) => j != i).ToList()).Any(AllAscending);
    }

    private static bool AllDescending(List<int> record)
    {
        return record.Zip(record.Skip(1), (l, r) => l != r && Math.Abs(l - r) <= 3 && l > r).All(b => b);
    }

    private static bool AllDescendingDamper(List<int> record)
    {
        return AllDescending(record) ||
               record.Select((t, i) => record.Where((_, j) => j != i).ToList()).Any(AllDescending);
    }
}

open System

let input =
    System.IO.File.ReadAllLines "input.txt"
    |> Array.map (_.Split(" ", StringSplitOptions.RemoveEmptyEntries)
        >> Array.map int
        >> List.ofArray)
        |> List.ofArray

let isLevelSafe =
    List.pairwise
    >> (fun lst ->
        ((List.forall (fun (a, b) -> a > b) lst || List.forall (fun (a, b) -> a < b) lst))
        && List.forall (fun (a, b) -> abs (a - b) >= 1 && abs (a - b) <= 3) lst)

let filterAndCount predicate = List.filter predicate >> List.length

let part1 = filterAndCount isLevelSafe

let part2 =
    filterAndCount (fun list ->
        List.mapi (fun i _ -> List.take i list @ List.skip (i + 1) list) list
        |> List.exists isLevelSafe)
    
printfn $"Safe levels part 1: %i{input |> part1} part 2: %i{input |> part2}"

var lines = File.ReadAllLines("input.txt").Select(x => x.Split(" ").Select(int.Parse)).ToList();
int sumpart1 = 0;
int sumpart2 = 0;

foreach (var line in lines)
{
    if (is_safe(line))
    {
        sumpart1++;
        sumpart2++;
        continue;
    }
    for (int i = 0; i < line.Count(); i++)
    {
        var list = line.ToList();
        list.RemoveAt(i);
        if (is_safe(list))
        {
            sumpart2++;
            break;
        }
    }

}
Console.WriteLine("Part 1: " + sumpart1);
Console.WriteLine("Part 2: " + sumpart2);

static bool is_safe(IEnumerable<int> line)
{
    var tuples = line.Zip(line.Skip(1), (a, b) => Tuple.Create(a, b));
    return tuples.All(pair => Math.Abs(pair.Item1 - pair.Item2) <= 3)
        && (tuples.All(pair => pair.Item1 < pair.Item2)
        || tuples.All(pair => pair.Item1 > pair.Item2)
        );
}

<?php
$data = "16 19 21 24 21
15 18 19 22 24 25 25
and_so_on_..."; // Source: https://adventofcode.com/2024/day/2/input

// First we grab all data by splitting the data string by new lines
$lines = explode("\n", $data);

// Each line has a list of number separated by spaces. We will store how many of these
// lines are considered "safe" by checking each numbers in each line and see if every
// adjacent number are differient by at least 1 or at most 3. Any other difference
// makes the entire line of numbers "unsafe". If it is "safe" we will increase "safeReports"
// by 1. A crucial detail to consider is that the numbers could be increasing or decreasing
// but each line is ONLY consireded safe is the numbers are only increasing or only decreasing
// by at least 1 or at most 3. Otherwise it is considered unsafe and not added to "safeReports".
$safeReports = 0;

foreach ($lines as $line) {
    $numbers = explode(" ", $line);
    $safe = true;
    $length = count($numbers) - 1; // Plåga inte looparna!

    // First loop will just check if there is a valid absolute difference (at least 1 or at most 3)
    // between each two adjacent numbers. If there is not, the line is considered unsafe and we break.
    for ($i = 0; $i < $length; $i++) {

        // First get absolute difference
        $diff = abs($numbers[$i] - $numbers[$i + 1]);

        if ($diff < 1 || $diff > 3) {
            $safe = false;
            break;
        }
    }

    // No need to continue current $line if the line is already considered unsafe
    if (!$safe) {
        continue;
    }

    // Second loop will check if all numbers are either increasing or either decreasing. If they
    // shift at any point between increasing and decreasing, the line is considered unsafe and we break.
    // What we'll do is first check two first numbers before the loop to know whether it should always
    // increase or always decrease. Then we loop through to make sure it is always increasing or decreasing.
    // Before we loop we first check if two first numbers are equal because that is a special case
    // that is not allowed since all numbers should be all increasing or all decreasing!
    if ($numbers[0] === $numbers[1]) {
        $safe = false;
    }

    // Now we check if the numbers are increasing or decreasing but only if the line is still considered safe.
    if ($safe) {
        $increasing = $numbers[0] < $numbers[1];
        for ($i = 0; $i < $length; $i++) {
            if ($increasing && $numbers[$i] > $numbers[$i + 1]) {
                $safe = false;
                break;
            } else if (!$increasing && $numbers[$i] < $numbers[$i + 1]) {
                $safe = false;
                break;
            }
        }
    }

    // Finally we will only add to "safeReports" if the line is considered safe.
    if ($safe) {
        $safeReports++;
    }
}

echo "Safe reports: $safeReports\n";
?>

$data = "16 19 21 24 21
15 18 19 22 24 25 25
and_so_on_..."; // Source: https://adventofcode.com/2024/day/2/input

// First we grab all data by splitting the data string by new lines
$lines = explode("\n", $data);

// Each line has a list of number separated by spaces. We will store how many of these
// lines are considered "safe" by checking each numbers in each line and see if every
// adjacent number are differient by at least 1 or at most 3. Any other difference
// makes the entire line of numbers "unsafe". If it is "safe" we will increase "safeReports"
// by 1. A crucial detail to consider is that the numbers could be increasing or decreasing
// but each line is ONLY consireded safe is the numbers are only increasing or only decreasing
// by at least 1 or at most 3. Otherwise it is considered unsafe and not added to "safeReports".
$safeReports = 0;

foreach ($lines as $line) {
    $numbers = explode(" ", $line);
    $safe = true;
    $length = count($numbers) - 1; // Plåga inte looparna!

    // First loop will just check if there is a valid absolute difference (at least 1 or at most 3)
    // between each two adjacent numbers. If there is not, the line is considered unsafe and we break.
    if (!allNumbersValidAbsoluteDifferences($numbers)) {
        $safe = false;
    }

    // No need to continue current $line if the line is already considered unsafe
    if (!$safe) {
        continue;
    }

    // Second loop will check if all numbers are either increasing or either decreasing. If they
    // shift at any point between increasing and decreasing, the line is considered unsafe and we break.
    // What we'll do is first check two first numbers before the loop to know whether it should always
    // increase or always decrease. Then we loop through to make sure it is always increasing or decreasing.
    // Before we loop we first check if two first numbers are equal because that is a special case
    // that is not allowed since all numbers should be all increasing or all decreasing!
    if (!allNumbersOnlyIncreaseOrOnlyDecrease($numbers)) {
        $safe = false;
    }

    // Finally we will only add to "safeReports" if the line is considered safe.
    if ($safe) {
        $safeReports++;
    }
}

echo "Safe reports first time: $safeReports\n";

// Part 2 - reset safeReports
$safeReports = 0;
$unsureReports = []; // We will store the lines that are unsure if they are safe or not

// We now loop through all lines again but this time we will store the lines that are unsure
foreach ($lines as $line) {
    $numbers = explode(" ", $line);
    $safe = true;
    $length = count($numbers) - 1; // Plåga inte looparna!

    // First loop will just check if there is a valid absolute difference (at least 1 or at most 3)
    // between each two adjacent numbers. If there is not, the line is considered unsafe and we break.
    if (!allNumbersValidAbsoluteDifferences($numbers)) {
        $safe = false;
    }

    if (!allNumbersOnlyIncreaseOrOnlyDecrease($numbers)) {
        $safe = false;
    }

    // Finally we will only add to "safeReports" if the line is considered safe.
    if ($safe) {
        $safeReports++;
    } else {
        $unsureReports[] = $line; // we will store the line since we will check it later
    }
}

// Now we will loop through all unsure reports and check if we can make them safe by removing one number
// meaning we will need to bruteforce all possible combinations of removing one number from each line and
// check if the line is safe. If it is, we will increase "safeReports" by 1.
// A function that will return true if all numbers are valid by checking if the absolute difference
// between each two adjacent numbers are at least 1 or at most 3.
function allNumbersValidAbsoluteDifferences($numbers)
{
    $length = count($numbers) - 1;
    for ($i = 0; $i < $length; $i++) {
        $diff = abs($numbers[$i] - $numbers[$i + 1]);
        if ($diff < 1 || $diff > 3) {
            return false;
        }
    }
    return true;
}

// A function that will return true if all numbers are either increasing or decreasing but not both.
function allNumbersOnlyIncreaseOrOnlyDecrease($numbers)
{
    $length = count($numbers) - 1;
    if ($numbers[0] === $numbers[1]) {
        return false;
    }
    $increasing = $numbers[0] < $numbers[1];
    for ($i = 0; $i < $length; $i++) {
        if ($increasing && $numbers[$i] > $numbers[$i + 1]) {
            return false;
        } else if (!$increasing && $numbers[$i] < $numbers[$i + 1]) {
            return false;
        }
    }
    return true;
}

// The foreach that will loop through all unsure reports and check if we can make them safe by removing one number
foreach ($unsureReports as $line) {
    $line = trim($line);
    $numbers = explode(" ", $line);
    $length = count($numbers);
    $safe = false;

    // By using the functions we created above, we can check if the line is safe after removing one number
    // meaning we will have to send all possible combinations of removing one number from the line ($numbers) and check
    // if the line is safe. If it is, we will increase "safeReports" by 1.
    for ($i = 0; $i < $length; $i++) {
        $newNumbers = $numbers;
        unset($newNumbers[$i]);
        $newNumbers = array_values($newNumbers); // Reindex the array

        if (allNumbersValidAbsoluteDifferences($newNumbers) && allNumbersOnlyIncreaseOrOnlyDecrease($newNumbers)) {
            $safe = true;
            break;
        }
    }

    // If safe after all checks in the beginning, we will add to safeReports
    if ($safe) {
        $safeReports++;
    }
}

echo "Safe reports second time: $safeReports\n";

$data = "https://adventofcode.com/2024/day/2/input";

$lines = explode("\n", $data);
$safeReports = 0;

foreach ($lines as $line) {
    $numbers = explode(" ", $line);
    $safe = true;
    $length = count($numbers) - 1;

    if (!allNumbersValidAbsoluteDifferences($numbers)) {
        $safe = false;
    }

    if (!$safe) {
        continue;
    }

    if (!allNumbersOnlyIncreaseOrOnlyDecrease($numbers)) {
        $safe = false;
    }

    if ($safe) {
        $safeReports++;
    }
}

echo "Safe reports first time: $safeReports\n";

$safeReports = 0;
$unsureReports = [];

foreach ($lines as $line) {
    $numbers = explode(" ", $line);
    $safe = true;
    $length = count($numbers) - 1;

    if (!allNumbersValidAbsoluteDifferences($numbers)) {
        $safe = false;
    }

    if (!allNumbersOnlyIncreaseOrOnlyDecrease($numbers)) {
        $safe = false;
    }

    if ($safe) {
        $safeReports++;
    } else {
        $unsureReports[] = $line;
    }
}

function allNumbersValidAbsoluteDifferences($numbers)
{
    $length = count($numbers) - 1;
    for ($i = 0; $i < $length; $i++) {
        $diff = abs($numbers[$i] - $numbers[$i + 1]);
        if ($diff < 1 || $diff > 3) {
            return false;
        }
    }
    return true;
}

function allNumbersOnlyIncreaseOrOnlyDecrease($numbers)
{
    $length = count($numbers) - 1;
    if ($numbers[0] === $numbers[1]) {
        return false;
    }
    $increasing = $numbers[0] < $numbers[1];
    for ($i = 0; $i < $length; $i++) {
        if ($increasing && $numbers[$i] > $numbers[$i + 1]) {
            return false;
        } else if (!$increasing && $numbers[$i] < $numbers[$i + 1]) {
            return false;
        }
    }
    return true;
}

foreach ($unsureReports as $line) {
    $line = trim($line);
    $numbers = explode(" ", $line);
    $length = count($numbers);
    $safe = false;

    for ($i = 0; $i < $length; $i++) {
        $newNumbers = $numbers;
        unset($newNumbers[$i]);
        $newNumbers = array_values($newNumbers);

        if (allNumbersValidAbsoluteDifferences($newNumbers) && allNumbersOnlyIncreaseOrOnlyDecrease($newNumbers)) {
            $safe = true;
            break;
        }
    }

    if ($safe) {
        $safeReports++;
    }
}

echo "Safe reports second time: $safeReports\n";

use itertools::Itertools;
use std::ops::RangeInclusive;
use std::str::FromStr;
use std::{fs, usize};

pub const INPUT_FILE: &str = "input.txt";

pub type Level = i32;
pub struct Report(Vec<Level>);

impl Report {
    fn new(report_str: &str) -> Report {
        let levels = report_str
            .split_ascii_whitespace()
            .map(i32::from_str)
            .map(Result::unwrap)
            .collect();
        Report(levels)
    }

    fn is_valid(&self) -> bool {
        self.is_valid_with_ignored_index(usize::MAX)
    }

    fn is_valid_with_problem_dampener(&self) -> bool {
        for ignored_index in 0..self.0.len() {
            if self.is_valid_with_ignored_index(ignored_index) {
                return true;
            }
        }
        false
    }

    fn is_valid_with_ignored_index(&self, ignored_index: usize) -> bool {
        let valid_range = valid_delta_range(self.0.iter());
        self.0
            .iter()
            .enumerate()
            .filter_map(|(i, level)| {
                if i == ignored_index {
                    None
                } else {
                    Some(level)
                }
            })
            .tuple_windows()
            .all(|(a, b)| valid_range.contains(&(b - a)))
    }
}

fn valid_delta_range<'a, I>(mut levels: I) -> RangeInclusive<Level>
where
    I: Iterator<Item = &'a Level>,
{
    let first = levels.next().unwrap();
    let second = levels.next().unwrap();
    if first < second {
        1..=3
    } else {
        -3..=-1
    }
}

pub fn read_to_reports(path: &str) -> Vec<Report> {
    fs::read_to_string(path)
        .expect(&format!("File {} should be present", path))
        .lines()
        .map(Report::new)
        .collect()
}

pub fn count_valid_reports(reports: &[Report]) -> usize {
    reports.iter().filter(|&report| report.is_valid()).count()
}

pub fn count_valid_reports_with_problem_dampener(reports: &[Report]) -> usize {
    reports
        .iter()
        .filter(|&report| report.is_valid_with_problem_dampener())
        .count()
}

fn main() {
    let reports = read_to_reports(INPUT_FILE);
    println!("part 1: {}", count_valid_reports(&reports));
    println!(
        "part 2: {}",
        count_valid_reports_with_problem_dampener(&reports)
    );
}

package main

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

func readValuesFromFile(filename string) ([][]int, error) {
	file, err := os.Open(filename)

	if err != nil {
		return nil, fmt.Errorf("failed to open file: %w", err)
	}

	defer file.Close()

	scanner := bufio.NewScanner(file)

	values := [][]int{}

	for scanner.Scan() {
		columns := strings.Fields(scanner.Text())

		line := []int{}

		for _, v := range columns {
			intVal, err := strconv.Atoi(v)
			if err != nil {
				return nil, fmt.Errorf("not an integer: %s", v)
			}
			line = append(line, intVal)
		}
		values = append(values, line)
	}

	if err := scanner.Err(); err != nil {
		return nil, fmt.Errorf("error reading file: %w", err)
	}

	return values, nil
}

func isValidReport(report []int) (bool, error) {
	if len(report) < 2 {
		return false, fmt.Errorf("too few levels in report %d", len(report))
	}

	increasing := report[0] < report[1]

	for i := 0; i < len(report)-1; i++ {
		var supposedlyHigher, supposedlyLower int

		if increasing {
			supposedlyHigher = report[i+1]
			supposedlyLower = report[i]
		} else {
			supposedlyHigher = report[i]
			supposedlyLower = report[i+1]
		}

		if supposedlyHigher <= supposedlyLower {
			return false, nil
		}

		if supposedlyHigher-supposedlyLower > 3 {
			return false, nil
		}
	}

	return true, nil
}

func isValidReportWithDampening(report []int) (bool, error) {
	for i := 0; i < len(report); i++ {
		reportCopy := make([]int, len(report))
		copy(reportCopy, report)

		candidateDampenedReport := append(reportCopy[:i], reportCopy[i+1:]...)
		valid, err := isValidReport(candidateDampenedReport)
		if err != nil {
			return false, fmt.Errorf("validation of dampened report failed: %w", err)
		}

		if valid {
			return true, nil
		}
	}

	return false, nil
}

func calculateSafeReports(reports [][]int, validationFunc func(report []int) (bool, error)) (int, error) {
	validReports := 0
	for _, report := range reports {
		valid, err := validationFunc(report)
		if err != nil {
			return 0, fmt.Errorf("failed to check report validity: %w", err)
		}
		if valid {
			validReports++
		}
	}

	return validReports, nil
}

func main() {
	reports, err := readValuesFromFile("input.txt")

	if err != nil {
		log.Fatalf("Error reading data: %s", err)
	}

	safeReports, err := calculateSafeReports(reports, isValidReport)
	if err != nil {
		log.Fatalf("Error calculating part 1: %s", err)
	}
	fmt.Printf("Part 1: %d\n", safeReports)

	safeReports2, err := calculateSafeReports(reports, isValidReportWithDampening)
	if err != nil {
		log.Fatalf("Error calculating part 2: %s", err)
	}
	fmt.Printf("Part 2: %d\n", safeReports2)
}

$data =
  "soLongStringThatVSCodeTokenizerStartedCrying"; // Source: https://adventofcode.com/2024/day/3/input

// We will extract all mul(\d+,\d+) from the $data variable using regex
// After that we will multiply each \d+ after the , \d+ before the , and sum all the results

// Extract all mul(\d+,\d+) from the $data variable
preg_match_all('/mul\((\d+),(\d+)\)/', $data, $matches);

// Initialize the $result variable
$result = 0;

// Loop through all the matches
foreach ($matches[1] as $key => $value) {
    // Multiply the values and add the result to the $result variable
    $result += $value * $matches[2][$key];
}

echo "Part 1 result: $result\n";

preg_match_all('/mul\((\d+),(\d+)\)/', $data, $matches);
$result = 0;
foreach ($matches[1] as $key => $value) {
    $result += $value * $matches[2][$key];
}
echo "Part 1 result: $result\n";

public partial class Puzzle_2024_3 : Puzzle
{
    public override object PartOne(string data)
    {
        return MulRegex()
            .Matches(data)
            .Select(m => m.Value[4..^1]
                .Split(',')
                .Select(int.Parse)
                .Aggregate((x, y) => x * y))
            .Sum();
    }

    public override object PartTwo(string data)
    {
        int sum = 0;
        var matches = DoMulRegex().Matches(data);
        bool enable = true;
        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
            if (match.Value == "do()")
                enable = true;
            else if (match.Value == "don't()")
                enable = false;
            else if (enable)
                sum += match.Value[4..^1].Split(',').Select(int.Parse).Aggregate((x, y) => x * y);
        }

        return sum;
    }

    [GeneratedRegex(@mul\(\d+,\d+\), RegexOptions.Compiled)]
    private static partial Regex MulRegex();

    [GeneratedRegex(@(do\(\))|(don't\(\))|(mul\(\d+,\d+\)), RegexOptions.Compiled)]
    private static partial Regex DoMulRegex();
}

using System.Text.RegularExpressions;
var lines = File.ReadAllLines("input.txt");
(int sumpart1, int sumpart2) = (0, 0);
var pattern = @(do\(\))|(mul\(\d+,\d+\))|(don't\(\));
bool is_active = true;
foreach (var line in lines)
{
    var matches = Regex.Matches(line, pattern).Cast<Match>().Select(m => m.Value);
    foreach(var match in matches)
    {
        switch (match)
        {
            case "don't()":
                is_active = false;
                break;
            case "do()":
                is_active = true;
                break;
            default:
                sumpart1 += mult(match);
                if (is_active)
                    sumpart2 += mult(match);
                break;
        }
    }
}
Console.WriteLine("Part 1: " + sumpart1);
Console.WriteLine("Part 2: " + sumpart2);
int mult(string input)
{
    input = input.Remove(0, 4);
    input = input.Remove(input.Length - 1, 1);
    var a = input.Split(",").Select(int.Parse).ToArray();
    return a[0] * a[1];
}

$data =
    "^+'*>,,why()mul(229,919)&-#^~mul(187,600)_Inte_
     Php_Vänlig_Tackvare_Alla$_Tecken_Som_Parseas_i_PHP
     $_Source: https://adventofcode.com/2024/day/3/input";

// We will extract all mul(\d+,\d+) from the $data variable using regex
// After that we will multiply each \d+ after the , \d+ before the , and sum all the results
// Extract all mul(\d+,\d+) from the $data variable
preg_match_all('/mul\((\d+),(\d+)\)/', $data, $matches);

// Initialize the $result variable
$result = 0;

// Loop through all the matches
foreach ($matches[1] as $key => $value) {
    // Multiply the values and add the result to the $result variable
    $result += $value * $matches[2][$key];
}

echo "Part 1 result: $result\n";

// For Part 2 we will create a simple tokenizer that will start "reading" the $data variable
// and keeping track of its position in the string, the current state (valid or invalid)
// by knowing whether it has seen a "do()" or "don't()".
// "do()" means we will parse and multiply the values inside of mul(\d+,\d+)
// whereas "don't()" means we will ignore the values inside of mul(\d+,\d+)
// until we stumble upon a "do()" again.

// Reset the $result variable and initialize others
$result = 0;
$currentState = "do()";
$currentToken = ""; // This will store the current token we are parsing which will be "do()", "don't()" or a mul(\d+,\d+)
$currentNumber1 = ""; // This and variable below will store the values inside of mul(\d+,\d+)
$currentNumber2 = ""; // After that they would be multiplied and added to the $result variable, then reset to 0

// Initialize the $position variable
$position = 0;

// Use a while loop to tokenize the input string
$i = 0;
while ($i < strlen($data)) {

    echo "Current $i: " . $data[$i] . "| Current token: $currentToken" . "\n";
    // Check if current character is a "m" when state is do and token is empty
    // This means we are trying to build a "mul(\d+,\d+)" token string
    if ($currentState == "do()" && $currentToken == "" && $data[$i] == "m") {
        // We now check if the next 3 characters are "mul(" and if so we add them to the token
        if ($data[$i] == "m" && $data[$i + 1] == "u" && $data[$i + 2] == "l" && $data[$i + 3] == "(") {
            $currentToken = "mul(";
            $i += 3;
        }
    } // Check if current token is "mul(" which means next up is "\d+,\d+"
    elseif ($currentState == "do()" && $currentToken == "mul(" && is_numeric($data[$i])) {
        // We then loop through the string until we HOPEFULLY find a "," which means we have found the first number
        $validNumbers = true; // This boolean will be used to determine if the current mul(\d+,\d+) is valid or not
        while (is_numeric($data[$i])) {
            $currentNumber1 .= $data[$i];
            echo "Current $i: " . $data[$i] . "| Current token: $currentToken | Current 1st Number: $currentNumber1" . "\n";
            $i++;
        }

        // When a comma after first number was not found, we will consider the current mul(\d+,\d+) as invalid
        if ($data[$i] != ",") {
            $validNumbers = false;
            echo "Invalid split after (no comma) $currentNumber1. NOT added to the current result: $result\n";
            $currentToken = "";
            $currentNumber1 = "";
            $currentNumber2 = "";
            continue;
        }
        $i++; // to skip the valid ","
        // Then we loop again until we HOPEFULLY find ")" which means we have found the second number
        while (is_numeric($data[$i])) {
            $currentNumber2 .= $data[$i];
            echo "Current $i: " . $data[$i] . "| Current token: $currentToken | Current 2nd Number: $currentNumber2" . "\n";
            $i++;
        }

        // Check if the non-numeric character after the second number is a ")" which means we have found a valid mul(\d+,\d+)
        if ($data[$i] != ")") {
            $validNumbers = false;
            echo "Invalid split after (no closing parenthesis) $currentNumber2. NOT added to the current result: $result\n";
            $currentToken = "";
            $currentNumber1 = "";
            $currentNumber2 = "";
            continue;
        }
        // and we can change the $currentToken to "" and reset the $currentNumber1 and $currentNumber2.
        // Now, we also multiply and increment the $result variable
        $currentToken = "";
        $result += intval($currentNumber1) * intval($currentNumber2);
        echo "Numbers: $currentNumber1 and $currentNumber2 multiplied and added to current result: $result\n";
        $currentNumber1 = "";
        $currentNumber2 = "";
    }
    // Check if current token "d" meaning we will check for "do()" or "don't()" to change the current token.
    elseif ($currentToken == "" && $data[$i] == "d") {
        // Now check if after "d" o() follows which means we have found a "do()"
        if ($data[$i + 1] == "o" && $data[$i + 2] == "(" && $data[$i + 3] == ")") {
            $currentState = "do()";
            $currentToken = "";
            $i += 3;
            echo "Do() found\n";
        }
        // Else check if after "d" on't() follows which means we have found a "don't()"
        elseif ($data[$i + 1] == "o" && $data[$i + 2] == "n" && $data[$i + 3] == "'" && $data[$i + 4] == "t" && $data[$i + 5] == "(" && $data[$i + 6] == ")") {
            $currentState = "don't()";
            $currentToken = "";
            $i += 6;
            echo "Don't() found\n";
        }
    }
    $i++;
}

echo "Part 2 result: $result\n";

<?php

$data =
    "^+'*>,,why()mul(229,919)&-#^~mul(187,600)_Inte_
     Php_Vänlig_Tackvare_Alla$_Tecken_Som_Parseas_i_PHP
     $_Source: https://adventofcode.com/2024/day/3/input";

preg_match_all('/mul\((\d+),(\d+)\)/', $data, $matches);

$result = 0;
foreach ($matches[1] as $key => $value) {
    $result += $value * $matches[2][$key];
}

echo "Part 1 result: $result\n";

$result = 0;
$currentState = "do()";
$currentToken = "";
$currentNumber1 = "";
$currentNumber2 = "";
$position = 0;
$i = 0;
while ($i < strlen($data)) {

    echo "Current $i: " . $data[$i] . "| Current token: $currentToken" . "\n";
    if ($currentState == "do()" && $currentToken == "" && $data[$i] == "m") {
        if ($data[$i] == "m" && $data[$i + 1] == "u" && $data[$i + 2] == "l" && $data[$i + 3] == "(") {
            $currentToken = "mul(";
            $i += 3;
        }
    } elseif ($currentState == "do()" && $currentToken == "mul(" && is_numeric($data[$i])) {

        $validNumbers = true;
        while (is_numeric($data[$i])) {
            $currentNumber1 .= $data[$i];
            echo "Current $i: " . $data[$i] . "| Current token: $currentToken | Current 1st Number: $currentNumber1" . "\n";
            $i++;
        }

        if ($data[$i] != ",") {
            $validNumbers = false;
            echo "Invalid split after (no comma) $currentNumber1. NOT added to the current result: $result\n";
            $currentToken = "";
            $currentNumber1 = "";
            $currentNumber2 = "";
            continue;
        }
        $i++;
        while (is_numeric($data[$i])) {
            $currentNumber2 .= $data[$i];
            echo "Current $i: " . $data[$i] . "| Current token: $currentToken | Current 2nd Number: $currentNumber2" . "\n";
            $i++;
        }

        if ($data[$i] != ")") {
            $validNumbers = false;
            echo "Invalid split after (no closing parenthesis) $currentNumber2. NOT added to the current result: $result\n";
            $currentToken = "";
            $currentNumber1 = "";
            $currentNumber2 = "";
            continue;
        }

        $currentToken = "";
        $result += intval($currentNumber1) * intval($currentNumber2);
        echo "Numbers: $currentNumber1 and $currentNumber2 multiplied and added to current result: $result\n";
        $currentNumber1 = "";
        $currentNumber2 = "";
    } elseif ($currentToken == "" && $data[$i] == "d") {

        if ($data[$i + 1] == "o" && $data[$i + 2] == "(" && $data[$i + 3] == ")") {
            $currentState = "do()";
            $currentToken = "";
            $i += 3;
            echo "Do() found\n";
        } elseif ($data[$i + 1] == "o" && $data[$i + 2] == "n" && $data[$i + 3] == "'" && $data[$i + 4] == "t" && $data[$i + 5] == "(" && $data[$i + 6] == ")") {
            $currentState = "don't()";
            $currentToken = "";
            $i += 6;
            echo "Don't() found\n";
        }
    }
    $i++;
}

echo "Part 2 result: $result\n";