Inlägg

public static void Run()
{
    var scratchies = FileReader.ReadLines("Day4.txt")
        .Select(x =>
        {
            var idAndGameDetails = x.Split(":", StringSplitOptions.RemoveEmptyEntries);
            var id = int.Parse(idAndGameDetails[0].Split(" ", StringSplitOptions.RemoveEmptyEntries)[1]);

            var numbers = idAndGameDetails[1].Split("|", StringSplitOptions.TrimEntries);

            var winningNumbers = numbers[0].Split(" ", StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)).ToList();
            var scratchyNumbers = numbers[1].Split(" ", StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)).ToList();

            return new Scratchy(id, winningNumbers, scratchyNumbers);
        }).ToList();


    var part1Res = scratchies.Select(x =>
    {
        var numOfIntersection = x.WinningNumbers.Intersect(x.ScratchysNumbers).Count();

        return numOfIntersection > 1 ? Math.Floor(Math.Pow(2, numOfIntersection-1)) : numOfIntersection;
    }).Sum();

    Console.WriteLine(part1Res);

    for (int i = 0; i < scratchies.Count; i++)
    {
        var scratchy = scratchies[i];

        for (int j = 0; j < scratchy.Instances; j++)
        {
            var numOfIntersection =  scratchy.WinningNumbers.Intersect(scratchy.ScratchysNumbers).Count();

            var lastIndex = numOfIntersection <= scratchies.Count - 1 ? numOfIntersection + i + 1 : scratchies.Count - 1;

            for (int k = i + 1; k < lastIndex; k++)
            {
                var scratchyCopy = scratchies[k] with { Instances = scratchies[k].Instances + 1 };
                scratchies[k] = scratchyCopy;
            }
        }
    }

    Console.WriteLine(scratchies.Sum(x => x.Instances));

}

