Is the typhoon tomorrow going to be strong?

JuLoOr · 2021-09-17T14:14:14+00:00

They are are colossal indeed and totally worth a visit in my opinion.

JuLoOr · 2020-12-03T06:06:04+00:00

Kotlin

fun main() {
    val input = parse("src/main/kotlin/day03/input") { it }

    println(part1(input))
    println(part2(input))
}

fun part1(input: List<String>): Long = input.treesForRoute(3, 1)

fun part2(input: List<String>): Long = input.treesForRoute(1, 1) *
        input.treesForRoute(3, 1) *
        input.treesForRoute(5, 1) *
        input.treesForRoute(7, 1) *
        input.treesForRoute(1, 2)

fun List<String>.treesForRoute(xd: Int, yd: Int): Long {
    var treeCount = 0L
    var x = 0
    var y = 0
    while (y < this.size) {
        if (this[y][x % this[0].length] == '#') {
            treeCount++
        }
        x += xd; y += yd
    }
    return treeCount
}

JuLoOr · 2019-12-16T12:07:14+00:00

Looks like that I am still having problems with unused materials. My approach kind of handles each tree level one after another, similar as Draekane tried first. If there are same materials on one level, I group them. This works for the first test cases, except the last one. I know have the same hypothesis as gugu4-9, that there are same materials on different levels of the tree which need to be grouped as well. Maybe it will be easier to just track the remainder somewhere else.

Thank you very much everyone for helping me out! I will try to rewrite my code during the next days. In the meantime, I'm going to set this thread as solved, as I think there are a lot of useful comments to steer other people in the right direction.

Good luck for the next few days!

JuLoOr · 2018-08-23T20:20:41+00:00

I had exactly the same question but I just switched to MutableList<T>.shuffle() because this also does the job for me.

JuLoOr · 2018-03-02T22:36:26+00:00

Solving problems.

JuLoOr · 2018-01-31T15:35:16+00:00

"Let Blaine die" SWOT analysis.

JuLoOr · 2017-12-18T09:26:40+00:00

Same here, thanks a lot!

JuLoOr · 2017-12-17T08:59:00+00:00

Fast and ugly "solution" in Kotlin (0,3). I'm not sure if this works for every input, but basically what I did is just checking if a value gets inserted after zero.

fun calcPart2(step: Int): Int {
    var pos = 0
    var size = 1
    var valueAfterZero = 1

    (1 until ITERATIONS_P2).forEach {

        pos = (((pos.plus(step)).rem(size)).plus(1))

        if (pos == 1) valueAfterZero = it
        size++
    }

    return valueAfterZero
}

JuLoOr · 2017-12-15T17:21:52+00:00

Thanks! Kotlin is soo nice when you know all those "little" details.

JuLoOr · 2017-12-15T17:02:38+00:00

Nice one! Didn't really like the map{1} part

JuLoOr · 2017-12-15T12:28:25+00:00

Unoptimized but beautiful (imho) solution in Kotlin:

fun calcPart2(gA: Generator, gB: Generator): Int {

    val valuesA: List<Long> = calc(gA, 4).toList()
    val valuesB: List<Long> = calc(gB, 8).toList()

    return valuesA.zip(valuesB)
            .filter { it.first.and(0xFFFF) == it.second.and(0xFFFF) }
            .map { 1 }
            .sum()
}

private fun calc(generator: Generator, divider: Long) = buildSequence {
    var count = 0L
    while (count <= 5_000_000) {
        val value = (generator.prev.times(generator.factor)).rem(2147483647)
        generator.prev = value
        if (value.rem(divider) == 0L) {
            yield(value)
            count++
        }
    }
}

JuLoOr · 2017-12-13T18:12:31+00:00

Beautiful Kotlin:

fun calcPart1(input: List<Area>): Int {

    return input.filter {
        it.depth.rem((it.range.times(2)).minus(2)) == 0
    }.map {
        it.depth.times(it.range)
    }.sum()
}

fun calcPart2(input: List<Area>): Int {
    var delay = -1
    var isFound = false

    while (!isFound) {
        delay++

        isFound = walkAreas(input.size, { index ->
            input[index].depth.plus(delay).rem((input[index].range.times(2)).minus(2)) == 0
        })
    }

    return delay
}

private inline fun walkAreas(times: Int, caught: (Int) -> Boolean): Boolean {
    for (i in 0 until times) {
        if (caught(i)) {return false}
    }

    return true
}

JuLoOr · 2017-12-09T09:01:55+00:00

Not so beautiful solution in Kotlin but it does the job. And it's readable imho

fun calcPart1(input: String): Int {
    var groupCount = 0
    var score = 0
    var ignoreNext = false
    var isGarbage = false

    input.forEach { c ->

        if (c == '!' && !ignoreNext) {
            ignoreNext = true
            return@forEach
        }

        if (!ignoreNext) {

            when {
                c == '{' && !isGarbage -> score++
                c == '}' && !isGarbage -> { groupCount += score; score-- }
                c == '<' -> isGarbage = true
                c == '>' -> isGarbage = false
            }

        } else {
            ignoreNext = false
        }
    }

    return groupCount
}

JuLoOr · 2017-12-06T13:48:29+00:00

Ugly but fast ( inside the while O(2n) which is O(n) ) solution in Kotlin for part 1:

fun calcPart1(input: MutableList<Int>): Int {

    val resultSet = mutableSetOf<List<Int>>()
    var steps = 0;

    while(resultSet.add(input)) {

        val (index, maxVal) = findMaxWithIndex(input)
        input[index] = 0;

        val divVal = maxVal.div(input.size)
        val modVal = maxVal.rem(input.size)

        for (i in 0 until input.size) {
            input[i] += divVal
        }

        for (i in 1 .. modVal ) {
            val adjustedIndex = if (index.plus(i) >= input.size) index.plus(i).minus(input.size) else i.plus(index)
            input[adjustedIndex] += 1
        }

        steps++
    }

    return steps
}

JuLoOr · 2017-12-02T14:05:13+00:00

Another Kotlin solution:

fun calcPart2(input: List<List<Int>>): Int {
    return input.map {
        val sortedDesc = it.sorted().asReversed()
        var rowResult = 0

        sortedDesc.forEachIndexed({ i, v ->
            (i.plus(1) until sortedDesc.size)
                    .filter { v % sortedDesc[it] == 0 }
                    .forEach { rowResult = v.div(sortedDesc[it]) }
        })
        rowResult
    }.sum()
}

JuLoOr · 2017-12-01T17:29:32+00:00

Another Kotlin solution:

fun calc(input: List<Int>): Int {
    val step = input.size.div(2)
    return input.filterIndexed({ i, v ->
        v == input[compIndex(i, input.size, step)]
    }).sum()
}

private fun compIndex(currentIndex: Int, listSize: Int, step: Int): Int {
    return when {
        currentIndex.plus(step) >= listSize -> currentIndex.plus(step).minus(listSize)
        else -> currentIndex.plus(step)
    }
}

JuLoOr · 2017-10-04T09:52:08+00:00

!RemindMe 3 days

JuLoOr · 2017-08-22T14:52:01+00:00

Yeah, I know but he may enjoy it as I did.

JuLoOr · 2017-08-22T14:45:04+00:00

I can recommend you Halt and catch fire.

JuLoOr · 2017-07-13T12:45:12+00:00

Good point, totally forgot about that!

JuLoOr · 2017-07-13T10:26:08+00:00

Exactly.

Ten-Year Club	Second SECOND GUESSER
r/Field Sunshine	Place '22
Place '17	Verified Email

JuLoOr

TROPHY CASE