[장희직] 기적의 매매법, 수 이어 쓰기 1, 등수 구하기, DNA

src/main/kotlin/heejik/12week/안녕.kt

@@ -10,8 +10,6 @@ class 안녕 {
     )
 
     fun solve() {
-        var hp = 100
-        var happy = 0
         val n = readln().toInt()
         val l = readln().split(' ').map { it.toInt() }
         val j = readln().split(' ').map { it.toInt() }

src/main/kotlin/heejik/12week/트럭.kt

@@ -2,6 +2,10 @@ package heejik.`12week`
 
 class 트럭 {
 
+    data class Truck(
+        val weight: Int, var time: Int
+    )
+
     fun solve() {
         val (n, w, l) = readln().split(' ').map { it.toInt() }
         val trucks = readln().split(' ').map { it.toInt() }.toMutableList()
@@ -24,9 +28,6 @@ class 트럭 {
     }
 }
 
-data class Truck(
-    val weight: Int, var time: Int
-)
 
 fun main() {
     트럭().solve()

src/main/kotlin/heejik/13week/DNA.kt

@@ -0,0 +1,38 @@
+package heejik.`13week`
+
+import java.lang.Integer.max
+
+
+class DNA {
+
+    fun solve() {
+
+        var answerDna = ""
+        var answerCnt = 0
+
+        val (n, m) = readln().split(' ').map { it.toInt() }
+
+        val dnaList = mutableListOf<String>()
+
+        repeat(n) { dnaList.add(readln()) }
+
+        repeat(m) {
+            var dnaByIdx = ""
+            dnaList.forEach { dna -> dnaByIdx += dna[it] }
+
+            var maxCnt = 0
+            "ACGT".forEach { c -> maxCnt = max(maxCnt, dnaByIdx.count { c == it }) }
+
+            answerDna += dnaByIdx.filter { c -> maxCnt == dnaByIdx.count { c == it } }.min()
+            answerCnt += dnaByIdx.count { it != answerDna.last() }
+        }
+
+        println(answerDna)
+        println(answerCnt)
+    }
+}
+
+fun main() {
+
+    DNA().solve()
+}

src/main/kotlin/heejik/13week/등수 구하기.kt

@@ -0,0 +1,26 @@
+package heejik.`13week`
+
+class `등수 구하기` {
+
+    fun solve() {
+        val (n, score, p) = readln().split(' ').map { it.toInt() }
+
+        if (n == 0) {
+            println(1)
+            return
+        }
+        val scores = readln().split(' ').map { it.toInt() }.toMutableList()
+
+        scores.sort()
+
+        if (scores.count { it >= score } >= p) {
+            println(-1)
+        } else {
+            println(scores.count { it > score } + 1)
+        }
+    }
+}
+
+fun main() {
+    `등수 구하기`().solve()
+}

src/main/kotlin/heejik/13week/수 이어 쓰기 1.kt

@@ -0,0 +1,29 @@
+package heejik.`13week`
+
+class `수 이어 쓰기 1` {
+
+    fun solve() {
+        val n = readln().toInt()
+        var answer = 0
+
+        repeat(n) {
+            answer += getDigit(it+1)
+        }
+
+        println(answer)
+    }
+
+    private fun getDigit(_num : Int): Int {
+        var num = _num
+        var cnt = 0
+        while (num != 0) {
+            num /= 10
+            cnt ++
+        }
+        return cnt
+    }
+}
+
+fun main() {
+    `수 이어 쓰기 1`().solve()
+}

src/main/kotlin/heejik/13week/시계.kt

@@ -0,0 +1,45 @@
+package heejik.`13week`
+
+class 시계 {
+
+    val nums = listOf(
+        "####.##.##.####",  // 0
+        "..#..#..#..#..#",  // 1
+        "###..#####..###",  // 2
+        "###..####..####",  // 3
+        "#.##.####..#..#",  // 4
+        "####..###..####",  // 5
+        "####..####.####",  // 6
+        "###..#..#..#..#",  // 7
+        "####.#####.####",  // 8
+        "####.####..####"   // 9
+    )
+
+    fun solve() {
+        val watch = mutableListOf<List<String>>()
+        repeat(5) {
+            watch.add(readln().split(' '))
+        }
+
+        val hourFirst = find(watch.joinToString(separator = "") { it[0] })
+        val hourSecond = find(watch.joinToString(separator = "") { it[1] })
+        val minuteFirst = find(watch.joinToString(separator = "") { it[2] })
+        val minuteSecond = find(watch.joinToString(separator = "") { it[3] })
+
+        println("$hourFirst$hourSecond:$minuteFirst$minuteSecond")
+    }
+
+    fun find(diode: String): Int {
+        nums.forEach { num ->
+            num.forEachIndexed { index, c ->
+                if (c == '.' && diode[index] == '#') return@forEach
+            }
+            return nums.indexOf(num)
+        }
+        return -1
+    }
+}
+
+fun main() {
+    시계().solve()
+}

src/main/kotlin/heejik/13week/크로스워드.kt

@@ -0,0 +1,34 @@
+package heejik.`13week`
+
+class 크로스워드 {
+
+    fun solve() {
+
+        val (r, c) = readln().split(' ').map { it.toInt() }
+
+        val crossWord = mutableListOf<String>()
+        val words = mutableListOf<String>()
+
+
+        repeat(r) {
+            val row = readln()
+            crossWord.add(row)
+            row.split('#').forEach {
+                if (it.length > 1) words.add(it)
+            }
+        }
+
+        repeat(c) { n ->
+            crossWord.joinToString(separator = "") { it[n].toString() }.split('#').forEach {
+                if (it.length > 1) words.add(it)
+            }
+        }
+
+        println(words.minOrNull())
+    }
+}
+
+
+fun main() {
+    크로스워드().solve()
+}

src/main/kotlin/heejik/13week/🐜 기적의 매매법 🐜.kt

@@ -0,0 +1,71 @@
+package heejik.`13week`
+
+class `🐜 기적의 매매법 🐜` {
+
+    fun solve() {
+        val money = readln().toInt()
+        val stocks = readln().split(' ').map { it.toInt() }
+
+        val bnf = bnf(money, stocks)
+        val timing = timing(money, stocks)
+
+        println(
+            if (bnf > timing) "BNP"
+            else if (timing > bnf) "TIMING"
+            else "SAMESAME"
+        )
+    }
+
+    private fun bnf(_money: Int, stocks: List<Int>): Int {
+        var money = _money
+        var stock = 0
+
+        stocks.forEach {
+            val cnt = money / it
+            money -= it * (cnt)
+            stock += cnt
+        }
+
+        return money + (stock * stocks.last())
+    }
+
+    private fun timing(_money: Int, stocks: List<Int>): Int {
+        var money = _money
+        var stock = 0
+
+        var upCnt = 0
+        var downCnt = 0
+        var preStock = stocks.first()
+
+        stocks.drop(0).forEach {
+            if (it > preStock) {
+                upCnt++
+                downCnt = 0
+            } else if (it < preStock) {
+                downCnt++
+                upCnt = 0
+            } else {
+                upCnt = 0
+                downCnt = 0
+            }
+
+            if (upCnt >= 3) {
+                money += stock * it
+                stock = 0
+            }
+            if (downCnt >= 3) {
+                val cnt = money / it
+                money -= it * (cnt)
+                stock += cnt
+            }
+
+            preStock = it
+        }
+
+        return money + (stock * stocks.last())
+    }
+}
+
+fun main() {
+    `🐜 기적의 매매법 🐜`().solve()
+}