@Test
    void countIfNextMeasurementIncreased() {
        assertEquals(7, SonarSweep.countIfNextMeasurementIncreased([199, 200,208,210,200,207,240,269,260,263]))
    }

    static int countIfNextMeasurementIncreased(List<Integer> input) {
        int counter = 0
        for (int i = 0; i < input.size() - 1; i++) {
            counter += count(input[i], input[i+1])
        }
        counter
    }
    static int count(int a, b) {
        b > a ? 1 : 0
    }

        def collect = new File('input.txt').text.split('\n').collect { Integer::valueOf(it) }
        println "Part1 solution: ${countIfNextMeasurementIncreased(collect)}"

    @Test
    void countThreeMeasurementSlidingWindow() {
        assertEquals(5, SonarSweep.countThreeMeasurementSlidingWindow([199, 200,208,210,200,207,240,269,260,263]))
    }

    static int countThreeMeasurementSlidingWindow(List<Integer> input) {
        int counter = 0
        for (int i = 0; i < input.size() - 3; i++) {
            int sum1 = input.subList(i, i +3).sum(0) as int
            int sum2 = input.subList(i+1, i +4).sum(0) as int
            counter += count(sum1, sum2)
        }
        counter
    }
    static int count(int a, b) {
        b > a ? 1 : 0
    }

        def collect = new File('input.txt').text.split('\n').collect { Integer::valueOf(it) }
        println "Part2 solution: ${countThreeMeasurementSlidingWindow(collect)}"

    @Test
    void part1() {
        assertEquals(150, Navigation.calculateFinalPositionValue(["forward 5", "down 5", "forward 8", "up 3", "down 8", "forward 2"]))
    }

    enum Course {
        DOWN, FORWARD, UP
    }
    static int calculateFinalPositionValue(def plannedCourse = String[]) {
        int horizontalPosition = 0
        int depth = 0

        plannedCourse.each { String plannedStep ->
            def (direction, sValue) = plannedStep.tokenize(" ")
            int speed = Integer.valueOf(sValue)
            switch (Course.valueOf(direction.toUpperCase())) {
                case Course.FORWARD: {
                    horizontalPosition += speed
                    break
                }
                case Course.UP: {
                    depth -= speed
                    break
                }
                case Course.DOWN: {
                    depth += speed
                    break
                }
            }
        }
        return horizontalPosition * depth
    }

        def lines = new File("input.txt").readLines()
        println "Day2 part 1 solution: ${calculateFinalPositionValue(lines)}"

    @Test
    void part2() {
        assertEquals(900, Navigation.calculateFinalPositionValueWithAIM(["forward 5", "down 5", "forward 8", "up 3", "down 8", "forward 2"]))
    }

    enum Course {
        DOWN, FORWARD, UP
    }
    static int calculateFinalPositionValueWithAIM(def plannedCourse = String[]) {
        int horizontalPosition = 0
        int depth = 0
        int aim = 0

        plannedCourse.each { String plannedStep ->
            def (direction, sValue) = plannedStep.tokenize(" ")
            int speed = Integer.valueOf(sValue)
            switch (Course.valueOf(direction.toUpperCase())) {
                case Course.FORWARD: {
                    horizontalPosition += speed
                    depth += (aim * speed)
                    break
                }
                case Course.UP: {
                    aim -= speed
                    break
                }
                case Course.DOWN: {
                    aim += speed
                }
            }
        }

        println "${horizontalPosition}, ${depth}, ${aim}"


        return horizontalPosition * depth

    }

        def lines = new File("input.txt").readLines()
        println "Day2 part 2 solution: ${calculateFinalPositionValueWithAIM(lines)}"

    @Test
    void calculatePowerConsumption() {
        assertEquals(198, BinaryDiagnostic.calculatePowerConsumption(["00100", "11110", "10110", "10111", "10101", "01111", "00111", "11100", "10000", "11001", "00010", "01010"]))
    }

    static int calculatePowerConsumption(List<String> diagnosticReport) {

        def gammaBinary = ""
        def epsilonBinary = ""
        def tempValue = 0
        def length = diagnosticReport[0].length()
        int half = diagnosticReport.size() / 2

        for (int position = 0; position < length; position++) {
            tempValue = 0
            diagnosticReport.each { String it ->
                tempValue += Integer.parseInt(it[position])
            }
            gammaBinary += tempValue > half ? "1" : "0"
            epsilonBinary += tempValue > half ? "0" : "1"
        }
        println gammaBinary
        println epsilonBinary

        return Integer.parseInt(gammaBinary, 2) * Integer.parseInt(epsilonBinary, 2)
    }

    static void main(String[] args) {
        println "Day3 power consumption rating: ${calculatePowerConsumption(new File("input.txt").readLines())}"
    }

