๐ ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์ ๋งํฌ
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
โ๐ป ๋ฌธ์ ํ์ด Github ๋งํฌ
-Swift-CodingTest/ํ๋ก๊ทธ๋๋จธ์ค/2/42586.โ ๊ธฐ๋ฅ๊ฐ๋ฐ at main · BaeJihae/-Swift-CodingTest
Swift๋ก ํผ ์ฝ๋ฉ ํ ์คํธ ๋ฌธ์ ๋ค์ ์ ๋ฆฌํ๊ณ ๊ณต๋ถํ๋ ๊ณต๊ฐ์ ๋๋ค. Contribute to BaeJihae/-Swift-CodingTest development by creating an account on GitHub.
github.com
๋ฌธ์ ์ค๋ช
ํ๋ก๊ทธ๋๋จธ์ค ํ์์๋ ๊ธฐ๋ฅ ๊ฐ์ ์์ ์ ์ํ ์ค์ ๋๋ค. ๊ฐ ๊ธฐ๋ฅ์ ์ง๋๊ฐ 100%์ผ ๋ ์๋น์ค์ ๋ฐ์ํ ์ ์์ต๋๋ค.
๋, ๊ฐ ๊ธฐ๋ฅ์ ๊ฐ๋ฐ์๋๋ ๋ชจ๋ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ๋ค์ ์๋ ๊ธฐ๋ฅ์ด ์์ ์๋ ๊ธฐ๋ฅ๋ณด๋ค ๋จผ์ ๊ฐ๋ฐ๋ ์ ์๊ณ , ์ด๋ ๋ค์ ์๋ ๊ธฐ๋ฅ์ ์์ ์๋ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋ ๋ ํจ๊ป ๋ฐฐํฌ๋ฉ๋๋ค.
๋จผ์ ๋ฐฐํฌ๋์ด์ผ ํ๋ ์์๋๋ก ์์ ์ ์ง๋๊ฐ ์ ํ ์ ์ ๋ฐฐ์ด progresses์ ๊ฐ ์์ ์ ๊ฐ๋ฐ ์๋๊ฐ ์ ํ ์ ์ ๋ฐฐ์ด speeds๊ฐ ์ฃผ์ด์ง ๋ ๊ฐ ๋ฐฐํฌ๋ง๋ค ๋ช ๊ฐ์ ๊ธฐ๋ฅ์ด ๋ฐฐํฌ๋๋์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ ์ฌํญ
- ์์ ์ ๊ฐ์(progresses, speeds๋ฐฐ์ด์ ๊ธธ์ด)๋ 100๊ฐ ์ดํ์ ๋๋ค.
- ์์ ์ง๋๋ 100 ๋ฏธ๋ง์ ์์ฐ์์ ๋๋ค.
- ์์ ์๋๋ 100 ์ดํ์ ์์ฐ์์ ๋๋ค.
- ๋ฐฐํฌ๋ ํ๋ฃจ์ ํ ๋ฒ๋ง ํ ์ ์์ผ๋ฉฐ, ํ๋ฃจ์ ๋์ ์ด๋ฃจ์ด์ง๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด ์ง๋์จ์ด 95%์ธ ์์ ์ ๊ฐ๋ฐ ์๋๊ฐ ํ๋ฃจ์ 4%๋ผ๋ฉด ๋ฐฐํฌ๋ 2์ผ ๋ค์ ์ด๋ฃจ์ด์ง๋๋ค.
์ ์ถ๋ ฅ ์
progresses | speeds | return |
[93, 30, 55] | [1, 30, 5] | [2, 1] |
[95, 90, 99, 99, 80, 99] | [1, 1, 1, 1, 1, 1] | [1, 3, 2] |
๋ฌธ์ ํ์ด
๋์ ํ์ด
import Foundation
func solution(_ progresses:[Int], _ speeds:[Int]) -> [Int] {
var numberOfRemaining = zip(progresses, speeds).map{ Int(ceil(Double(100 - $0) / Double($1))) }
numberOfRemaining.append(100)
var answer = [Int]()
var a = numberOfRemaining[0]
var count = 0
for i in numberOfRemaining {
if a >= i {
count += 1
}else {
answer.append(count)
a = i
count = 1
}
}
return answer
}
์ฌ์ค ๊ธฐ๊ฐ๋งํ๊ฒ ์ ํ์๋ค๊ณ ๋ ๋๋ตํ์ง ๋ชปํ ํ์ด์ธ๊ฑฐ ๊ฐ๋ค.
๋ด ์ค์ค๋ก๋ ๋ณต์กํ๊ฒ ํ์๋ค๋ ์๊ฐ์ด ๋ค์๋ค.
๋ต์ ๋ด๊ธฐ ์ํด ๋ผ์ด๋ง์ถ๋ฏ์ด 100์ด๋ผ๋ ์ซ์๋ฅผ ๋ฐฐ์ด์ ๋งจ๋์ ์ถ๊ฐํ์๊ณ ,
a๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค๋ฉด count๋ฅผ ์ฌ๋ฆฌ๊ณ ๋ฐ๋๋ฉด์ ํด๋น count๋ฅผ ๋ฐฐ์ด์ ์ถ๊ฐํ์ฌ ์ง๊ด์ ์ผ๋ก ์ ๊ทผํ๋ค.
ํ์ง๋ง numberOfRemaining ๋ฐฐ์ด์ ๊ตฌํ ๋ถ๋ถ์ ์์ฃผ ์ ํ๋ค๊ณ ์๊ฐํ๋ค.
๋ค๋ฅธ ์ฌ๋ ํ์ด
import Foundation
func solution(_ progresses:[Int], _ speeds:[Int]) -> [Int] {
return zip(progresses, speeds)
.map { (100 - $0) / $1 }
.reduce(([], 0)) { (tuple, day) -> ([Int], Int) in
let (list, lastMax) = tuple
guard let lastCount = list.last else {
return ([1], day)
}
if lastMax >= day {
return (list.dropLast() + [lastCount + 1], lastMax)
}
return (list + [1], day)
}.0
}
๋ด๊ฐ ๋จธ๋ฆฟ์์ผ๋ก ํ๊ณ ์ถ์๋ ํ์ด์ด๋ค.
ํ์ง๋ง, ์ค์ ๋ก๋ reduce์ ํด๋ก์ ํจ์์ ๊ฐํ์ ํ์ด๋ด์ง ๋ชปํ์๋ค.
tuple๋ก ํ์ด๋์ ๊ฐํํ๊ณ , ๋ ๊ฐํํ๋ค. reduce ํจ์๋ ์ด๋ ๊ฒ ์ฐ๋ ๊ฑฐ๊ตฌ๋..?
์ค์ํ ๊ฐ๋
- ๋ฐ์ฌ๋ฆผ - round
- ์ฌ๋ฆผ - ceil
- ๋ด๋ฆผ - floor
- ๋ฒ๋ฆผ - trunc