[ํ๋ก๊ทธ๋๋จธ์ค] (Swift) kakao - ์คํจ์จ (2019 KAKAO BLIND RECRUITMENT)
๐ ๋ฌธ์ ๋งํฌ
https://school.programmers.co.kr/learn/courses/30/lessons/42889\
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๐ ์๊ฐ์ด๊ณผ ์ฝ๋
GitHub - deslog/Algorithm
Contribute to deslog/Algorithm development by creating an account on GitHub.
github.com
๊ฐ๋จํ๊ฒ, ๋ฐฐ์ด์์ ์๋ฅผ ์ธ์ด์ ๋๋ ์ฃผ๋ ๋ฌธ์ ์ด๋ค. stage๋ณ๋ก failure๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ๋ผ์, ๋ฐฐ์ด์ ๋๊ฐ ๋ง๋ค์ด์ ๊ตฌํ๋ ค๊ณ ํ์ง๋ง, ๋ฉ๋ชจ๋ฆฌ+ํจ์จ์ฑ์ ์ํด ๋์ ๋๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ค. ์ด์ฐจํผ key/value ๋ณ๋ก ์ ๋ ฌํด์ฃผ๋ฉด ๋๋๊น!
๊ทธ๋ฆฌ๊ณ ํด๋น stage๋ฅผ ๋ฌ์ฑํ์ฌ๋, ๋ฌ์ฑํ์ง๋ง ๋ชปํด๊ฒฐํ์ฌ๋์ ์ธ์ด์ฃผ๊ธฐ์ํด filter+count๋ฅผ ์ด์ฉํด์ ์ธ์ด์ฃผ์๋ค. ํ์ง๋ง test case 5, 9, 22๋ฒ์์ ์๊ฐ์ด๊ณผ๊ฐ ๋ฐ์ํ๋ค ใ ใ
import Foundation
func solution(_ N:Int, _ stages:[Int]) -> [Int] {
var failure = [Int: Double]()
for i in 1..<N+1 {
let failNum = stages.filter({ $0 == i }).count
let clearNum = stages.filter({ $0 >= i }).count
failure[i] = Double(failNum) / Double(clearNum)
}
let sortArr = failure.sorted(by: <).sorted(by: { $0.1 > $1.1 })
let result = sortArr.map{ $0.key }
return result
}
์ธํฐ๋ท์ ์ฐพ์๋ณด๋, ํ ์คํธ์ผ์ด์ค๊ฐ ์ถ๊ฐ๋๋ฉด์ 5, 9, 22 ๋ฒ์์ ์๊ฐ์ด๊ณผ๊ฐ ๋จ๋ ์ฌ๋๋ค์ด ๋ง์๋ค. ๋ฌธ์ ๋, filter ๊ณ ์ฐจํจ์๊ฐ for ๋ฌธ ์์ ๋ค์ด๊ฐ๋ฉด ์๊ฐ๋ณต์ก๋๊ฐ ๋๋ฌด ์ปค์ง๊ธฐ ๋๋ฌธ์, filter๋ฅผ ๋นผ๊ณ countํด๋ณด๋ผ๋ ์กฐ์ธ์ด ์์๋ค.
๐ ์ ๋ต ์ฝ๋
GitHub - deslog/Algorithm
Contribute to deslog/Algorithm development by creating an account on GitHub.
github.com
๊ทธ๋์ ์ ์ฝ๋์ ๊ฐ์ ๋ฐฉ์์ผ๋ก, filter๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ๋ฐฐ์ด์ ์ฌ์ฉํด์ count ํด์ฃผ์๋ค. index๋ฒํธ๋ฅผ ๊ทธ๋๋ก stage ๋ฒํธ๋ก ๊ฐ์ ธ๊ฐ๊ณ , ๋ฑ์ฅํ๋ฉด index์ ๋ง์ถฐ์ +1 ์ฉ ํด์ฃผ๋ฉด์ count ํด์ฃผ์๋ค. ์ด๋ฐ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํธ๋, ํต๊ณผ์๋ค!
import Foundation
func solution(_ N:Int, _ stages:[Int]) -> [Int] {
var failure = [Int: Double]()
var total = Double(stages.count) // 8.0
var countArr = Array(repeating: 0, count: N+2) // [0, 0, 0, 0, 0, 0]
for num in stages {
countArr[num] += 1 // [0, 1, 3, 2, 1, 0, 1]
}
for i in 1..<N+1 {
if countArr[i] == 0 {
failure[i] = 0.0
} else {
total = total - Double(countArr[i])
failure[i] = Double(countArr[i]) / total
}
}
let sortArr = failure.sorted(by: <).sorted(by: { $0.1 > $1.1 })
let result = sortArr.map{ $0.key }
return result
}
์ ์ด์ ๊ฐ ์คํ ์ด์ง ๋ณ๋ก ๊ฐ์๋ฅผ ์ธ์ด์ฃผ๊ณ ๋๋ค for๋ฌธ์ ๋๋ ค์ฃผ๋ฉด, ์ ํ์ ์ธ ์๊ฐ๋ณต์ก๋๋ก ํด๊ฒฐ์ด ๊ฐ๋ฅํ์ง๋ง, for๋ฌธ์์ filter๋ฅผ ๋ฃ๊ฒ ๋๋ฉด, O(n^2) ๊น์ง ์๊ฐ๋ณต์ก๋๊ฐ ์ปค์ง๊ธฐ ๋๋ฌธ์, ํน์ ์ผ์ด์ค๊ฐ ํฐ ๊ฒ๋ค์ ํต๊ณผํ์ง ๋ชปํ๋ ๊ฒ์ด๋ค.
๐ ๊ณ ์ฐฐ
์ ํ ์์นด๋ฐ๋ฏธ์์ ์ข์ ๊ธฐํ๋ก ์ ํ ๊ด๊ณ์๋ถ๊ป ์ง๋ฌธํ ์ ์๋ ๊ธฐํ๊ฐ ์์๊ณ , ์ด๋ ์๊ณ ๋ฆฌ์ฆ ๊ด๋ จ ์ง๋ฌธํ ์ ์ด ์์๋ค. '๊ณ ์ฐจํจ์'์ ๋ํ ๋ํ๋ฅผ ์งํํ์๊ณ , ์๊ณ ๋ฆฌ์ฆ์ ํ ๋ ์ ๊ณ ์ฐจํจ์๋ฅผ ์ฐ๋ฉด ํจ์จ์ฑ์ด ๋จ์ด์ง๊ณ , ์๊ฐ์ด๊ณผ๊ฐ ์์ฃผ๋๋์ง์ ๋ํด์ ์ฌ์ญค๋ณด์๋ค.
๊ทธ ๋ถ๊ป์๋ ์ ๋ swift์์ ํจ์จ์ฑ์ด ๋จ์ด์ง๊ฒ ๊ณ ์ฐจํจ์๋ฅผ ๋ง๋ค์ด๋์ง ์์๋ค๋ฉฐ, ๋ด๊ฐ ์ง ์๊ณ ๋ฆฌ์ฆ์ ๋ฌธ์ ๊ฐ ์๋ ๊ฒฝ์ฐ๋ผ๊ณ ํ์ จ๋ค. ์ธํฐ๋ท์ ์ฐพ์๋ณด๋ map, filter, reduce ๊ฐ ๊ณ ์ฐจํจ์๋ O(n)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ๊ณ ์๋ค. ๋ณ๋ก ๊ทธ๋ฅ ํฐ ๊ฑด ์๋๊ฑฐ๊ฐ์ง๋ง, ์ด๊ฒ for ๋ฌธ ์์ ๋ค์ด์์ผ๋ฉด, ์๊ฐ๋ณต์ก๋๊ฐ ๊ธฐํ๊ธ์์ ์ผ๋ก ๋์ด๋๊ธฐ๋๋ฌธ์ ๋ฐฉ๊ธ๊ณผ ๊ฐ์, ์๊ฐํจ์จ์ฑ์ด ๋จ์ด์ง๋ ๋ฌธ์ ๋ฅผ ๊ฒช์๋ ๊ฒ์ด๋ค.
์ํ! ๊ทธ๋์ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ ๋๋ ๋๋ถ๋ถ ๊ณ ์ฐจํจ์๋ฅผ ์ฐ์ง๋ง๋ผ๋๊ฑฐ๊ตฌ๋!! ์๋๋ฉด ๋๋ถ๋ถ for ๋ฌธ์ ์ฌ์ฉํ๋๊น..! ๋๋ ์์ผ๋ก๋ ๋จ๋ ์ผ๋ก ์ฌ์ฉํ ๋ ์ธ์๋ ๊ณ ์ฐจํจ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ์กฐ์ฌํด์ผ๊ฒ ๋ฐ!