🌟 Advent of Code (AoC) 2024 🌟

$content = Get-Content day3.txt
### Part 1

$readableData = [regex]::Matches($content, 'mul\(\d{1,3},\d{1,3}\)')
$mulInstructions = 0
$correctedMulInstructions = 0

$readableData | ForEach-Object{
    $item = ($PSItem.Value).Replace( 'mul(','' ).Replace(')','').Split(',')
    $mulInstructions = $mulInstructions + ([int]$item[0] * [int]$item[1])
}
Write-Host "Part 1: $mulInstructions"
### Part 2

$extractedDataToCalculate = $allData = @()
$allData += [regex]::Matches($content, "don't()|do()" )
$allData += $readableData
$allData = $allData | Sort-Object Index
$doCalculations = $true

$allData | ForEach-Object{
    switch($PSItem.Value){
        "do"        { $doCalculations = $true }
        "don't"     { $doCalculations = $false }
    }
    if( $doCalculations -eq $true -and $PSItem.Value -like 'mul*' ){
        $extractedDataToCalculate += $PSItem
    }
}

$extractedDataToCalculate | ForEach-Object{
    $item = ($PSItem.Value).Replace( 'mul(','' ).Replace(')','').Split(',')
    $correctedMulInstructions = $correctedMulInstructions + ([int]$item[0] * [int]$item[1])
}
Write-Host "Part 2: $correctedMulInstructions"

open System.Text.RegularExpressions

let input = System.IO.File.ReadAllText "./input.txt"

let parse pattern input =     
    Regex.Matches(input, pattern) |>
    Seq.fold (fun (acc, enabled) cur ->
        match cur.Value with
        | "do()" -> (acc, true)
        | "don't()" -> (acc, false)
        | _ when enabled -> let x = int cur.Groups.[1].Value
                            let y = int cur.Groups.[2].Value
                            ((acc+x*y), enabled)
        | _ -> (acc, enabled)
    ) (0, true) |> fst
    
let part1 = parse @"mul\((\d+),(\d+)\)"
let part2 = parse @"mul\((\d+),(\d+)\)|do\(\)|don't\(\)"
    
printfn $"Part 1: %i{part1 input}"
printfn $"Part 2: %i{part2 input}"

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)
    {
        return DoMulRegex()
            .Matches(data)
            .Aggregate<Match, (bool enabled, int acc)>((true, 0), (current, match) => match.Value switch
            {
                "do()" => (true, current.acc),
                "don't()" => (false, current.acc),
                _ => (current.enabled,
                    current.enabled
                        ? current.acc += match.Value[4..^1].Split(',').Select(int.Parse).Aggregate((x, y) => x * y)
                        : current.acc)
            }).acc;
    }

    [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();
}

print([eval("("+"".join([re.sub(r"mul\((\d{1,3}),(\d{1,3})\)", r"+\1*\2", i)
                         .replace("do()", ")+(")
                         .replace("don't()", p) 
                         for line in [re.findall(r"mul\(\d{1,3},\d{1,3}\)|do\(\)|don't\(\)", l) 
                                      for l in open("input03.txt", "r").readlines()] 
                         for i in line]) + ")") 
       for p in [")+(", ")+0*("]])

import re


def day(data: list, debug=True):
    if debug:
        print(f' Mul reports \n{data}')

        # Use debug to switch between the two example data items provided for part 1 and part 2
        data_1 = [data[0]]
        data_2 = [data[1]]

    else:
        data_1 = data_2 = data

    print(' --------- Part 1 ---------')
    re_mul = re.compile(r'mul\(\d+,\d+\)')
    re_digits = re.compile(r'\d+')

    mul_added = 0
    for line in data_1:
        # Find correct mul statements
        matches = re_mul.findall(line)

        for match in matches:
            # Find numbers to multiply
            a, b = re_digits.findall(match)
            if debug:
                print(f' {match}, {a}, {b}')

            mul_added += int(a) * int(b)

    print(' --------- Part 2 ---------')
    mul_added_2 = 0

    # Start with match enabled
    match_enabled = True

    for line in data_2:

        # Use regular expression groups to find all relevant combinations in correct order and iterate over them
        for match in re.finditer(r"(don\'t\(\))|(do\(\))|(mul\(\d+,\d+\))", line):

            # Assign matches depending on order defined in the regular expression
            dont, do, mul = match.groups()

            if debug:
                print(f'\tDo: {do} - Dont: {dont} - mul: {mul}')

            if do:
                if debug:
                    print('\t -Match enabled')
                match_enabled = True
            elif dont:
                if debug:
                    print('\t -Match disabled')
                match_enabled = False
            else:
                if match_enabled:
                    a, b = re_digits.findall(mul)
                    mul_added_2 += int(a) * int(b)
                    if debug:
                        print(f'\tAdd mul: {mul}, {a}, {b}, New mul: {mul_added_2}')
                else:
                    if debug:
                        print("\tSkipping mul as disabled")

    print(f' Answer part 1: {mul_added}, part 2: {mul_added_2}')
    return mul_added, mul_added_2

