Julekalender 2016

Luke1.kt

import java.lang.Math.floor
import java.lang.Math.log10
import java.util.stream.Stream

fun main(args: Array<String>) {
    Stream.iterate(6, { it + 10 } )
        .filter { swapFirstAndLastDigit(it) == 4 * it }
        .findFirst()
        .map { println(it) }
}

fun swapFirstAndLastDigit(it: Int) : Int {
    return it / 10 + (it % 10) * Math.pow(10.0, floor(log10(it.toDouble()))).toInt()
}

Luke2.kt

import kotlin.system.measureTimeMillis

fun main(args: Array<String>) {
    println(measureTimeMillis { println(tailRecursion(0, 1, 0)) })
    println(measureTimeMillis { println(reduction()) })
}

tailrec fun tailRecursion(prevprev: Long, prev: Long, sum: Long) : Long {
    val current = prevprev + prev
    val nextsum =
            if (current % 2 == 0L) sum + current
            else sum
    if (current > 4000000000) return sum
    else return tailRecursion(prev, current, nextsum)
}

fun reduction() : Long {
    return generateSequence(Pair(0L, 1L), { f -> Pair(f.second, f.first + f.second)})
            .map { f -> f.second }
            .takeWhile { n -> n < 4000000000 }
            .filter { n -> n % 2L == 0L }
            .sum()
}

Luke4.kt

import java.util.*
import kotlin.system.measureTimeMillis

fun main(args: Array<String>) {
    val listOf = listOf(1..1337).flatten()
    // Alternativ 1
    println(measureTimeMillis { println(clap(listOf)[1336]) })
    // Alternativ 2
    println(measureTimeMillis { println(Clap().asSequence().take(1337).last()) })
}

tailrec fun clap(integers: List<Int>) : List<Int> {
    val list = ArrayList<Int>()
    var increment = 1
    for (v in integers) {
        if (v % 7 == 0) list.add(increment++)
        else if (v.toString().contains("7")) list.add(increment++)
        else list.add(v)
    }
    return if (increment < 7) list else clap(list)
}

class Clap : Iterator<Int> {
    var v = 0
    val otherList by lazy { Clap() }

    override fun next(): Int {
        v++
        return if (v % 7 == 0) otherList.next()
        else if (v.toString().contains("7")) otherList.next()
        else v
    }

    override fun hasNext(): Boolean {
        return true
    }
}

Luke5.kt