internal record Scratchy(int Id, IReadOnlyList<int> WinningNumbers, IReadOnlyList<int> ScratchysNumbers, int Instances = 1);

    var day1Res = FileReader.ReadLines("Day1.txt")
        .Select(x =>
        {
            var first = x.ToCharArray().First(possibleNum => char.IsNumber(possibleNum));
            var last = x.ToCharArray().Last(possibleNum => char.IsNumber(possibleNum));

            return char.GetNumericValue(first) * 10 + char.GetNumericValue(last);
        }).Sum();
    Console.WriteLine(day1Res);

    var day1Res2 = FileReader.ReadLines("Day1.txt")
        .Select(x =>
        {
            var firstIndex = int.MaxValue;
            var firstValue = 0;
            var secondIndex = int.MinValue;
            var secondValue = 0;
            foreach (var item in numToInt)
            {
                var indexOfFirstKey = x.IndexOf(item.Key);
                if (indexOfFirstKey >= 0 && indexOfFirstKey < firstIndex)
                {
                    firstIndex = indexOfFirstKey;
                    firstValue = item.Value;
                }

                var indexOfSecondKey = x.LastIndexOf(item.Key);
                if (indexOfSecondKey >= 0 && indexOfSecondKey > secondIndex)
                {
                    secondIndex = indexOfSecondKey;
                    secondValue = item.Value;
                }
            }
           
            return firstValue*10 + secondValue;
        }).Sum();

    Console.WriteLine(day1Res2);
}

        public static void Run()
    {
        var games = FileReader.ReadLines("Day2.txt")
            .Select(GameMaker)
            .ToList();

       var day1Res = games.Where(x => x.Possible).Select(x => x.Id).Sum();
       Console.WriteLine(day1Res);

       var day2Res = games.Select(x => x.Blue * x.Red * x.Green).Sum();
       Console.WriteLine(day2Res);
        
    }

    private static Game GameMaker(string input)
    {
        var idAndCubesSeparation = input.Split(":", StringSplitOptions.RemoveEmptyEntries);

        string id = idAndCubesSeparation[0].Split(" ")[1];

        var game = new Game(int.Parse(id));

        var gameSections = idAndCubesSeparation[1].Split(";", StringSplitOptions.RemoveEmptyEntries);

        foreach (var section in gameSections)
        {
            var sectionColorParts = section.Split(",", StringSplitOptions.RemoveEmptyEntries);

            foreach (var colorPart in sectionColorParts)
            {
                var numCubesAndColor = colorPart.Split(" ", StringSplitOptions.RemoveEmptyEntries);

                var num = int.Parse(numCubesAndColor[0]);

                var color = numCubesAndColor[1];

                //if Possible has been set to false, it will stay false, otherwise do the value check
                game = (color) switch
                {
                    "blue" => game with { Possible = !game.Possible ? game.Possible : num <= Game.BLUE_LIMIT, Blue = int.Max(game.Blue, num) },
                    "red" => game with { Possible = !game.Possible ? game.Possible : num <= Game.RED_LIMIT, Red = int.Max(game.Red, num) },
                    "green" => game with { Possible = !game.Possible ? game.Possible : num <= Game.GREEN_LIMIT, Green = int.Max(game.Green, num) },
                    _ => game
                };
            }

        }
        
        return game;
    }

    private record Game(int Id, int Blue = 0, int Red = 0, int Green = 0, bool Possible = true)
    {
        internal const int BLUE_LIMIT = 14;
        internal const int RED_LIMIT = 12;
        internal const int GREEN_LIMIT = 13;
    }

           public static void Run()
    {
        var lines = FileReader.ReadLines("Day3.txt");

        var lineDetails = lines
            .Select((line, index) =>
            {
                List<Gear> gears = [];
                List<LineNumber> lineNumbers = [];
                string currNumber = "";

                for (int i = 0; i < line.Length; i++)
                {
                    var currChar = line[i];

                    if (currChar == '*')
                    {
                        gears.Add(new Gear(i, []));
                    }

                    if (!char.IsNumber(currChar))
                    {
                        if (currNumber != "")
                        {
                            lineNumbers.Add(new LineNumber(int.Parse(currNumber), i - currNumber.Length, i));
                            currNumber = "";
                        }
                    }
                    else
                    {
                        currNumber += currChar;
                    }
                }

                if (currNumber != "")
                {
                    lineNumbers.Add(new LineNumber(int.Parse(currNumber), line.Length - currNumber.Length, line.Length));
                }



                return new LineDetails(line, index, index == 0, index == lines.Length - 1, lineNumbers, gears);
            })
            .ToList();

        lineDetails.ForEach(ld => ld.Numbers.ForEach(ln => ln.CheckSurrounding(ld, lineDetails)));

        var part1Res = lineDetails.SelectMany(ld =>
        {
            return ld.Numbers.Where(ldn => ldn.SymbolSurrounded);
        }).Sum(x => x.Number);

        var part2Res = lineDetails
            .SelectMany(ld => ld.Gears)
            .Where(x => x.Numbers.Count == 2)
            .Select(x => x.Numbers.Aggregate((a, b) => a * b))
            .Sum();


        Console.WriteLine(part1Res);
        Console.WriteLine(part2Res);
    }


    internal record LineDetails(string Line, int Index, bool IsTop, bool IsBottom, List<LineNumber> Numbers, List<Gear> Gears);

    internal class LineNumber()
    {
        public int Number { get; init; }
        public int StartIndex { get; init; }
        public int EndIndex { get; init; }
        public bool SymbolSurrounded { get; set; }


        readonly Func<char, bool> _isSymbol = (char c) => (!char.IsNumber(c) && c != '.');
        readonly Func<char, bool> _isGear = (char c) => (c == '*');

        public LineNumber(int number, int startIndex, int endIndex, bool symbolSurrounded = false) : this()
        {
            Number = number;
            StartIndex = startIndex;
            EndIndex = endIndex;
            SymbolSurrounded = symbolSurrounded;
        }

        public void CheckSurrounding(LineDetails ld, List<LineDetails> allLines)
        {
            bool addedTopAlready = false;
            bool addedBottomAlready = false;
            for (int i = StartIndex; i < EndIndex; i++)
            {
                if (!ld.IsTop)
                {
                    var lineDescriptionAbove = allLines[ld.Index - 1];

                    var upperleftIndex = i > 0 ? i - 1 : -1;
                    var upperRightIndex = i < ld.Line.Length - 1 ? i + 1 : -1;

                    if (upperleftIndex > 0)
                    {
                        if (_isGear(lineDescriptionAbove.Line[upperleftIndex]) && !addedTopAlready)
                        {
                            lineDescriptionAbove.Gears.First(x => x.Index == upperleftIndex).Numbers.Add(Number);
                            addedTopAlready = true;
                        }
                        if (!SymbolSurrounded && _isSymbol(lineDescriptionAbove.Line[upperleftIndex])) this.SymbolSurrounded = true;
                    }


                    if (_isGear(lineDescriptionAbove.Line[i]) && !addedTopAlready)
                    {
                        lineDescriptionAbove.Gears.First(x => x.Index == i).Numbers.Add(Number);
                        addedTopAlready = true;
                    }
                    if (!SymbolSurrounded && _isSymbol(lineDescriptionAbove.Line[i])) this.SymbolSurrounded = true;

                    if (upperRightIndex > 0)
                    {
                        if (_isGear(lineDescriptionAbove.Line[upperRightIndex]) && !addedTopAlready)
                        {
                            lineDescriptionAbove.Gears.First(x => x.Index == upperRightIndex).Numbers.Add(Number);
                            addedTopAlready = true;
                        }
                        if (!SymbolSurrounded && _isSymbol(lineDescriptionAbove.Line[upperRightIndex])) this.SymbolSurrounded = true;
                    }

                }

                if (!ld.IsBottom)
                {
                    var lineDescriptionBelow = allLines[ld.Index + 1];

                    var lowerleftIndex = i > 0 ? i - 1 : -1;
                    var lowerRightIndex = i < ld.Line.Length - 1 ? i + 1 : -1;

                    if (lowerleftIndex > 0)
                    {
                        if (_isGear(lineDescriptionBelow.Line[lowerleftIndex]) && !addedBottomAlready)
                        {
                            lineDescriptionBelow.Gears.First(x => x.Index == lowerleftIndex).Numbers.Add(Number);
                            addedBottomAlready = true;
                        }
                        if (!SymbolSurrounded && _isSymbol(lineDescriptionBelow.Line[lowerleftIndex])) this.SymbolSurrounded = true;
                    }

                    if (_isGear(lineDescriptionBelow.Line[i]) && !addedBottomAlready)
                    {
                        lineDescriptionBelow.Gears.First(x => x.Index == i).Numbers.Add(Number);
                        addedBottomAlready = true;
                    }
                    if (!SymbolSurrounded && _isSymbol(lineDescriptionBelow.Line[i])) this.SymbolSurrounded = true;


                    if (lowerRightIndex > 0)
                    {
                        if (_isGear(lineDescriptionBelow.Line[lowerRightIndex]) && !addedBottomAlready)
                        {
                            lineDescriptionBelow.Gears.First(x => x.Index == lowerRightIndex).Numbers.Add(Number);
                            addedBottomAlready = true;
                        }
                        if (!SymbolSurrounded && _isSymbol(lineDescriptionBelow.Line[lowerRightIndex])) this.SymbolSurrounded = true;
                    }
                }

                if (i > 0)
                {
                    if (_isGear(ld.Line[i - 1])) ld.Gears.First(x => x.Index == i - 1).Numbers.Add(Number);
                    if (!SymbolSurrounded && _isSymbol(ld.Line[i-1])) this.SymbolSurrounded = true;
                }

                if (i < ld.Line.Length - 1)
                {
                    if (_isGear(ld.Line[i + 1])) ld.Gears.First(x => x.Index == i+1).Numbers.Add(Number);
                    if (!SymbolSurrounded && _isSymbol(ld.Line[i + 1])) this.SymbolSurrounded = true;
                }
            }


        }
    }

    internal record Gear(int Index, List<int> Numbers);