public class Solver
{
    public static int Run_PartOne(List<string> input)
    {
        var leftNumbers = new List<int>();
        var rightNumbers = new List<int>();
        foreach (var line in input)
        {
            var numbers = line.Split("   ");
            var left = int.Parse(numbers[0]);
            var right = int.Parse(numbers[1]);
            leftNumbers.Add(left);
            rightNumbers.Add(right);
        }

        leftNumbers = leftNumbers.OrderBy(x => x).ToList();
        rightNumbers = rightNumbers.OrderBy(x => x).ToList();
        
        var totalDistance = 0;
        for (int i = 0; i < input.Count; i++)
        {
            var left = leftNumbers[i];
            var right = rightNumbers[i];
            var distance = Math.Abs(left - right);
            totalDistance += distance;
        }
        
        return totalDistance;
    }
    public static int Run_PartTwo(List<string> input)
    {
        var leftNumbers = new List<int>();
        var rightNumbers = new List<int>();
        foreach (var line in input)
        {
            var numbers = line.Split("   ");
            var left = int.Parse(numbers[0]);
            var right = int.Parse(numbers[1]);
            leftNumbers.Add(left);
            rightNumbers.Add(right);
        }
        
        var totalSimilarityScore = 0;
        for (int i = 0; i < leftNumbers.Count; i++)
        {
            var left = leftNumbers[i];
            var leftInRightCount = rightNumbers.Count(n => n == left);
            var similarityScore = left * leftInRightCount;
            totalSimilarityScore += similarityScore;
        }
        
        return totalSimilarityScore;
    }
}

public class Solver
{
    private static bool AllNumbersAreAscOrDesc(List<int> numbers)
    {
        return numbers.SequenceEqual(numbers.Order()) || numbers.SequenceEqual(numbers.OrderDescending());
    }

    private static bool CheckAllAdjacentNumberDistances(List<int> numbers, int minDistance, int maxDistance)
    {
        bool isValid = true;
        for (int i = 0; i < numbers.Count - 1; i++)
        {
            var distance = Math.Abs(numbers[i] - numbers[i + 1]);
            if (distance < minDistance || distance > maxDistance)
            {
                isValid = false;
                break;
            }
        }
        return isValid;
    }

    private static bool ValidateNumbers(List<int> numbers)
    {
        return AllNumbersAreAscOrDesc(numbers) && CheckAllAdjacentNumberDistances(numbers, 1, 3);
    }

    public static int Run_PartOne(List<string> input)
    {
        // Example line: "7 6 4 2 1"
        // Each line must validate against the following rules:
        //  1.    All increasing or all decreasing
        //  2.    Any two adjacent numbers differs by at least one and at most three

        int safeLines = 0;
        foreach (var line in input)
        {
            var numbers = line.Split(" ").Select(x => int.Parse(x)).ToList();
            
            if(ValidateNumbers(numbers))
                safeLines++;
        }
        
        return safeLines;
    }
    
    public static int Run_PartTwo(List<string> input)
    {
        // Example line: "7 6 4 2 1"
        // Each line must validate against the following rules:
        //  1.    All increasing or all decreasing
        //  2.    Any two adjacent numbers differs by at least one and at most three
        // If the line does not validate, try ignoring one number at a time, until every number has been ignored once. 
        // If the line validates while ignoring a number, count it as valid.

        int safeLines = 0;
        foreach (var line in input)
        {
            var numbers = line.Split(" ").Select(x => int.Parse(x)).ToList();
            
            var isValid = numbers
                .Index()
                .Any(item => ValidateNumbers(numbers.Index().Where(t => t.Index != item.Index).Select(t => t.Item).ToList()));
            
           if(isValid) 
               safeLines++;
        }
        
        return safeLines;
    }
}

public class Solver
{
    public static int Run_PartOne(string input)
    {
        // Run the multiplications (mul(X,Y)) from the input
        // Only run the instructions defined as; mul(number,number) and ignore anything that does not match this pattern
        // Sum the results from each instruction

        var result = 0;
        var matches = Regex.Matches(input, @mul\((\d+)\,(\d+)\));
        foreach (Match match in matches)
        {
            var first = int.Parse(match.Groups[1].Value);
            var second = int.Parse(match.Groups[2].Value);
            result += first * second;
        }
        return result;
    }
    