class BingoBoard {

    static class Field {
        int value
        boolean marked

        private Field(int value) {
            this.value = value
            this.marked = false
        }

        static Field of(int value) {
            return new Field(value)
        }

        String toString() {
            return (marked ? "X" : "${value}").padLeft(2, " ")
        }
    }

    List<Field> fields


    static BingoBoard init(String[] boardLayout) {
        def fields = boardLayout.collect { it.split(" ").findAll { it.trim() }.collect { Field.of(it.trim() as int) } }.flatten()
        return new BingoBoard(fields)
    }

    private BingoBoard(def fields) {
        this.fields = fields
    }

    boolean isWins() {
        // check rows
        def match = false
        int i = 0
        do {
            // check line
            match |= fields.subList(i * 5, 5 * i + 5).every { it.marked }
            // check row
            match |= fields.collate(5).every { it[i].marked }
            i++
        } while (!match && i < 5)
        return match
    }

    int sumOfAllUnmarkedNumbers() {
        def sum = fields.findAll { !it.marked }.collect { it.value as int }.sum(0)
        return sum as int
    }

    boolean markNumber(int value) {
        // search field with this number
        def field = fields.find { it.value == value }
        if (field) {
            field.marked = true
            return wins
        } else {
            return false
        }
    }

    String toString() {
        return fields.collect { it.toString() }.collate(5).collect {it.join(" ")}.join("\n")
    }


}

    static GiantSquid initGame(File puzzleInputFile) {
        def allLines = puzzleInputFile.readLines().findAll { String it -> it?.trim() }
        int[] randomNumbers = allLines.remove(0).split(",").collect{it as int}
        def boards = allLines.collate(5).collect { it.join(" " ) }.collect { BingoBoard.init(it) }
        return new GiantSquid(boards, randomNumbers)
    }

    int playBingoAndReturnFinalScoreFromWinningBoard() {
        int finalScore = -1
        int randomNumbersIndex = 0
        do {
            for (int j = 0; j < boards.size(); j++) {
                if (boards[j].markNumber(randomNumbers[randomNumbersIndex])) {
                    finalScore = randomNumbers[randomNumbersIndex] * boards[j].sumOfAllUnmarkedNumbers()
                    break
                }
            }
            randomNumbersIndex++
        } while (finalScore == -1 && randomNumbersIndex < randomNumbers.size())
        return finalScore
    }

    int playBingoAndLetGiantSquidWins() {
        int finalScore = -1
        int randomNumbersIndex = 0
        int lastNumber = -1
        BingoBoard lastBoard = null
        do {
            lastNumber = randomNumbers[randomNumbersIndex]
            boards.each {it.markNumber(lastNumber)}
            lastBoard = boards.find {it.wins}
            boards.removeAll {it.wins }
            randomNumbersIndex++
        } while (boards.size() > 0 && randomNumbersIndex < randomNumbers.size())
        return lastBoard.sumOfAllUnmarkedNumbers() * lastNumber
    }

package io.uniqueck.aoc.day5

import java.util.stream.IntStream

class Coord {

    int x, y

    static Coord of(String stringRepresentation) {
        def (tempX, tempY) = stringRepresentation.tokenize(",")
        new Coord(tempX as int, tempY as int)
    }

    Coord(int x, y) {
        this.x = x
        this.y = y
    }

    boolean isOnSameRowOrColumn(Coord target) {
        return x == target.x || y == target.y
    }