val msg = listOf("IV", "VI", "I", "II", "III", "V", "XI", "VI", "IV", "III", "VI", "VI", "V", "IV", "III", "V", "XI", "VI", "III", "VII", "IV", "VI", "III", "IX", "II", "I", "VI", "III", "IX", "VII", "III", "II", "V", "X", "VI", "V", "XI", "VI", "IV", "V", "X", "II", "III", "III", "VI", "XIII", "XI", "III", "IX", "VII", "III", "II", "VIII", "I", "IX", "I", "II", "V", "X", "IV", "IX", "VIII", "VII", "X", "IV", "XI", "VIII", "IX", "II", "III", "X", "III", "IX", "IV", "XI", "I", "III", "VIII", "IX", "IV", "XI", "II", "III", "IX", "X", "VI", "V", "VIII", "VII", "X", "VI", "VIII", "VII", "VII", "VI", "V", "IV", "V", "I", "VI", "I", "VII", "X", "VIII", "X", "X", "II", "III", "IV", "I", "IX", "VI", "VIII", "VII", "VII", "VI", "V", "IV", "V", "I", "VI", "I", "VII", "X", "VIII", "X", "X", "II", "III", "IV", "I", "IX", "V", "XI", "VI", "III", "III", "IX", "XIII", "II", "III", "XI", "V", "IV", "III", "III", "IX", "XIII", "II", "IV", "III", "VI", "VI", "V", "IV", "X", "I", "VII", "IV", "VII", "III", "II", "IV", "V", "VII", "VII", "III", "VI", "X", "VI", "VI", "XIII", "II", "II", "III", "X", "XI", "I", "IX", "III", "VII", "IV", "VI", "III", "IX", "X", "VIII", "VII", "IV", "XIII", "IX", "II", "III", "VII", "III", "X", "I", "II", "III", "VII", "IV", "I", "VII", "IV", "IV", "III", "IX", "IX", "III", "VII", "V", "VI", "IX", "XIII", "I", "I", "III", "VII", "VI", "I", "III", "XI", "V", "IV", "III", "IX", "III", "VII", "IV", "VI", "III", "VII", "III", "X", "X", "I", "VII", "IV", "III", "XI", "V", "IV", "III", "IX", "III", "VII", "IV", "VI", "III", "VII", "III", "X", "X", "I", "VII", "IV", "X", "I", "VI", "V", "IV", "III", "IX", "III", "II", "IV", "V", "VII", "VII", "III", "VI", "X", "VI", "III", "IX", "III", "II", "X", "VIII", "VII", "III", "IX", "V", "XI", "VI", "III", "VII", "I", "X", "X", "IV", "III", "IX", "VII", "III", "II", "III", "VII", "IV", "VI", "III", "IX", "I", "IX", "V", "VII", "IV", "III", "IX", "X", "V", "VI", "X", "X", "VIII", "IX", "III", "VIII", "IV", "X", "VII", "I", "I", "XI", "II", "VIII", "VII", "IV", "I", "VII", "X", "VIII", "VII", "V", "VI", "IX", "XIII", "I", "I", "III", "VII", "VI", "I", "III", "IX", "XIII", "II", "II", "III", "IV", "IV", "XI", "III", "IX", "X", "V", "III", "VI", "IV", "I", "VII", "IV", "I", "IX", "III", "IX", "III", "VI", "X", "X", "III", "IX", "XIII", "II", "II", "III", "IV", "IV", "XI", "III", "IX", "X", "V", "III", "VI", "IV", "I", "VII", "IV", "I", "IX", "III", "IX", "III", "VI", "X", "X", "X", "IX", "VI", "II", "IX", "III", "IX", "0", "IV", "VII", "0", "IV", "VI", "II", "V", "IX", "IX", "II", "XI", "IV", "III", "II", "II", "II", "XII", "IX", "III", "X", "IX", "VI", "II", "IX", "III", "IX", "0", "IV", "VII", "0", "IV", "VI", "II", "V", "IX", "IX", "II", "XI", "IV", "III", "II", "II", "II", "XII", "IX", "III", "0", "VI", "VII", "II", "I", "I", "XII", "IX", "V", "IV", "VI", "VII", "IX", "VI", "0", "IV", "VI", "VII", "II", "X", "I", "0", "VI", "IX", "III", "VII", "II", "IX", "VII", "X", "IX", "VI", "IV", "X", "IX", "II", "III", "VII", "IV", "IX", "I", "IX", "II", "VI", "III", "VII", "II", "II", "II", "VII", "IX", "II", "IV", "X", "X", "0", "VII", "II", "VI", "X", "V", "IX", "II", "VII", "VII", "X", "II", "II", "IX", "III", "V", "IX", "VI", "II", "VI", "VI", "IV", "IV", "II", "II", "IX", "III", "III", "IV", "VI", "0", "IX", "III", "VII", "0", "IX", "IX", "II", "VII", "II", "VI", "III", "VII", "II", "IX", "II", "III", "IV", "XI", "II", "III", "VII", "0", "IX", "IX", "II", "VII", "II", "VI", "III", "VII", "II", "IX", "II", "III", "IV", "XI", "II", "0", "VI", "VII", "II", "I", "I", "XII", "IX", "V", "IV", "VII", "II", "IX", "IX", "II", "IV", "III", "VII", "0", "III", "VII", "II", "II", "0", "IX", "II", "VII", "II", "II", "IX", "XII", "IV", "VI", "VII", "IX", "IX", "II", "VI", "III", "VII", "II", "IX", "0", "XI", "X", "II", "II", "II", "XII", "VI", "V", "IX", "VI", "II", "VI", "VI", "IV", "IV", "II", "II", "VI", "III", "VII", "0", "IX", "III", "IV", "VI", "VI", "II", "IV", "II", "XII", "IX", "III", "II", "III", "IV", "XI", "II", "II", "XII", "IX", "III", "II", "VI", "X", "V", "IX", "0", "III", "II", "II", "IX", "IX", "VII", "X", "VII", "0", "VI", "I", "IV", "III", "IV", "VI", "VII", "VII", "VII", "VI", "IX", "0", "III", "II", "II", "IX", "IX", "VII", "X", "VII", "0", "VI", "I", "IV", "III", "IV", "VI", "VII", "VII", "VII", "VI", "X", "VII", "VII", "V", "V", "IX", "IX", "II", "II", "X", "III", "IX", "VII", "III", "0", "XI", "IV", "IX", "II", "IX", "II", "II", "IX", "VII", "XI", "IV", "X", "VII", "VII", "IX", "III", "IX", "IV", "II", "0", "IX", "0", "VIII", "II", "II", "VI", "IX", "II", "XI", "XII", "VI", "III", "II", "II", "X", "IV", "IV", "VI", "X", "V", "V", "IX", "IV", "II", "II", "VII", "IX", "II", "VI", "0", "II", "IX", "II", "VI", "III", "VII", "II", "VI", "X", "V", "II", "III", "IV", "VI", "VI", "II", "IV", "VI", "X", "V", "II", "II", "0", "VI", "III")
val romans = mapOf("I" to 1, "V" to 5, "X" to 10)

fun main(args: Array<String>) {
    val characters = msg.subList(0, msg.size/2)
            .zip(msg.reversed().subList(0, msg.size/2))
            .map { a -> romanToNum(a.first, 0) + romanToNum(a.second, 0) }
            .map { c -> (c + 96).toChar().toString() }
            .reduce { a, b -> a + b }

    println(characters)
}