    public static int Run_PartTwo(string input)
    {
        // Run the multiplications (mul(X,Y)) from the input
        // Only run the instructions defined as; mul(number,number) and ignore anything that does not match this pattern
        // instructions following a "don't()" is ignored until a "do()" is reached - where it is enabled again.
        // Sum the results from each instruction
        
        do
        {
            var startIndex = input.IndexOf("don't()");
            var endIndex = input.Substring(startIndex).IndexOf("do()");
            if (endIndex == -1)
            {
                input = input.Substring(0, startIndex);
            }
            else
            {
                endIndex += "do()".Length + startIndex;
           
                input = input.Replace(input.Substring(startIndex, endIndex -  startIndex), "");
    
            }

        } while (input.Contains("don't()"));
            
        var result = 0;
        var matches = Regex.Matches(input, @mul\((\d+)\,(\d+)\));
        foreach (Match match in matches)
        {
            var first = int.Parse(match.Groups[1].Value);
            var second = int.Parse(match.Groups[2].Value);
            result += first * second;
        }
        
        return result;
    }
}

package main

import (
	"fmt"
	"io"
	"log"
	"os"
	"regexp"
	"strconv"
)

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

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

	defer file.Close()

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

	return string(data), nil
}

type Mul struct {
	Val1 int
	Val2 int
}

func getGroupNameMap(names []string) map[string]int {
	nameMap := map[string]int{}

	for i, v := range names {
		if v != "" {
			nameMap[v] = i
		}
	}

	return nameMap
}

func parseMultiplications(value string, interpretConditionals bool) ([]Mul, error) {
	re := regexp.MustCompile(`(?:(?P<Mul>mul)\((?P<MulVal1>\d+),(?P<MulVal2>\d+)\))|(?:(?P<Do>do)\(\))|(?:(?P<Dont>don't)\(\))`)
	groupNames := getGroupNameMap(re.SubexpNames())

	matches := re.FindAllStringSubmatch(value, -1)

	muls := []Mul{}
	mulsEnabled := true

	for _, match := range matches {
		if match[groupNames["Mul"]] == "mul" {
			if mulsEnabled {
				val1, err := strconv.Atoi(match[groupNames["MulVal1"]])
				if err != nil {
					return nil, fmt.Errorf("not an integer: %s", match[groupNames["MulVal1"]])
				}

				val2, err := strconv.Atoi(match[groupNames["MulVal2"]])
				if err != nil {
					return nil, fmt.Errorf("not an integer: %s", match[groupNames["MulVal2"]])
				}

				mul := Mul{Val1: val1, Val2: val2}
				muls = append(muls, mul)
			}
		}
		if interpretConditionals {
			if match[groupNames["Do"]] == "do" {
				mulsEnabled = true
			}
			if match[groupNames["Dont"]] == "don't" {
				mulsEnabled = false
			}
		}
	}
	return muls, nil
}

func calculateMultiplications(value string, interpretConditionals bool) (int, error) {
	muls, err := parseMultiplications(value, interpretConditionals)
	if err != nil {
		return 0, fmt.Errorf("failed to parse multiplications: %w", err)
	}

	total := 0
	for _, mul := range muls {
		total += mul.Val1 * mul.Val2
	}

	return total, nil
}

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

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

	total, err := calculateMultiplications(value, false)
	if err != nil {
		log.Fatalf("Error calculating part 1: %s", err)
	}
	fmt.Printf("Part 1: %d\n", total)

	total2, err := calculateMultiplications(value, true)
	if err != nil {
		log.Fatalf("Error calculating part 2: %s", err)
	}
	fmt.Printf("Part 2: %d\n", total2)

}

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

void new_row_without_idx(const int *in, int *out, int rm_idx)
{
    int ofs = 0;
    for (int i = 0; i < 7; i++) {
        if (rm_idx == i) {
            ofs = 1;
        }
        out[i] = in[i+ofs];
    }
}

// returns 0 if safe, -1 when non-safe
int is_row_safe(int *row)
{
    int dir = 0;
    int j;

    for (j = 1; j < 8; j++) {
        // start by checking if value is zero, that means we've passed through the row successfully
        if (row[j] == 0) {
            return 0;
        }

        if (!dir) {
            dir = row[j] - row[j-1];
        }

        if (dir > 0) {
            if (row[j-1] >= row[j]) {
                return -1;
            }
        } else { // dir decreasing
            if (row[j-1] <= row[j]) {
                return -1;
            }
        }

        // Check safeness - diff 1-3 and same dir
        if (abs(row[j-1] - row[j]) > 3) {
            return -1; // diff outside of 1-3 range
        }
    }
    return 0;
}

int main(int argc, char *argv[])
{
    FILE *fp;
    int a[1000][8] = {{0}};
    char tmp[100], *r = NULL;
    int i = 0, j;
    int safecount = 0;

    fp = fopen("input.txt", "r");

    while ((r = fgets(tmp, sizeof(tmp), fp)) != NULL) {
        (void) sscanf(r, "%d %d %d %d %d %d %d %d", &a[i][0], &a[i][1], &a[i][2], &a[i][3], &a[i][4], &a[i][5], &a[i][6], &a[i][7]);
        i++;
    }
    fclose(fp);

    // part 1
    for (i = 0; i < 1000; i++) {
        if (is_row_safe(a[i]) == 0) {
            safecount++;
        }
    }
    printf("part1: %d\n", safecount);

    // part 2
    int tmprow[8] = {0};
    safecount = 0;

    for (i = 0; i < 1000; i++) {
        if (is_row_safe(a[i]) != 0) {
            for (j = 0; j < 8; j++) {
                memset(tmprow, 0, sizeof(tmprow));
                new_row_without_idx(a[i], tmprow, j);
                if (is_row_safe(tmprow) == 0) {
                    safecount++;
                    break;
                }
            }
        } else {
            safecount++;
        }
    }

    printf("part 2: %d\n", safecount);

    return 0;
}