class Day7 {

    fun run() {
        val input = java.io.File("src/input/day7.txt").readLines();

        val fileStructure = addChildren(input)
        var root = fileStructure

        while (root?.parentDirectory != null) {
            root = root?.parentDirectory
        }
        val part1Answer = root!!.part1()
        val part2Answer = root!!.part2(30000000).minByOrNull { it.totalSize }!!
        println(part1Answer)
        println(part2Answer.totalSize)

        println(root!!.part1test())
    }




    private tailrec fun addChildren(instructions: List<String>, currentDirectory: Directory? = null): Directory? {
        if (instructions.isEmpty()) {
            return currentDirectory

        }

        val instruction = instructions.first()
        when {
            instruction.startsWith("dir ") -> {
                val directoryName = instruction.split(" ")[1]
                val newDirectory = Directory(currentDirectory, mutableListOf(), mutableListOf(), directoryName)
                currentDirectory?.subDirectories?.add(newDirectory)
                return addChildren(instructions.drop(1), currentDirectory)
            }

            instruction.split(" ")[0].all { it.isDigit() } -> {
                val fileParts = instruction.split(" ")
                val newFile = File(currentDirectory!!, fileParts[1], fileParts[0].toInt())
                currentDirectory?.files?.add(newFile)
                return addChildren(instructions.drop(1), currentDirectory)
            }

            instruction == "$ ls" -> return addChildren(instructions.drop(1), currentDirectory)
            instruction.startsWith("$ cd") -> {
                val targetDirectory = instruction.split(" ")[2]
                if (targetDirectory == "/") {
                    return addChildren(
                        instructions.drop(1),
                        Directory(null, mutableListOf(), mutableListOf(), targetDirectory)
                    )
                }
                if (targetDirectory == "..") {
                    return addChildren(instructions.drop(1), currentDirectory?.parentDirectory)
                }
                return addChildren(
                    instructions.drop(1),
                    currentDirectory?.subDirectories?.find { it.name == targetDirectory })
            }

        }

        throw IllegalArgumentException("nu blev det tokigt igen")
    }