    List<Coord> createListOfCoordsToConnectTo(Coord target) {

        List<Coord> listOfCoords = []
        // diagonal
        int stepSizeX = target.x - x < 0 ? -1 : target.x - x == 0 ? 0 : 1
        int stepSizeY = target.y - y < 0 ? -1 : target.y - y == 0 ? 0 : 1

        int stepX = x
        int stepY = y

        while (!(stepX == target.x && stepY == target.y)) {
            listOfCoords << new Coord(stepX, stepY)
            stepX += stepSizeX
            stepY += stepSizeY
        }
        listOfCoords << target

        return listOfCoords
    }

    boolean equals(o) {
        if (this.is(o)) return true
        if (getClass() != o.class) return false

        Coord coord = (Coord) o

        if (x != coord.x) return false
        if (y != coord.y) return false

        return true
    }

    int hashCode() {
        int result
        result = x
        result = 31 * result + y
        return result
    }

    String toString() {
        return "(${x},${y})"
    }

}

package io.uniqueck.aoc.day5

class Line {

    Coord start, end

    // converts 1,2 -> 3,2 to a line with start coordinate 1,2 and end coordinate 3,2
    static Line of(String stringRepresentation) {
        def (tempStart, tempEnd) = stringRepresentation.tokenize("->")
        return new Line(Coord.of(tempStart), Coord.of(tempEnd))
    }

    Line(Coord start, end) {
        this.start = start
        this.end = end
    }

    boolean isStartAndEndOnSameRowOrColumn() {
        return start.isOnSameRowOrColumn(end)
    }

    List<Coord> getListOfCoordsFromStartToEnd() {
        return start.createListOfCoordsToConnectTo(end)
    }



}

package io.uniqueck.aoc.day5

class HydrothermalVenture {

    static void main(String[] args) {
        def lines = new File("src/main/resources/day5/input.txt").readLines()
        new HydrothermalVenture().process(lines)
    }

    void process(List<String> input) {
        def lines = input.collect {Line.of(it)}
        println "HydrothermalVenture only horizontal and vertical lines: ${countHowManyPointsAreOverlappingFromMoreThenOnLine(lines.findAll {it.startAndEndOnSameRowOrColumn})}"
        println "HydrothermalVenture all type of lines: ${countHowManyPointsAreOverlappingFromMoreThenOnLine(lines)}"
    }

    @SuppressWarnings('GrMethodMayBeStatic')
    int countHowManyPointsAreOverlappingFromMoreThenOnLine(List<Line> lines) {
        int[][] result = new int[999][999]
        lines.collect { it.listOfCoordsFromStartToEnd}.flatten().each { Coord it ->
            result[it.y][it.x]++
        }
        ((List<List<Integer>>)result).flatten().findAll{it > 1}.size()
    }
}

class Simulator {

    static void main(String[] args) {
        def countBy = new File("input.txt").readLines().collect { it.split(",") }.flatten().collect { it as int }.countBy { it }
        long[] initialStock = [0,0,0,0,0,0,0,0,0]
        countBy.each {initialStock[it.key] += it.value}
        println initialStock
        println "Star1: ${countLanternFishesAfterDays(initialStock, 80)}"
        println "Star2: ${countLanternFishesAfterDays(initialStock, 256)}"
    }