tailrec fun romanToNum(msg : String, sum : Int) : Int {
    if (msg == "0") return 0
    val rest = msg.drop(1)
    val currentValue = romans[msg.take(1)] ?: 0
    val nextValue = romans[rest.take(1)] ?: Int.MAX_VALUE
    if (rest.length == 0) {
        return sum + currentValue
    }
    else {
        return romanToNum(rest, sum + (if (currentValue >= nextValue) currentValue else - currentValue))
    }
}

Luke7.kt

import java.net.HttpURLConnection
import java.net.URL

fun main(args: Array<String>) {
    val connection = URL("http://pastebin.com/raw/BZrAMcN2").openConnection() as HttpURLConnection
    val s = connection.inputStream.bufferedReader().use { reader ->
        reader.readLines().map {
            val (prefix, walk, m, dir) = it.split(" ")
            when (dir) {
                "north" -> Pair(walk.toInt(), 0)
                "south" -> Pair(-walk.toInt(), 0)
                "east" -> Pair(0, -walk.toInt())
                "west" -> Pair(0, walk.toInt())
                else -> Pair(0, 0)
                }
            }
            .reduce { a, b -> Pair(a.first + b.first, a.second + b.second) }
    }
    println("${s.first}, ${s.second}")
}

Luke8.kt

import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import kotlin.system.measureTimeMillis

val stiger = listOf(Pair(3,17), Pair(8,10),Pair (15,44), Pair(22,5), Pair(39,56), Pair(49,75), Pair(62,45), Pair(64,19), Pair(65,73), Pair(80,12), Pair(87,79))
        .groupBy({ it.first }, { it.second} )
        .mapValues { it.value.first() }

fun main(args: Array<String>) {
    val connection = URL("http://pastebin.com/raw/dJ7cT4AF").openConnection() as HttpURLConnection
    val s = connection.inputStream.bufferedReader().use { reader -> reader.readLines().map { it.toInt() } }
    val loop = measureTimeMillis { println(loops(s)) }
    val rec = measureTimeMillis { println(recursion(s.zip(generateSequence(1) { it % 1337 + 1 }.asIterable()), emptyMap(), 0)) }

    println("Loop took $loop, recursion took $rec")
}

fun loops(kast: List<Int>) : Int {
    val posisjon = HashMap<Int, Int>()
    var stigeflytt = 0
    for ((k, spiller) in kast.zip(generateSequence(1) { it % 1337 + 1 }.asIterable())) {
        val pos = posisjon.getOrDefault(spiller, 1)
        if (pos + k > 90) {
            posisjon.put(spiller, pos)
        }
        else if (stiger.containsKey(pos + k)) {
            stigeflytt++
            posisjon.put(spiller, stiger.getOrElse(pos + k) { 0 })
        }
        else if (pos + k == 90) {
            return spiller * stigeflytt
        }
        else {
            posisjon.put(spiller, pos + k)
        }
    }
    return -1
}

tailrec fun recursion(kastOgSpiller: Iterable<Pair<Int, Int>>, posisjon: Map<Int, Int>, stigeflytt: Int) : Int {
    val (k, spiller) = kastOgSpiller.first()
    val neste = kastOgSpiller.drop(1)
    val pos = posisjon.getOrElse(spiller, { 1 })
    if (pos + k > 90) {
        return recursion(neste, posisjon + Pair(spiller, pos), stigeflytt)
    }
    else if (stiger.containsKey(pos + k)) {
        return recursion(neste, posisjon + Pair(spiller, stiger[pos + k] ?: 0), stigeflytt + 1)
    }
    else if (pos + k == 90) {
        return stigeflytt * spiller
    }
    else {
        return recursion(neste, posisjon + Pair(spiller, pos + k), stigeflytt)
    }
}

Luke9.kt

import java.net.HttpURLConnection
import java.net.URL
import java.util.*
import kotlin.system.measureTimeMillis

fun main(args: Array<String>) {
    val connection = URL("http://pastebin.com/raw/2vstb018").openConnection() as HttpURLConnection
    val s = connection.inputStream.bufferedReader().use { reader -> reader.readLines().map {
        val (from, to, amount) = it.split(",")
        Trans(from, to, amount.toInt())
    } }

    val loop = measureTimeMillis { println(loop(s)) }
    val reduce = measureTimeMillis { println(reduce(s)) }

    println("Loop took $loop ms and reduce took $reduce ms")
}

fun loop(s: List<Trans>): Int {
    val map = HashMap<String, Int>()
    for ((from, to, amount) in s) {
        val fromBalance = map.getOrDefault(from, 0)
        val toBalance = map.getOrDefault(to, 0)
        map.put(to, toBalance + amount)
        if (from != "None") map.put(from, fromBalance - amount)
    }
    return map
            .filter { it.value > 10 }
            .count()
}

fun reduce(s: List<Trans>): Int {
    return s.flatMap { listOf(Pair(it.from, -it.amount), Pair(it.to, it.amount)) }
        .filter { it.first != "None" }
        .groupBy({ it.first }, { it.second })
        .mapValues { it.value.reduce { a, b -> a + b } }
        .filter { it.value > 10 }
        .count()
}

data class Trans (
        val from: String,
        val to: String,
        val amount: Int
)

Fett!

👍