Week9

Lv.1/2016년.kt

@@ -0,0 +1,10 @@
+package Lv.`1`
+
+
+fun solution(a: Int, b: Int): String {
+    val daysOfMonth = listOf(0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
+    val dayOfWeek = listOf("FRI", "SAT", "SUN", "MON", "TUE", "WED", "THU")
+    val totalDays = (1 until a).sumOf { daysOfMonth[it] } + b - 1
+
+    return dayOfWeek[totalDays % 7]
+}

Lv.1/가장 많이 받은 선물.kt

@@ -0,0 +1,49 @@
+package Lv.`1`
+
+fun solution2(users: Array<String>, giftList: Array<String>): Int {
+    var result: Int = 0
+    val giftTracker = mutableMapOf<String, MutableList<String>>()
+
+    val giftsReceived = mutableMapOf<String, Int>()
+    val giftsGiven = mutableMapOf<String, Int>()
+    val scoreMap = mutableMapOf<String, Int>()
+    val totalGifts = mutableMapOf<String, Int>()
+
+    giftList.forEach { record ->
+        val parts = record.split(" ")
+        val giver = parts.first()
+        val receiver = parts.last()
+        giftTracker.computeIfAbsent(giver) { mutableListOf() }.add(receiver)
+        giftsGiven[giver] = giftsGiven.getOrDefault(giver, 0) + 1
+    }
+
+    users.forEach { user ->
+        val receivedCount = giftTracker.values.flatten().count { giver -> giver == user }
+        giftsReceived[user] = receivedCount
+        scoreMap[user] = (giftsGiven[user] ?: 0) - (giftsReceived[user] ?: 0)
+        totalGifts[user] = 0
+    }
+
+    for (i in users.indices) {
+        val currentUser = users[i]
+        var maxGiftCount = Int.MIN_VALUE
+        for (j in users.indices) {
+            val otherUser = users[j]
+            if (i != j) {
+                val giftsFromCurrent = giftTracker[currentUser]?.count { it == otherUser } ?: 0
+                val giftsFromOther = giftTracker[otherUser]?.count { it == currentUser } ?: 0
+                if (giftsFromCurrent > giftsFromOther) {
+                    totalGifts[currentUser] = totalGifts.getOrDefault(currentUser, 0) + 1
+                } else if (giftsFromCurrent == giftsFromOther) {
+                    if (scoreMap[currentUser] ?: 0 > scoreMap[otherUser] ?: 0) {
+                        totalGifts[currentUser] = totalGifts.getOrDefault(currentUser, 0) + 1
+                    }
+                }
+            }
+        }
+        maxGiftCount = maxOf(maxGiftCount, totalGifts[currentUser] ?: 0)
+        result = maxOf(maxGiftCount, result)
+    }
+
+    return result
+}

Lv.1/기사단원의 무기.kt

@@ -0,0 +1,28 @@
+package Lv.`1`
+
+class Solution4 {
+    fun solution(number: Int, limit: Int, power: Int): Int {
+        var answer: Int = 0
+
+        for (i in 1..number) {
+            var divisorCount = 0
+
+            for (j in 1..Math.sqrt(i.toDouble()).toInt()) {
+                if (i % j == 0) {
+                    divisorCount += 1
+                    if (j != i / j) {
+                        divisorCount += 1
+                    }
+                }
+            }
+
+            if (divisorCount > limit) {
+                answer += power
+            } else {
+                answer += divisorCount
+            }
+        }
+
+        return answer
+    }
+}

Lv.1/달리기 경주.kt

@@ -0,0 +1,25 @@
+package Lv.`1`
+
+fun solution(players: Array<String>, callings: Array<String>): Array<String> {
+    val rankList = players.copyOf()
+    val playerMap = hashMapOf<String, Int>()
+
+    players.forEachIndexed { index, player ->
+        playerMap[player] = index
+    }
+
+    callings.forEach { calledPlayer ->
+        playerMap[calledPlayer]?.let {
+            if (it > 0) {
+                val nextPlayer = rankList[it - 1]
+                rankList[it] = nextPlayer
+                rankList[it - 1] = calledPlayer
+
+                playerMap[calledPlayer] = it - 1
+                playerMap[nextPlayer] = it
+            }
+        }
+    }
+
+    return rankList
+}

Lv.1/동영상 재생기.kt

@@ -0,0 +1,42 @@
+package Lv.`1`
+
+class Solution5 {
+    fun solution(videoLen: String, pos: String, opStart: String, opEnd: String, commands: Array<String>): String {
+        fun timeToSeconds(time: String): Int {
+            val parts = time.split(":")
+            return parts[0].toInt() * 60 + parts[1].toInt()
+        }
+
+        fun secondsToTime(seconds: Int): String {
+            val minutes = seconds / 60
+            val secs = seconds % 60
+            return String.format("%02d:%02d", minutes, secs)
+        }
+
+        val videoLength = timeToSeconds(videoLen)
+        val openingStart = timeToSeconds(opStart)
+        val openingEnd = timeToSeconds(opEnd)
+        var currentPosition = timeToSeconds(pos)
+
+        if (currentPosition in openingStart..openingEnd) {
+            currentPosition = openingEnd
+        }
+
+        for (command in commands) {
+            when (command) {
+                "prev" -> {
+                    currentPosition = (currentPosition - 10).coerceAtLeast(0)
+                }
+                "next" -> {
+                    currentPosition = (currentPosition + 10).coerceAtMost(videoLength)
+                }
+            }
+
+            if (currentPosition in openingStart..openingEnd) {
+                currentPosition = openingEnd
+            }
+        }
+
+        return secondsToTime(currentPosition)
+    }
+}

Lv.1/모의고사.kt

@@ -0,0 +1,26 @@
+package Lv.`1`
+
+fun solution(answers: IntArray): IntArray {
+    val student1 = arrayOf(1, 2, 3, 4, 5)
+    val student2 = arrayOf(2, 1, 2, 3, 2, 4, 2, 5)
+    val student3 = arrayOf(3, 3, 1, 1, 2, 2, 4, 4, 5, 5)
+
+    val scores = intArrayOf(0, 0, 0)
+
+    for (i in answers.indices) {
+        if (answers[i] == student1[i % student1.size]) scores[0]++
+        if (answers[i] == student2[i % student2.size]) scores[1]++
+        if (answers[i] == student3[i % student3.size]) scores[2]++
+    }
+
+    val maxScore = scores.maxOrNull() ?: 0
+
+    val answer = mutableListOf<Int>()
+    for (i in scores.indices) {
+        if (scores[i] == maxScore) {
+            answer.add(i + 1)
+        }
+    }
+
+    return answer.toIntArray()
+}

Lv.1/문자열 나누기.kt

@@ -0,0 +1,31 @@
+package Lv.`1`
+
+fun solution(s: String): Int {
+    var answer = 0
+    var i = 0
+
+    while (i < s.length) {
+        var xCount = 0
+        var otherCount = 0
+        val x = s[i]
+
+        while (i < s.length) {
+            if (s[i] == x) {
+                xCount++
+            } else {
+                otherCount++
+            }
+
+            i++
+
+            if (xCount == otherCount) {
+                answer++
+                break
+            }
+        }
+    }
+
+    if (i == s.length) answer++
+
+    return answer
+}

Lv.1/바탕화면 정리.kt

@@ -0,0 +1,22 @@
+package Lv.`1`
+
+fun solution(wallpaper: Array<String>): IntArray {
+    var lux = Int.MAX_VALUE
+    var luy = Int.MAX_VALUE
+    var rdx = 0
+    var rdy = 0
+
+    for (i in wallpaper.indices) {
+        for (j in wallpaper[i].indices) {
+            if (wallpaper[i][j] == '#') {
+                lux = minOf(lux, i)
+                luy = minOf(luy, j)
+
+                rdx = maxOf(rdx, i + 1)
+                rdy = maxOf(rdy, j + 1)
+            }
+        }
+    }
+
+    return intArrayOf(lux, luy, rdx, rdy)
+}

Lv.2/k진수에서 소수 개수 구하기.kt

@@ -0,0 +1,23 @@
+package Lv.`2`
+
+fun solution(n: Int, k: Int): Int {
+    val converted = n.toString(k)
+    val parts = converted.split("0")
+    var count = 0
+
+    for (part in parts) {
+        if (part.isNotEmpty() && checkPrime(part.toLong())) {
+            count++
+        }
+    }
+
+    return count
+}
+
+fun checkPrime(num: Long): Boolean {
+    if (num < 2) return false
+    for (i in 2..Math.sqrt(num.toDouble()).toLong()) {
+        if (num % i == 0L) return false
+    }
+    return true
+}

Lv.2/이진 변환 반복하기.kt

@@ -0,0 +1,22 @@
+package Lv.`2`
+
+class Solution {
+    fun solution(s: String): IntArray {
+        var count = 0
+        var zeroCount = 0
+        var currentString = s
+
+        while (currentString != "1") {
+            val zeros = currentString.count { it == '0' }
+            zeroCount += zeros
+
+            val length = currentString.length - zeros
+
+            currentString = Integer.toBinaryString(length)
+
+            count++
+        }
+
+        return intArrayOf(count, zeroCount)
+    }
+}

Lv.2/최댓값과 최솟값.kt

@@ -0,0 +1,10 @@
+package Lv.`2`
+
+fun solution(s: String): String {
+    val numbers = s.split(" ").map { it.toInt() }
+
+    val min = numbers.minOrNull() ?: 0
+    val max = numbers.maxOrNull() ?: 0
+
+    return "$min $max"
+}

kotlin_2/오픈채팅방.kt

@@ -1,7 +1,7 @@
 package kotlin_2
 
 class Solution {
-    fun solution(record: Array<String>): Array<Any> {
+    fun solution(record: Int, intArrayOf: IntArray, intArrayOf1: IntArray): Array<Any> {
         var member: MutableMap<String, String> = mutableMapOf()
 
         record.forEach {