๐ ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์ ๋งํฌ
โ๐ป ๋ฌธ์ ํ์ด Github ๋งํฌ
๋ฌธ์ ์ค๋ช
์ฃผ์ฐจ์ฅ์ ์๊ธํ์ ์ฐจ๋์ด ๋ค์ด์ค๊ณ (์ ์ฐจ) ๋๊ฐ(์ถ์ฐจ) ๊ธฐ๋ก์ด ์ฃผ์ด์ก์ ๋, ์ฐจ๋๋ณ๋ก ์ฃผ์ฐจ ์๊ธ์ ๊ณ์ฐํ๋ ค๊ณ ํฉ๋๋ค. ์๋๋ ํ๋์ ์์๋ฅผ ๋ํ๋ ๋๋ค.
- ์๊ธํ
๊ธฐ๋ณธ ์๊ฐ(๋ถ) | ๊ธฐ๋ณธ ์๊ธ(์) | ๋จ์ ์๊ฐ(๋ถ) | ๋จ์ ์๊ธ(์) |
180 | 5000 | 10 | 600 |
- ์ /์ถ์ฐจ ๊ธฐ๋ก
์๊ฐ(์:๋ถ) | ์ฐจ๋ ๋ฒํธ | ๋ด์ญ |
05:34 | 5961 | ์ ์ฐจ |
06:00 | 0000 | ์ ์ฐจ |
06:34 | 0000 | ์ถ์ฐจ |
07:59 | 5961 | ์ถ์ฐจ |
07:59 | 0148 | ์ ์ฐจ |
18:59 | 0000 | ์ ์ฐจ |
19:09 | 0148 | ์ถ์ฐจ |
22:59 | 5961 | ์ ์ฐจ |
23:00 | 5961 | ์ถ์ฐจ |
- ์๋์ฐจ๋ณ ์ฃผ์ฐจ ์๊ธ
์ฐจ๋ ๋ฒํธ | ๋์ ์ฃผ์ฐจ ์๊ฐ(๋ถ) | ์ฃผ์ฐจ ์๊ธ(์) |
0000 | 34 + 300 = 334 | 5000 + ⌈(334 - 180) / 10⌉ x 600 = 14600 |
0148 | 670 | 5000 +⌈(670 - 180) / 10⌉x 600 = 34400 |
5961 | 145 + 1 = 146 | 5000 |
- ์ด๋ค ์ฐจ๋์ด ์
์ฐจ๋ ํ์ ์ถ์ฐจ๋ ๋ด์ญ์ด ์๋ค๋ฉด, 23:59์ ์ถ์ฐจ๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค.
- 0000๋ฒ ์ฐจ๋์ 18:59์ ์ ์ฐจ๋ ์ดํ, ์ถ์ฐจ๋ ๋ด์ญ์ด ์์ต๋๋ค. ๋ฐ๋ผ์, 23:59์ ์ถ์ฐจ๋ ๊ฒ์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค.
- 00:00๋ถํฐ 23:59๊น์ง์ ์ /์ถ์ฐจ ๋ด์ญ์ ๋ฐํ์ผ๋ก ์ฐจ๋๋ณ ๋์ ์ฃผ์ฐจ ์๊ฐ์ ๊ณ์ฐํ์ฌ ์๊ธ์ ์ผ๊ด๋ก ์ ์ฐํฉ๋๋ค.
- ๋์ ์ฃผ์ฐจ ์๊ฐ์ด ๊ธฐ๋ณธ ์๊ฐ์ดํ๋ผ๋ฉด, ๊ธฐ๋ณธ ์๊ธ์ ์ฒญ๊ตฌํฉ๋๋ค.
- ๋์ ์ฃผ์ฐจ ์๊ฐ์ด ๊ธฐ๋ณธ ์๊ฐ์ ์ด๊ณผํ๋ฉด, ๊ธฐ๋ณธ ์๊ธ์ ๋ํด์, ์ด๊ณผํ ์๊ฐ์ ๋ํด์ ๋จ์ ์๊ฐ ๋ง๋ค ๋จ์ ์๊ธ์ ์ฒญ๊ตฌํฉ๋๋ค.
- ์ด๊ณผํ ์๊ฐ์ด ๋จ์ ์๊ฐ์ผ๋ก ๋๋์ด ๋จ์ด์ง์ง ์์ผ๋ฉด, ์ฌ๋ฆผํฉ๋๋ค.
- ⌈a⌉ : a๋ณด๋ค ์์ง ์์ ์ต์์ ์ ์๋ฅผ ์๋ฏธํฉ๋๋ค. ์ฆ, ์ฌ๋ฆผ์ ์๋ฏธํฉ๋๋ค.
์ฃผ์ฐจ ์๊ธ์ ๋ํ๋ด๋ ์ ์ ๋ฐฐ์ด fees, ์๋์ฐจ์ ์ /์ถ์ฐจ ๋ด์ญ์ ๋ํ๋ด๋ ๋ฌธ์์ด ๋ฐฐ์ด records๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ฐจ๋ ๋ฒํธ๊ฐ ์์ ์๋์ฐจ๋ถํฐ ์ฒญ๊ตฌํ ์ฃผ์ฐจ ์๊ธ์ ์ฐจ๋ก๋๋ก ์ ์ ๋ฐฐ์ด์ ๋ด์์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- fees์ ๊ธธ์ด = 4
- fees[0] = ๊ธฐ๋ณธ ์๊ฐ(๋ถ)
- 1 ≤ fees[0] ≤ 1,439
- fees[1] = ๊ธฐ๋ณธ ์๊ธ(์)
- 0 ≤ fees[1] ≤ 100,000
- fees[2] = ๋จ์ ์๊ฐ(๋ถ)
- 1 ≤ fees[2] ≤ 1,439
- fees[3] = ๋จ์ ์๊ธ(์)
- 1 ≤ fees[3] ≤ 10,000
- 1 ≤ records์ ๊ธธ์ด ≤ 1,000
- records์ ๊ฐ ์์๋ "์๊ฐ ์ฐจ๋๋ฒํธ ๋ด์ญ" ํ์์ ๋ฌธ์์ด์ ๋๋ค.
- ์๊ฐ, ์ฐจ๋๋ฒํธ, ๋ด์ญ์ ํ๋์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์์ต๋๋ค.
- ์๊ฐ์ ์ฐจ๋์ด ์
์ฐจ๋๊ฑฐ๋ ์ถ์ฐจ๋ ์๊ฐ์ ๋ํ๋ด๋ฉฐ, HH:MM ํ์์ ๊ธธ์ด 5์ธ ๋ฌธ์์ด์
๋๋ค.
- HH:MM์ 00:00๋ถํฐ 23:59๊น์ง ์ฃผ์ด์ง๋๋ค.
- ์๋ชป๋ ์๊ฐ("25:22", "09:65" ๋ฑ)์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ์ฐจ๋๋ฒํธ๋ ์๋์ฐจ๋ฅผ ๊ตฌ๋ถํ๊ธฐ ์ํ, `0'~'9'๋ก ๊ตฌ์ฑ๋ ๊ธธ์ด 4์ธ ๋ฌธ์์ด์ ๋๋ค.
- ๋ด์ญ์ ๊ธธ์ด 2 ๋๋ 3์ธ ๋ฌธ์์ด๋ก, IN ๋๋ OUT์ ๋๋ค. IN์ ์ ์ฐจ๋ฅผ, OUT์ ์ถ์ฐจ๋ฅผ ์๋ฏธํฉ๋๋ค.
- records์ ์์๋ค์ ์๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์ฃผ์ด์ง๋๋ค.
- records๋ ํ๋ฃจ ๋์์ ์ /์ถ์ฐจ๋ ๊ธฐ๋ก๋ง ๋ด๊ณ ์์ผ๋ฉฐ, ์ ์ฐจ๋ ์ฐจ๋์ด ๋ค์๋ ์ถ์ฐจ๋๋ ๊ฒฝ์ฐ๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ๊ฐ์ ์๊ฐ์, ๊ฐ์ ์ฐจ๋๋ฒํธ์ ๋ด์ญ์ด 2๋ฒ ์ด์ ๋ํ๋ด์ง ์์ต๋๋ค.
- ๋ง์ง๋ง ์๊ฐ(23:59)์ ์ ์ฐจ๋๋ ๊ฒฝ์ฐ๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ์๋์ ์๋ฅผ ํฌํจํ์ฌ, ์๋ชป๋ ์
๋ ฅ์ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ์ฃผ์ฐจ์ฅ์ ์๋ ์ฐจ๋์ด ์ถ์ฐจ๋๋ ๊ฒฝ์ฐ
- ์ฃผ์ฐจ์ฅ์ ์ด๋ฏธ ์๋ ์ฐจ๋(์ฐจ๋๋ฒํธ๊ฐ ๊ฐ์ ์ฐจ๋)์ด ๋ค์ ์ ์ฐจ๋๋ ๊ฒฝ์ฐ
์ ์ถ๋ ฅ ์
fees | records | result |
[180, 5000, 10, 600] | ["05:34 5961 IN", "06:00 0000 IN", "06:34 0000 OUT", "07:59 5961 OUT", "07:59 0148 IN", "18:59 0000 IN", "19:09 0148 OUT", "22:59 5961 IN", "23:00 5961 OUT"] | [14600, 34400, 5000] |
[120, 0, 60, 591] | ["16:00 3961 IN","16:00 0202 IN","18:00 3961 OUT","18:00 0202 OUT","23:58 3961 IN"] | [0, 591] |
[1, 461, 1, 10] | ["00:00 1234 IN"] | [14841] |
๋ฌธ์ ํ์ด
๋์ ํ์ด
import Foundation
func solution(_ fees:[Int], _ records:[String]) -> [Int] {
// ์ฐจ๋์ ์
์ฐจ/์ถ์ฐจ ์ ๋ณด์ ์๊ฐ์ ๋ถ์ผ๋ก ํ์ฐ
var carDict = [Int:(isIn: Bool, minute: Int)]()
// ์ฐจ๋์ ์๊ธ
var feeDict = [Int:Int]()
// ์
์ฐจ ์ถ์ฐจ์ ๋ฐ๋ฅธ ์ฐจ๋ ์๊ธ ๊ณ์ฐ
for record in records {
let carInOut = record.split(separator: " ")
let clock = carInOut[0].split(separator: ":")
let minute = Int(clock[0])! * 60 + Int(clock[1])!
let carNum = Int(String(carInOut[1]))!
let isIn = carInOut[2] == "IN" ? true : false
if !(carDict[carNum] ?? (isIn: false, minute: 0)).isIn {
carDict[carNum] = (isIn: isIn, minute: minute)
}else if !isIn {
feeDict[carNum] = ( feeDict[carNum] ?? 0 ) + ( minute - carDict[carNum]!.minute )
carDict[carNum] = (isIn: isIn, minute: minute)
}
}
// ์ถ์ฐจ๊ฐ ๋์ง ์์ ์ฐจ๋ ์๊ธ ๊ณ์ฐ
for car in carDict {
if car.value.isIn {
feeDict[car.key] = ( feeDict[car.key] ?? 0 ) + ( 1439 - car.value.minute )
}
}
// ์๊ธ ๊ณ์ฐ
for fee in feeDict {
if fee.value > fees[0]{
var value = Double(fee.value-fees[0])/Double(fees[2])
feeDict[fee.key] = fees[1] + Int(ceil(value))*fees[3]
}else {
feeDict[fee.key] = fees[1]
}
}
return feeDict.sorted{ $0.key < $1.key }.map{ $0.value }
}
์ฒ์ ๋ฌธ์ ๋ฅผ ๋ณด์๋ง์ ์๊ฐ์ ๋ฐ๋ฅธ ๋ถ์ ๊ณ์ฐํ๋ ๋ฐฉ๋ฒ์ผ๋ก ์๊ฐ ์ฐจ๋ฅผ ๋น๊ตํด์ ๊ณ์ฐ์ ํด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๊ณ , ์ ์ฐจ์ ์ถ์ฐจ๋ฅผ ์ด๋ป๊ฒ ๊ตฌ๋ถํ์ฌ ๋ฌธ์ ๋ฅผ ํ์ง๋ผ๋ ์๊ฐ์ ๋์ ๋๋ฆฌ์ Bool ๊ฐ์ด ๋ค์ด์๋ ํํ์ ์ฌ์ฉํด์ ํธ๋ ๋ฐฉ๋ฒ์ ์๊ฐํ๋ค.
๊ทธ๋ ๊ฒ ์ถ์ฐจ ์ ๋ณด๊ฐ ์ ์ฅ๋์ด์๋ records๋ฅผ ํ์ธํ๋ฉด์ ์ถ์ฐจ ์ ๋ณด๊ฐ false์ด๊ฑฐ๋ ๋์ ๋๋ฆฌ์ ํด๋น ์ฐจ๋ ๋๋ฒ๊ฐ ๋ฑ๋ก๋์ด ์์ง ์๋ค๋ฉด ์๋ก์ด ๊ฐ์ carDict์ ์ ์ฅํ๊ณ , ์ถ์ฐจ์ ๋ณด๊ฐ ์๋ true ๊ฐ์ด์๋๋ฐ false ๊ฐ์ผ๋ก ๋ค์ด์๋ค๋ฉด, ์ ์ฐจ์ ์ถ์ฐจ ์๊ฐ์ ๋น๊ตํด์ ์๋ก์ด ๋์ ๋๋ฆฌ์ธ ์๊ธ์ ์ ์ฅํ๋ feeDict์ ์๊ฐ์ ์ ์ฅํด์ฃผ์๋ค. ์๊ฐ์ ์ ์ฅํ ๋๋ ์์ ์ ์ฅํ ๊ฐ์ ์ถ๊ฐ๋ก ๋ํ๋ ์์ผ๋ก ์ ์ฅํ์๋ค. ์ถ์ฐจ์ ๋ณด๊ฐ ์๋ true ๊ฐ์ด์๋๋ฐ false๊ฐ์ผ๋ก ๋ค์ด์ค๊ฒ๋ ์ค์ ํ๋ ๊ณผ์ ์์ ์๋์ผ๋ก ์ ์ฐจ๊ฐ ๋๋ฒ๋ค์ด์์ ๊ฒฝ์ฐ ๋ค์ ๋ค์ด์จ ์ ์ฐจ์ ๋ณด๋ฅผ ๋ฌด์ํ๋๋ก ํ์๋ค.
records๋ฅผ ๋ค ํ์ธํ ํ์ ์ถ์ฐจ๊ฐ ๋์ง ์๋ ์ฐจ๋๋ค์ ์๊ฐ ๊ณ์ฐ์ ๋ฐ๋ก ํด์ฃผ์๊ณ , ๋ง์ง๋ง์ผ๋ก ํด๋น ์๊ธ๋ค์ ๊ณ์ฐํด์ฃผ์๋ค. ๊ฐ์ ์ถ๋ ฅํ๋ ๊ณผ์ ์์ ์๋ String๊ฐ์ผ๋ก ์ฐจ๋ ๋ฒํธ๋ฅผ ์ ์ฅํ๋๋ฐ, ์ฐจ๋ ๋ฒํธ๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ต์ ์ถ๋ ฅํด์ผํด์ Int๊ฐ์ผ๋ก ์ ์ฅํ๋๋ก ๋ฐ๊พธ์๋ค.