    class Directory(
        val parentDirectory: Directory?,
        val subDirectories: MutableList<Directory>,
        val files: MutableList<File>,
        val name: String
    ) {

        val totalSize: Int by lazy {
            files.sumOf { it.size } + this.subDirectories.sumOf { it.totalSize }
        }

        fun part1(): Int {
            val size = if (totalSize < 100000) totalSize else 0
            return size + this.subDirectories.sumOf { it.part1() }
        }

        fun part1test(): Int {
            println(this.name + ": " + this.totalSize)
            return totalSize + this.subDirectories.sumOf { it.part1test() }
        }

        fun part2(
            targetFreeSpace: Int,
            currentFreeSpace: Int = 70000000 - this.totalSize,
            directoriesForDelete: MutableList<Directory> = mutableListOf()
        ): List<Directory> {
            if (currentFreeSpace + this.totalSize >= targetFreeSpace) {
                directoriesForDelete.add(this)
            }
            for (childDirectory in this.subDirectories) {
                childDirectory.part2(targetFreeSpace, currentFreeSpace, directoriesForDelete)
            }
            return directoriesForDelete
        }
    }

    class File(val parentDirectory: Directory, val name: String, val size: Int)
}

class Day8 {

    fun run(){
        //val input = "30373\n25512\n65332\n33549\n35390".split("\n")
        val input = File("src/input/day8.txt").readLines();
        val allTrees: List<List<Tree>> = input.mapIndexed { y, treeLine ->
            val trees = treeLine.split("").subList(1, treeLine.length+1)
            trees.mapIndexed { x, tree ->
                Tree(x, y, tree.toInt())
             }
         }
        val forest = Forest(allTrees)

        println(forest.treesVisibleFromAnywhere)
        println(forest.highestScenicValue)
    }

}

