[소병희] Java vs C++, 1,2,3 더하기 4, 도어맨, 배열 복원하기, 후위 표기식2

src/main/kotlin/byeonghee/9week/1 2 3 더하기 4.kt

@@ -0,0 +1,44 @@
+package byeonghee.`9week`
+
+import java.io.*
+
+class 소병희_123더하기4 {
+    companion object {
+        const val LAST_ONE = 0
+        const val LAST_TWO = 1
+        const val LAST_THREE = 2
+
+        val br = BufferedReader(InputStreamReader(System.`in`))
+        val dp = Array(10004) { intArrayOf(1, 0, 0) }
+        var tc = 0
+
+        fun solve() {
+            val t = br.readLine().toInt()
+
+            repeat(t) {
+                tc = br.readLine().toInt()
+                println(findCases(tc + 3, LAST_THREE))
+            }
+        }
+
+        fun findCases(n: Int, e: Int): Int {
+            if (n <= e) return 0
+            if (n == 1) return if (e == LAST_ONE)  1 else 0
+            if (n == 2) return if (e <= LAST_TWO) 1 else 0
+            if (n == 3) return if (e <= LAST_THREE) 1 else 0
+
+            if (dp[n][e] > 0) return dp[n][e]
+
+            var ans = 0
+            for(i in 0..e) {
+                ans += findCases(n - e - 1, i)
+            }
+            dp[n][e] = ans
+            return ans
+        }
+    }
+}
+
+fun main() {
+    소병희_123더하기4.solve()
+}

src/main/kotlin/byeonghee/9week/Java vs C++.kt

@@ -0,0 +1,54 @@
+package byeonghee.`9week`
+
+import java.io.*
+import kotlin.system.exitProcess
+
+class 소병희_java_vs_cpp {
+    companion object {
+        const val UNDERSCORE = '_'
+        const val ERROR = "Error!"
+
+        val br = BufferedReader(InputStreamReader(System.`in`))
+
+        fun solve() {
+            val naming = br.readLine()
+            val sb = StringBuilder()
+
+            if (naming.first().isLowerCase().not() || naming.last() == '_' ||
+                (naming.contains("[A-Z]".toRegex()) && naming.contains('_'))) {
+                println("Error!")
+                exitProcess(0)
+            }
+
+            var prev = ' '
+            var cur = ' '
+            sb.append(naming.first())
+            for (i in 1 until naming.length) {
+                prev = naming[i-1]
+                cur = naming[i]
+                if (prev == UNDERSCORE) {
+                    if (cur.isLowerCase()) {
+                        sb.append(cur.uppercase())
+                    }
+                    else error()
+                }
+                else if (cur.isUpperCase()) {
+                    sb.append("_${cur.lowercase()}")
+                }
+                else if (cur.isLowerCase()) {
+                    sb.append(cur)
+                }
+            }
+            println(sb)
+        }
+
+        fun error() {
+            println(ERROR)
+            exitProcess(0)
+        }
+    }
+}
+
+fun main() {
+    소병희_java_vs_cpp.solve()
+}

src/main/kotlin/byeonghee/9week/도어맨.kt

@@ -0,0 +1,30 @@
+package byeonghee.`9week`
+
+import java.io.*
+import kotlin.math.abs
+
+class 소병희_도어맨 {
+    companion object {
+        const val M = 1
+        const val W = -1
+
+        val br = BufferedReader(InputStreamReader(System.`in`))
+        var count = 0
+
+        fun solve() {
+            val d = br.readLine().toInt()
+            val wait = br.readLine().map { if (it == 'M') M else W }
+            wait.indexOfFirst {
+                count += it
+                abs(count) > d + 1
+            }.let { ans -> when (ans) {
+                -1 -> if (abs(count) == d + 1) println(wait.size - 1) else println(wait.size)
+                else -> println(ans - 1)
+            } }
+        }
+    }
+}
+
+fun main() {
+    소병희_도어맨.solve()
+}

src/main/kotlin/byeonghee/9week/배열 복원하기.kt

@@ -0,0 +1,28 @@
+package byeonghee.`9week`
+
+import java.io.*
+
+class 소병희_배열복원하기 {
+    companion object {
+        val br = BufferedReader(InputStreamReader(System.`in`))
+
+        lateinit var matrixA : Array<IntArray>
+        lateinit var matrixB : List<List<Int>>
+
+        fun solve() {
+            val (h, w, x, y) = br.readLine().split(" ").map { it.toInt() }
+            matrixB = List(h + x) { br.readLine().split(" ").map { it.toInt() } }
+            matrixA = matrixB.subList(0, h).map { it.subList(0, w).toIntArray() }.toTypedArray()
+
+            for (r in x until h) for(c in y until w) {
+                matrixA[r][c] = matrixB[r][c] - matrixA[r - x][c - y]
+            }
+
+            println(matrixA.joinToString("\n") { it.joinToString(" ")})
+        }
+    }
+}
+
+fun main() {
+    소병희_배열복원하기.solve()
+}

src/main/kotlin/byeonghee/9week/후위 표기식2.kt

@@ -0,0 +1,46 @@
+package byeonghee.`9week`
+
+import java.io.*
+
+class 소병희_후위표기식2 {
+    companion object {
+        const val MUL = '*'
+        const val DIV = '/'
+        const val ADD = '+'
+        const val SUB = '-'
+
+        val br = BufferedReader(InputStreamReader(System.`in`))
+        val st = ArrayDeque<Double>()
+        val ans = 0L
+
+        fun solve() {
+            val n = br.readLine().toInt()
+            val expression = br.readLine()
+            val nums = Array(n) { br.readLine().toDouble() }
+
+            expression.forEach {
+                when (it) {
+                    MUL, DIV, ADD, SUB -> calc(st.removeLast(), st.removeLast(), it)
+                    else -> st.addLast(nums[it - 'A'])
+                }
+            }
+            println(st.last().let{ String.format("%.2f", it) })
+        }
+
+        fun calc(n1: Double, n2: Double, opC: Char) {
+            val op: (Double, Double) -> Double =
+                when (opC) {
+                    MUL -> { b, a -> a * b }
+                    DIV -> { b, a -> a / b }
+                    ADD -> { b, a -> a + b }
+                    SUB -> { b, a -> a - b }
+                    else -> { _, _ -> 0.0 }
+                }
+            st.addLast(op(n1, n2))
+        }
+    }
+}
+
+fun main() {
+    소병희_후위표기식2.solve()
+}