    static long countLanternFishesAfterDays(long[] initialStock, int afterDays, int currentDay = 1) {
        println "Day: ${currentDay} - ${initialStock}"
        long[] newFishes = [0,0,0,0,0,0,0,0,0]
        initialStock.eachWithIndex { long count, int index ->
            if (index > 0) {
                newFishes[index - 1] += count
            } else {
                newFishes[6] += count
                newFishes[8] += count
            }
        }
        if (currentDay < afterDays) {
            return countLanternFishesAfterDays(newFishes, afterDays, currentDay + 1)
        } else {
            return newFishes.sum()
        }
    }



}

    static int star1(File input) {
        int counter = 0
        input.readLines().each { String line ->
            println line
            def (uniqueSignalPatterns, fourDigitOutputValue) = line.tokenize("|")
            List<String> uniqueSignalPatternsList = uniqueSignalPatterns.tokenize(" ")
            println uniqueSignalPatternsList
            List<String> fourDigitOutputValueList = fourDigitOutputValue.tokenize(" ")
            println fourDigitOutputValueList

            fourDigitOutputValueList.findAll { [2, 3, 4, 7].contains(it.size()) }.each {
                counter += createCombinations(it).findAll {
                    uniqueSignalPatternsList.contains(it)
                }.size()
            }
        }
        return counter
    }

    static int star2(File input) {

        int sum = 0
        input.readLines().each { String line ->
            def (uniqueSignalPatterns, fourDigitOutputValue) = line.tokenize("|")

            println "UniqueSignalPatterns: ${uniqueSignalPatterns}"
            println "FourDigitOutputValue: ${fourDigitOutputValue}"

            def signalsForDigit = [:] as Map<Integer, String>
            def notDeterminedSignals = [] as List<String>
            uniqueSignalPatterns.trim().split(" ").collect { it.split("").sort().join() }.groupBy { it.size() }.each {

                switch (it.key) {
                    case 2: {
                        signalsForDigit[1] = it.value[0]
                        break
                    }
                    case 4: {
                        signalsForDigit[4] = it.value[0]
                        break
                    }
                    case 3: {
                        signalsForDigit[7] = it.value[0]
                        break
                    }
                    case 7: {
                        signalsForDigit[8] = it.value[0]
                        break
                    }
                    default: {
                        notDeterminedSignals += it.value
                    }
                }
            }

            println "determined signals after unique signals - start"
            println "determined signals: $signalsForDigit"
            println "not determined signals: $notDeterminedSignals"
            println "determined signals after unique signals - end"

            while (notDeterminedSignals) {
                notDeterminedSignals.each { String notDetermined ->
                    switch (notDetermined.size()) {
                        case 5: {
                            // check if already determined 1 is part of pattern, so we found the 3
                            if (notDetermined.contains(signalsForDigit[1][0]) && notDetermined.contains(signalsForDigit[1][1])) {
                                signalsForDigit[3] = notDetermined
                            } else
                            // if already determined 6 and 9, we can determined together with the 1 the last to remaining
                            if (signalsForDigit[6] && signalsForDigit[9] && signalsForDigit[1]) {

                                // check which bit from 1 is not part of 6
                                println signalsForDigit[6]
                                println signalsForDigit[1][0]
                                println signalsForDigit[1][1]
                                String signalForDigit6 = signalsForDigit[6]
                                String bit = signalForDigit6.contains(signalsForDigit[1][0]) ? signalsForDigit[1][1] : signalsForDigit[1][0]
                                println "Bit ${bit} is not part of 6"
                                // remove these bit from 9 and compare it with the current undetermined signal, if it succeed we found the 5
                                if (signalsForDigit[9].replace(bit, "") == notDetermined) {
                                    signalsForDigit[5] = notDetermined
                                } else {
                                    signalsForDigit[2] = notDetermined
                                }
                            }

                            break;
                        }
                        case 6: {
                            // can be 0,9,6
                            // check if already determined 1 is not part of pattern, so we found the 6
                            if (!(notDetermined.contains(signalsForDigit[1][0]) && notDetermined.contains(signalsForDigit[1][1]))) {
                                signalsForDigit[6] = notDetermined
                            } else
                            // if 3 is already determined, we can determine 9
                            if (signalsForDigit[3]
                                    && notDetermined.contains(signalsForDigit[3][0])
                                    && notDetermined.contains(signalsForDigit[3][1])
                                    && notDetermined.contains(signalsForDigit[3][2])
                                    && notDetermined.contains(signalsForDigit[3][3])
                                    && notDetermined.contains(signalsForDigit[3][4])
                            ) {
                                signalsForDigit[9] = notDetermined
                            } else
                            // if 9 and 6 is already determined, the last 6 signal digit is 0
                            if (signalsForDigit[6] && signalsForDigit[9]) {
                                signalsForDigit[0] = notDetermined
                            }
                        }
                    }
                }
                // remove all determined signals from unknown signals
                notDeterminedSignals.removeAll(signalsForDigit.values())
                println "determined signals: $signalsForDigit"
                println "not determined signals: $notDeterminedSignals"
            }


            String tempValue = ""
            fourDigitOutputValue.trim().split(" ").collect {it.split("").sort().join()}.each {String outputPart ->
                println "Search for $outputPart"
                tempValue += signalsForDigit.find {it.value == outputPart}.key
            }
            println "Decoded Output Signal $tempValue"
            sum += tempValue as Integer


        }

        return sum
    }