class Forest(val trees: List<List<Tree>>)
{
    val treesVisibleFromAnywhere: Int by lazy {
        var visibleTrees = 0
        for (y in trees.indices)
        {
            for(x in trees[0].indices)
            {
                val currentTree = trees[y][x]
                val treeLineHorizontal = trees[y]
                val treeLineVertical = getVerticalTreeLine(x)
                val hasAnyHeigherLeft = treeLineHorizontal.filter { it != currentTree && it.x < currentTree.x }.all { it.height < currentTree.height }
                val hasAnyHeigheRight = treeLineHorizontal.filter { it != currentTree && it.x > currentTree.x }.all { it.height < currentTree.height }
                val hasAnyHeigherAbove = treeLineVertical.filter { it != currentTree && it.y < currentTree.y }.all { it.height < currentTree.height }
                val hasAnyHeigherBelow = treeLineVertical.filter { it != currentTree && it.y > currentTree.y }.all { it.height < currentTree.height }

                visibleTrees += when{
                    y == 0 || y == trees.size-1 -> 1
                    x == 0 || x == trees[0].size-1 -> 1
                   hasAnyHeigherLeft || hasAnyHeigheRight -> 1
                    hasAnyHeigherAbove || hasAnyHeigherBelow -> 1
                    else -> 0
                }
            }
        }
        visibleTrees
    }

    val highestScenicValue: Int get(){
        var highestScore = 0
        val treeCounter = {treesToCount: List<Tree>, treeCountDirection: TreeCountDirection, currentTree: Tree ->

            val treesOnSpecifiedSide = when(treeCountDirection){
                TreeCountDirection.LEFT -> treesToCount.filter { it != currentTree && it.x < currentTree.x}.reversed()
                TreeCountDirection.RIGHT -> treesToCount.filter { it != currentTree && it.x > currentTree.x }
                TreeCountDirection.UP -> treesToCount.filter { it != currentTree && it.y < currentTree.y }.reversed()
                TreeCountDirection.DOWN -> treesToCount.filter { it != currentTree && it.y > currentTree.y }
            }.takeWhile { it.height < currentTree.height }

            treesOnSpecifiedSide.count() + when(treeCountDirection){
                TreeCountDirection.LEFT -> if (treesOnSpecifiedSide.lastOrNull()?.x != 0) 1 else 0
                TreeCountDirection.RIGHT -> if (treesOnSpecifiedSide.lastOrNull()?.x != treesToCount.size-1) 1 else 0
                TreeCountDirection.UP -> if (treesOnSpecifiedSide.lastOrNull()?.y != 0) 1 else 0
                TreeCountDirection.DOWN -> if (treesOnSpecifiedSide.lastOrNull()?.y != trees.size-1) 1 else 0
            }
        }
        for (y in 1 .. trees.size - 2)
        {
            for(x in 1 .. trees[0].size - 2)
            {
                val currentTree = trees[y][x]
                val treeLineHorizontal = trees[y]
                val treeLineVertical = getVerticalTreeLine(x)

                val scoreLeft = treeCounter(treeLineHorizontal, TreeCountDirection.LEFT, currentTree)
                val scoreRight = treeCounter(treeLineHorizontal, TreeCountDirection.RIGHT, currentTree)
                val scoreAbove = treeCounter(treeLineVertical, TreeCountDirection.UP, currentTree)
                val scoreBelow = treeCounter(treeLineVertical, TreeCountDirection.DOWN, currentTree)

                val score = scoreLeft*scoreRight*scoreAbove*scoreBelow
                if(score > highestScore)
                {
                    highestScore = score
                }
            }
        }
        return highestScore

    }

    private fun getVerticalTreeLine(x: Int): List<Tree>
    {
        var verticalTrees: MutableList<Tree> = mutableListOf()
        for(treeLine in trees)
        {
            verticalTrees.add(treeLine[x])
        }
        return verticalTrees.toList()
    }
}

data class Tree(val x: Int, val y: Int, val height: Int)

enum class TreeCountDirection{
    LEFT, RIGHT, UP, DOWN
}

class Day9 {

    fun run() {

        val input = File("src/input/day9.txt").readLines()

        val moves = input.map {
            val moveParts = it.trim().split(" ")
            val moveDirection = when (moveParts[0]) {
                "U" -> MoveCommand.Direction.UP
                "D" -> MoveCommand.Direction.DOWN
                "L" -> MoveCommand.Direction.LEFT
                "R" -> MoveCommand.Direction.RIGHT
                else -> throw IllegalArgumentException()
            }
            MoveCommand(moveDirection, moveParts[1].toInt())
        }


        println(Knots(2).moveAround(moves))
        println(Knots(10).moveAround(moves))
    }


}