// 4.php | PHP
$cleanLines = array_map('rtrim', explode("\n", $data));

$grid = array_map('str_split', $cleanLines);

$LINELENGTH = strlen($cleanLines[0]);
$MAXINDEX = $LINELENGTH - 1;
$NUMBEROFLINES = count($cleanLines);

$numberOfFoundXMAS = 0;

echo "Line Length: $LINELENGTH\n";
echo "Max Index: $MAXINDEX\n";
echo "Number of Lines: $NUMBEROFLINES\n";

function checkRowStraightAndReverse($stringRow, &$numberOfFoundXMAS)
{
    $numberOfFoundXMAS += substr_count($stringRow, "XMAS");
    $numberOfFoundXMAS += substr_count($stringRow, "SAMX");
}

for ($i = 0; $i < $NUMBEROFLINES; $i++) {
    checkRowStraightAndReverse($cleanLines[$i], $numberOfFoundXMAS);
}
echo "Found Horizontally Total: $numberOfFoundXMAS\n";

for ($i = 0; $i < $LINELENGTH; $i++) {
    $stringColumn = "";
    for ($j = 0; $j < $NUMBEROFLINES; $j++) {
        $stringColumn .= $grid[$j][$i];
    }
    checkRowStraightAndReverse($stringColumn, $numberOfFoundXMAS);
}

echo "Found Horizontally+Vertically: $numberOfFoundXMAS\n";

for ($i = 0; $i < $NUMBEROFLINES; $i++) {
    $stringDiagonal = "";
    for ($j = 0; $j < $NUMBEROFLINES - $i; $j++) {
        $stringDiagonal .= $grid[$j][$j + $i];
    }
    checkRowStraightAndReverse($stringDiagonal, $numberOfFoundXMAS);
}

for ($i = 0; $i < $NUMBEROFLINES; $i++) {
    $stringDiagonal = "";
    for ($j = 0; $j < $NUMBEROFLINES - $i; $j++) {
        $stringDiagonal .= $grid[$j][$NUMBEROFLINES - $j - $i - 1];
    }
    checkRowStraightAndReverse($stringDiagonal, $numberOfFoundXMAS);
}

echo "Found Horizontally+Vertically+Diagonally: $numberOfFoundXMAS\n";

public class Solver
{
    private enum Direction { Up, Down, Left, Right, UpRight, UpLeft, DownRight, DownLeft }
    private static string GetStringForDir(List<string> input, int xPos, int yPos, Direction dir)
    {
        int x2 = xPos, x3 = xPos, x4 = xPos;
        int y2 = yPos, y3 = yPos, y4 = yPos;
        switch (dir)
        {
            case Direction.Up:
                y2 = yPos - 1;
                y3 = yPos - 2;
                y4 = yPos - 3;
                break;
            case Direction.Down:
                y2 = yPos + 1;
                y3 = yPos + 2;
                y4 = yPos + 3;
                break;
            case Direction.Left:
                x2 = xPos - 1;
                x3 = xPos - 2;
                x4 = xPos - 3;
                break;
            case Direction.Right:
                x2 = xPos + 1;
                x3 = xPos + 2;
                x4 = xPos + 3;
                break;
            case Direction.UpLeft:
                y2 = yPos - 1;
                y3 = yPos - 2;
                y4 = yPos - 3;
                x2 = xPos - 1;
                x3 = xPos - 2;
                x4 = xPos - 3;
                break;
            case Direction.UpRight:
                y2 = yPos - 1;
                y3 = yPos - 2;
                y4 = yPos - 3;
                x2 = xPos + 1;
                x3 = xPos + 2;
                x4 = xPos + 3;
                break;
            case Direction.DownLeft:
                y2 = yPos + 1;
                y3 = yPos + 2;
                y4 = yPos + 3;
                x2 = xPos - 1;
                x3 = xPos - 2;
                x4 = xPos - 3;
                break;
            case Direction.DownRight:  
                y2 = yPos + 1;
                y3 = yPos + 2;
                y4 = yPos + 3;
                x2 = xPos + 1;
                x3 = xPos + 2;
                x4 = xPos + 3;
                break;
        }

        return $"{input[yPos][xPos]}{input[y2][x2]}{input[y3][x3]}{input[y4][x4]}";
    }