class MoveCommand(val direction: Direction, val totalSteps: Int) {
    val isVertical: Boolean by lazy { direction == Direction.UP || direction == Direction.DOWN }

    enum class Direction(val step: Int) {
        UP(1), DOWN(-1), LEFT(-1), RIGHT(1)
    }
}

data class Knot(var current: Point, val isHead: Boolean = false)

class Knots(numberOfKnots: Int){
    private val allKnots: LinkedList<Knot> = LinkedList()

    init {
        val head = Knot(Point(0, 0), true)
        allKnots.addFirst(head)
        IntRange(1, numberOfKnots-1).forEach { _ -> allKnots.add(Knot(Point(0,0))) }
    }

    fun moveAround(commands: List<MoveCommand>): Int {
        val uniqueLocations: MutableSet<Pair<Int, Int>> = mutableSetOf(Pair(0, 0))
        commands.forEach {command ->
            for (step in 0 until command.totalSteps) {
                allKnots.forEachIndexed{knotIndex, knot ->
                    if(knot.isHead)
                    {
                        moveHead(knot, command)
                    }
                    else
                    {
                        val lastKnot = allKnots[knotIndex-1]
                        moveTailPart(knot, lastKnot)
                    }
                }
                val tailCurrentLocation = Pair(allKnots.last.current.x, allKnots.last.current.y)
                uniqueLocations.add(tailCurrentLocation)
            }

        }
        return uniqueLocations.size
    }

    companion object {
        private fun moveHead(head: Knot, command: MoveCommand) =
            if (command.isVertical)
                head.current.move(head.current.x, head.current.y + command.direction.step)
            else
                head.current.move(head.current.x + command.direction.step, head.current.y)

        private fun moveTailPart(tailPart: Knot, lastPart: Knot){
            val currentPoint = tailPart.current
            val lastPoint = lastPart.current
            if(currentPoint.distance(lastPoint) == 2.0)
            {
                val newX = (lastPoint.x + currentPoint.x) / 2
                val newY = (lastPoint.y + currentPoint.y) / 2
                currentPoint.move(newX, newY)
            }
            else if (currentPoint.distance(lastPoint) > 2.0)
            {
                val newX = when{
                    lastPoint.x > currentPoint.x -> currentPoint.x+1
                    lastPoint.x < currentPoint.x -> currentPoint.x-1
                    else -> currentPoint.x
                }
                val newY = when{
                    lastPoint.y > currentPoint.y -> currentPoint.y+1
                    lastPoint.y < currentPoint.y -> currentPoint.y-1
                    else -> currentPoint.y
                }
                currentPoint.move(newX, newY)
            }
        }
    }

}

class Day10 {

    fun run()
    {
        val input = File("src/input/day10.txt").readLines()

        val display = Display(input)
        println(display.runInstructions())
        println(display.part2Sb.toString())
    }
}

class Display(private val instructions: List<String>){
    private var x: Int = 1
    val part2Sb: StringBuilder = java.lang.StringBuilder()
    private var cycleNumber: Int by Delegates.observable(0){prop, oldValue, newValue ->
        if(newValue % 20 == 0 && newValue % 40 != 0)
        {
            signalStrengths.add(x*newValue)
        }
        val currentPositionOnRow = (newValue - 1) % 40
        val spriteIsInView = currentPositionOnRow == x-1 || currentPositionOnRow == x || currentPositionOnRow == x+1

        if (spriteIsInView) part2Sb.append("#") else part2Sb.append(".")
        if(currentPositionOnRow == 39)
        {
            part2Sb.append("\n")
        }
    }
    private val signalStrengths: MutableList<Int> = mutableListOf()

    fun runInstructions(): Int
    {
        for ( instruction in instructions)
        {
            when{
                instruction == "noop" -> cycleNumber++
                instruction.startsWith("addx") -> {
                    val value = instruction.split(" ")[1].toInt()
                    repeat(2){cycleNumber++}
                    x += value
                }
            }
        }
        return signalStrengths.sum()
    }
}