    private static bool IsDirValid(List<string> characters, int xPos, int yPos, Direction dir, int maxLength)
    {
        switch (dir)
        {
            case Direction.Up:
                return yPos - maxLength >= 0;
            case Direction.Down:
                return yPos < characters.Count - maxLength;
            case Direction.Left:
                return xPos - maxLength >= 0;
            case Direction.Right:
                return xPos < characters[yPos].Length - maxLength;
            case Direction.UpLeft:
                return xPos - maxLength >= 0 && yPos - maxLength >= 0;
            case Direction.UpRight:
                return xPos < characters[yPos].Length - maxLength && yPos - maxLength >= 0;
            case Direction.DownLeft:
                return xPos - maxLength >= 0 && yPos < characters.Count - maxLength;
            case Direction.DownRight:
                return xPos < characters[yPos].Length - maxLength && yPos < characters.Count - maxLength;
            default: 
                return false;
        }
    }
    
    public static int Run_PartOne(List<string> input)
    {
        var matchedString = "XMAS";
        int matchedCount = 0;
        for (int y = 0; y < input.Count; y++)
        {
            for (int x = 0; x < input[y].Length; x++)
            {
                var character = input[y][x].ToString();
                if (character == "X")
                {
                    foreach (var dir in new List<Direction>(){ Direction.Up, Direction.Down, Direction.Left, Direction.Right, Direction.UpRight, Direction.UpLeft, Direction.DownRight, Direction.DownLeft })
                    {
                        if (IsDirValid(input, x, y, dir, matchedString.Length - 1))
                        {
                           var res = GetStringForDir(input, x, y, dir);
                           if (res == matchedString) matchedCount++;
                        } 
                    }
                }
            }
        }
        return matchedCount;
    }
    public static int Run_PartTwo(List<string> input)
    {
        int matchedCount = 0;
        for (int y = 0; y < input.Count; y++)
        {
            for (int x = 0; x < input[y].Length; x++)
            {
                var character = input[y][x].ToString();
                if (character == "A")
                {
                    var topLeftX = x - 1;
                    var topLeftY = y - 1;
                    var topRightX = x + 1;
                    var topRightY = y - 1;
                    var bottomLeftX = x - 1;
                    var bottomLeftY = y + 1;
                    var bottomRightX = x + 1;
                    var bottomRightY = y + 1;
                    if (IsDirValid(input, x, y, Direction.UpLeft, 1) && IsDirValid(input, x, y, Direction.UpRight, 1)
                        && IsDirValid(input, x, y, Direction.DownLeft, 1) && IsDirValid(input, x, y, Direction.DownRight, 1))
                    {
                        if(((input[topLeftY][topLeftX] == 'M' && input[bottomRightY][bottomRightX] == 'S') || (input[topLeftY][topLeftX] == 'S' && input[bottomRightY][bottomRightX] == 'M')) &&
                           ((input[topRightY][topRightX] == 'M' && input[bottomLeftY][bottomLeftX] == 'S') || (input[topRightY][topRightX] == 'S' && input[bottomLeftY][bottomLeftX] == 'M')))
                        {
                            matchedCount++;
                        }
                    } 
                }
            }
        }
        return matchedCount;
    }
}

<?php
$data = "https://adventofcode.com/2024/day/4/input";

// Prepare ["X,Y"] coordinate using PHP associative keys!
$cleanLines = array_map('rtrim', explode("\n", $data));
$coordinateSystem = [];
foreach ($cleanLines as $y => $row) {
    for ($x = 0; $x < strlen($row); $x++) {
        $coord = ($x + 1) . "," . ($y + 1);
        $coordinateSystem[$coord] = $row[$x];
    }
}

$numberOfFoundXMAS = 0;

function getCharAt($coordinate, $coordinateSystem)
{
    return isset($coordinateSystem[$coordinate]) ? $coordinateSystem[$coordinate] : "?";
}

function checkForMASAllDirections($coordinate, $coordinateSystem, &$numberOfFoundXMAS)
{
    // The starting X,Y coordinates
    [$startX, $startY] = array_map('intval', explode(",", $coordinate));

    // Check all to the Left meaning, we add getCharAt X-1, X-2, and X-3 and see if that spells "MAS"
    if (
        getCharAt(($startX - 1) . "," . $startY, $coordinateSystem) === "M" &&
        getCharAt(($startX - 2) . "," . $startY, $coordinateSystem) === "A" &&
        getCharAt(($startX - 3) . "," . $startY, $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Right meaning, we add getCharAt X+1, X+2, and X+3 and see if that spells "MAS"
    if (
        getCharAt(($startX + 1) . "," . $startY, $coordinateSystem) === "M" &&
        getCharAt(($startX + 2) . "," . $startY, $coordinateSystem) === "A" &&
        getCharAt(($startX + 3) . "," . $startY, $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Up meaning, we add getCharAt X,Y-1, X,Y-2, and X,Y-3 and see if that spells "MAS"
    if (
        getCharAt($startX . "," . ($startY - 1), $coordinateSystem) === "M" &&
        getCharAt($startX . "," . ($startY - 2), $coordinateSystem) === "A" &&
        getCharAt($startX . "," . ($startY - 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Down meaning, we add getCharAt X,Y+1, X,Y+2, and X,Y+3 and see if that spells "MAS"
    if (
        getCharAt($startX . "," . ($startY + 1), $coordinateSystem) === "M" &&
        getCharAt($startX . "," . ($startY + 2), $coordinateSystem) === "A" &&
        getCharAt($startX . "," . ($startY + 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Top Left meaning, we add getCharAt X-1,Y-1, X-2,Y-2, and X-3,Y-3 and see if that spells "MAS"
    if (
        getCharAt(($startX - 1) . "," . ($startY - 1), $coordinateSystem) === "M" &&
        getCharAt(($startX - 2) . "," . ($startY - 2), $coordinateSystem) === "A" &&
        getCharAt(($startX - 3) . "," . ($startY - 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Top Right meaning, we add getCharAt X+1,Y-1, X+2,Y-2, and X+3,Y-3 and see if that spells "MAS"
    if (
        getCharAt(($startX + 1) . "," . ($startY - 1), $coordinateSystem) === "M" &&
        getCharAt(($startX + 2) . "," . ($startY - 2), $coordinateSystem) === "A" &&
        getCharAt(($startX + 3) . "," . ($startY - 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Bottom Left meaning, we add getCharAt X-1,Y+1, X-2,Y+2, and X-3,Y+3 and see if that spells "MAS"
    if (
        getCharAt(($startX - 1) . "," . ($startY + 1), $coordinateSystem) === "M" &&
        getCharAt(($startX - 2) . "," . ($startY + 2), $coordinateSystem) === "A" &&
        getCharAt(($startX - 3) . "," . ($startY + 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Bottom Right meaning, we add getCharAt X+1,Y+1, X+2,Y+2, and X+3,Y+3 and see if that spells "MAS"
    if (
        getCharAt(($startX + 1) . "," . ($startY + 1), $coordinateSystem) === "M" &&
        getCharAt(($startX + 2) . "," . ($startY + 2), $coordinateSystem) === "A" &&
        getCharAt(($startX + 3) . "," . ($startY + 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }
}

foreach ($coordinateSystem as $coord => $value) {
    if ($value === "X") {
        checkForMASAllDirections($coord, $coordinateSystem, $numberOfFoundXMAS);
    }
}

echo "Found XMAS/SAMX in Total (Part 1): $numberOfFoundXMAS\n";

<?php
$data = "https://adventofcode.com/2024/day/4/input";

$cleanLines = array_map('rtrim', explode("\n", $data));
$coordinateSystem = [];
foreach ($cleanLines as $y => $row) {
    for ($x = 0; $x < strlen($row); $x++) {
        $coord = ($x + 1) . "," . ($y + 1); // Coordinates as "1,1", "2,1", etc.
        $coordinateSystem[$coord] = $row[$x];
    }
}

function getCharAt($coordinate, $coordinateSystem)
{
    return isset($coordinateSystem[$coordinate]) ? $coordinateSystem[$coordinate] : "?";
}

function checkForMASAllDirections($coordinate, $coordinateSystem, &$numberOfFoundXMAS)
{
    // The starting X,Y coordinates
    [$startX, $startY] = array_map('intval', explode(",", $coordinate));

    // Check all to the Left meaning, we add getCharAt X-1, X-2, and X-3 and see if that spells "MAS"
    if (
        getCharAt(($startX - 1) . "," . $startY, $coordinateSystem) === "M" &&
        getCharAt(($startX - 2) . "," . $startY, $coordinateSystem) === "A" &&
        getCharAt(($startX - 3) . "," . $startY, $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Right meaning, we add getCharAt X+1, X+2, and X+3 and see if that spells "MAS"
    if (
        getCharAt(($startX + 1) . "," . $startY, $coordinateSystem) === "M" &&
        getCharAt(($startX + 2) . "," . $startY, $coordinateSystem) === "A" &&
        getCharAt(($startX + 3) . "," . $startY, $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Up meaning, we add getCharAt X,Y-1, X,Y-2, and X,Y-3 and see if that spells "MAS"
    if (
        getCharAt($startX . "," . ($startY - 1), $coordinateSystem) === "M" &&
        getCharAt($startX . "," . ($startY - 2), $coordinateSystem) === "A" &&
        getCharAt($startX . "," . ($startY - 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Down meaning, we add getCharAt X,Y+1, X,Y+2, and X,Y+3 and see if that spells "MAS"
    if (
        getCharAt($startX . "," . ($startY + 1), $coordinateSystem) === "M" &&
        getCharAt($startX . "," . ($startY + 2), $coordinateSystem) === "A" &&
        getCharAt($startX . "," . ($startY + 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Top Left meaning, we add getCharAt X-1,Y-1, X-2,Y-2, and X-3,Y-3 and see if that spells "MAS"
    if (
        getCharAt(($startX - 1) . "," . ($startY - 1), $coordinateSystem) === "M" &&
        getCharAt(($startX - 2) . "," . ($startY - 2), $coordinateSystem) === "A" &&
        getCharAt(($startX - 3) . "," . ($startY - 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Top Right meaning, we add getCharAt X+1,Y-1, X+2,Y-2, and X+3,Y-3 and see if that spells "MAS"
    if (
        getCharAt(($startX + 1) . "," . ($startY - 1), $coordinateSystem) === "M" &&
        getCharAt(($startX + 2) . "," . ($startY - 2), $coordinateSystem) === "A" &&
        getCharAt(($startX + 3) . "," . ($startY - 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Bottom Left meaning, we add getCharAt X-1,Y+1, X-2,Y+2, and X-3,Y+3 and see if that spells "MAS"
    if (
        getCharAt(($startX - 1) . "," . ($startY + 1), $coordinateSystem) === "M" &&
        getCharAt(($startX - 2) . "," . ($startY + 2), $coordinateSystem) === "A" &&
        getCharAt(($startX - 3) . "," . ($startY + 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }

    // Check all to the Bottom Right meaning, we add getCharAt X+1,Y+1, X+2,Y+2, and X+3,Y+3 and see if that spells "MAS"
    if (
        getCharAt(($startX + 1) . "," . ($startY + 1), $coordinateSystem) === "M" &&
        getCharAt(($startX + 2) . "," . ($startY + 2), $coordinateSystem) === "A" &&
        getCharAt(($startX + 3) . "," . ($startY + 3), $coordinateSystem) === "S"
    ) {
        $numberOfFoundXMAS += 1;
    }
}

function checkForMSTopAndBottomCorners($coordinate, $coordinateSystem, &$numberOfFoundXMAS)
{
    // The starting X,Y coordinates
    [$startX, $startY] = array_map('intval', explode(",", $coordinate));

    // Check if the Top Left and Top Right "M" and "S", and same with the Bottom Left & Right
    // OR "S S" on top and "M M" on bottom or "S M" on top and "S M" on bottom
    if (
        (getCharAt(($startX - 1) . "," . ($startY - 1), $coordinateSystem) === "M" && // Top Left
            getCharAt(($startX + 1) . "," . ($startY - 1), $coordinateSystem) === "S" && // Top Right
            getCharAt(($startX - 1) . "," . ($startY + 1), $coordinateSystem) === "M" && // Bottom Left
            getCharAt(($startX + 1) . "," . ($startY + 1), $coordinateSystem) === "S") // Bottom Right

        ||
        (getCharAt(($startX - 1) . "," . ($startY - 1), $coordinateSystem) === "S" &&
            getCharAt(($startX + 1) . "," . ($startY - 1), $coordinateSystem) === "S" &&
            getCharAt(($startX - 1) . "," . ($startY + 1), $coordinateSystem) === "M" &&
            getCharAt(($startX + 1) . "," . ($startY + 1), $coordinateSystem) === "M")

        ||
        (getCharAt(($startX - 1) . "," . ($startY - 1), $coordinateSystem) === "S" &&
            getCharAt(($startX + 1) . "," . ($startY - 1), $coordinateSystem) === "M" &&
            getCharAt(($startX - 1) . "," . ($startY + 1), $coordinateSystem) === "S" &&
            getCharAt(($startX + 1) . "," . ($startY + 1), $coordinateSystem) === "M")
        ||
        (getCharAt(($startX - 1) . "," . ($startY - 1), $coordinateSystem) === "M" &&
            getCharAt(($startX + 1) . "," . ($startY - 1), $coordinateSystem) === "M" &&
            getCharAt(($startX - 1) . "," . ($startY + 1), $coordinateSystem) === "S" &&
            getCharAt(($startX + 1) . "," . ($startY + 1), $coordinateSystem) === "S")
    ) {
        $numberOfFoundXMAS += 1;
    }
}

$numberOfFoundXMAS = 0;
foreach ($coordinateSystem as $coord => $value) {
    if ($value === "X") {
        checkForMASAllDirections($coord, $coordinateSystem, $numberOfFoundXMAS);
    }
}
echo "Found XMAS/SAMX in Total (Part 1): $numberOfFoundXMAS\n";

$numberOfFoundXMAS = 0;
foreach ($coordinateSystem as $coord => $value) {
    if ($value === "A") {
        checkForMSTopAndBottomCorners($coord, $coordinateSystem, $numberOfFoundXMAS);
    }
}
echo "Found XMAS/SAMX in Total (Part 2): $numberOfFoundXMAS\n";
?>

import numpy

Del 2 var väldigt mycket mindre kod än del 1.... 

def day(data: list, debug=False):

    def get_valid_direction_indices(r, c):

        # Compute all possible indices of the letters in XMAS
        possible_directions = [r, c] - directions

        # Sort out all vectors which are outside the board
        boundary_1 = 0 <= possible_directions

        x_y_coordinates = numpy.moveaxis(possible_directions, 2, 0)
        boundary_2 = numpy.ones_like(x_y_coordinates, dtype=numpy.bool)
        boundary_2[0] = x_y_coordinates[0] < cols
        boundary_2[1] = x_y_coordinates[1] < rows
        boundary_2 = numpy.moveaxis(boundary_2, [0, 1], [2, 0])

        # Boolean operation AND
        boundaries = boundary_1 & boundary_2

        _valid_directions = list()

        for direction, boundary in zip(possible_directions, boundaries):

            if boundary.all():
                # if debug:
                #    print(f' Valid direction: \n{direction}')
                _valid_directions.append(direction)
            else:
                # if debug:
                #    print(f' Non valid direction:\n{direction} \n{boundary}')
                pass

        return _valid_directions

    # Get shape of input data
    rows = len(data)
    cols = len(data[0])

    # Create a word cloud
    word_cloud = numpy.zeros([rows, cols], dtype=numpy.str_)
    # Populate wordcloud
    for row_no, row in enumerate(data):
        word_cloud[row_no, :] = list(row)
    if debug:
        print(word_cloud)

    print(' --- Part 1')
    # Directions
    directions = numpy.array([[[0, 0], [-1, 0], [-2, 0], [-3, 0]],  # north
                              [[0, 0], [-1, 1], [-2, 2], [-3, 3]],  # north_east
                              [[0, 0], [0, 1], [0, 2], [0, 3]],  # east
                              [[0, 0], [1, 1], [2, 2], [3, 3]],  # south_east
                              [[0, 0], [1, 0], [2, 0], [3, 0]],  # south
                              [[0, 0], [1, -1], [2, -2], [3, -3]],  # south_west
                              [[0, 0], [0, -1], [0, -2], [0, -3]],  # west
                              [[0, 0], [-1, -1], [-2, -2], [-3, -3]]])  # north_west

    xmas_found = 0

    # Iterate over all positions
    for i in range(0, rows):
        for j in range(0, cols):

            # Sanity check the first letter to be an X
            if word_cloud[i, j] == 'X':
                valid_directions = get_valid_direction_indices(i, j)

                if debug:
                    print(f' i, k, valid directions: {i}, {j}, {len(valid_directions)}, {word_cloud[i, j]}')

                for valid_direction in valid_directions:
                    xmass = str()
                    for x, y in valid_direction:
                        xmass += (word_cloud[x, y])

                    # Check if we got XMAS
                    if xmass == 'XMAS':
                        xmas_found += 1

    print(' --- Part 2')
    x_mas_found = 0

    # Directions
    directions = numpy.array([[[-1, -1], [0, 0], [+1, +1], [+1, -1], [0, 0], [-1, +1]],
                              [[-1, -1], [0, 0], [+1, +1], [-1, +1], [0, 0], [+1, -1]],

                              [[+1, +1], [0, 0], [-1, -1], [+1, -1], [0, 0], [-1, +1]],
                              [[+1, +1], [0, 0], [-1, -1], [-1, +1], [0, 0], [+1, -1]]])

    wc = word_cloud
    # Iterate over all positions, this time skipp the edges
    for i in range(1, rows - 1):
        for j in range(1, cols - 1):

            # Sanity check the first letter to be an A
            if word_cloud[i, j] == 'A':
                for d in directions:
                    # Compute world cloud indices using relative directions
                    d = d + [i, j]
                    # Assemble potential x-mas
                    mas_1 = wc[d[0][0]][d[0][1]] + wc[d[1][0]][d[1][1]] + wc[d[2][0]][d[2][1]]
                    mas_2 = wc[d[3][0]][d[3][1]] + wc[d[4][0]][d[4][1]] + wc[d[5][0]][d[5][1]]

                    if mas_1 == mas_2 == "MAS":
                        x_mas_found += 1

    print(f' Part 1 XMAS found: {xmas_found}, Part 2 X-MASS found: {x_mas_found}')
    return xmas_found, x_mas_found

a = [l.strip() for l in open("input04.txt", "r").readlines()]

print(*[sum(f(x,y)
            for x in range(o, len(a) - o)
            for y in range(o, len(a[0]) - o)
            if a[x][y] == c)
        for f, c, o in [(lambda x, y:sum([(0 <= x+3*dx < len(a) and 
                                           0 <= y+3*dy < len(a[0]) and 
                                           "".join([a[x+i*dx][y+i*dy] for i in range(4)]) == "XMAS")
                                          for dx in range(-1, 2)
                                          for dy in range(-1, 2)]), "X", 0), 
                        (lambda x, y: ("".join([a[x-1][y-1], a[x-1][y+1], a[x+1][y-1], a[x+1][y+1]])
                                       in ["MMSS", "SSMM", "MSMS", "SMSM"]), "A", 1)]])