๋ฌธ์ ์ค๋ช
์ฃผ์ฐจ์ฅ์ ์๊ธํ์ ์ฐจ๋์ด ๋ค์ด์ค๊ณ (์ ์ฐจ) ๋๊ฐ(์ถ์ฐจ) ๊ธฐ๋ก์ด ์ฃผ์ด์ก์ ๋, ์ฐจ๋๋ณ๋ก ์ฃผ์ฐจ ์๊ธ์ ๊ณ์ฐํ๋ ค๊ณ ํฉ๋๋ค. ์๋๋ ํ๋์ ์์๋ฅผ ๋ํ๋ ๋๋ค.
- ์๊ธํ
๊ธฐ๋ณธ ์๊ฐ(๋ถ)๊ธฐ๋ณธ ์๊ธ(์)๋จ์ ์๊ฐ(๋ถ)๋จ์ ์๊ธ(์)
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] |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
๋ฌธ์ ์์์ ๊ฐ์ต๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ์๊ธํ
๊ธฐ๋ณธ ์๊ฐ(๋ถ)๊ธฐ๋ณธ ์๊ธ(์)๋จ์ ์๊ฐ(๋ถ)๋จ์ ์๊ธ(์)
120 | 0 | 60 | 591 |
- ์ /์ถ์ฐจ ๊ธฐ๋ก
์๊ฐ(์:๋ถ)์ฐจ๋ ๋ฒํธ๋ด์ญ
16:00 | 3961 | ์ ์ฐจ |
16:00 | 0202 | ์ ์ฐจ |
18:00 | 3961 | ์ถ์ฐจ |
18:00 | 0202 | ์ถ์ฐจ |
23:58 | 3961 | ์ ์ฐจ |
- ์๋์ฐจ๋ณ ์ฃผ์ฐจ ์๊ธ
์ฐจ๋ ๋ฒํธ๋์ ์ฃผ์ฐจ ์๊ฐ(๋ถ)์ฃผ์ฐจ ์๊ธ(์)
0202 | 120 | 0 |
3961 | 120 + 1 = 121 | 0 +⌈(121 - 120) / 60⌉x 591 = 591 |
- 3961๋ฒ ์ฐจ๋์ 2๋ฒ์งธ ์ ์ฐจ๋ ํ์๋ ์ถ์ฐจ๋ ๋ด์ญ์ด ์์ผ๋ฏ๋ก, 23:59์ ์ถ์ฐจ๋์๋ค๊ณ ๊ฐ์ฃผํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #3
- ์๊ธํ
๊ธฐ๋ณธ ์๊ฐ(๋ถ)๊ธฐ๋ณธ ์๊ธ(์)๋จ์ ์๊ฐ(๋ถ)๋จ์ ์๊ธ(์)
1 | 461 | 1 | 10 |
- ์ /์ถ์ฐจ ๊ธฐ๋ก
์๊ฐ(์:๋ถ)์ฐจ๋ ๋ฒํธ๋ด์ญ
00:00 | 1234 | ์ ์ฐจ |
- ์๋์ฐจ๋ณ ์ฃผ์ฐจ ์๊ธ
์ฐจ๋ ๋ฒํธ๋์ ์ฃผ์ฐจ ์๊ฐ(๋ถ)์ฃผ์ฐจ ์๊ธ(์)
1234 | 1439 | 461 +⌈(1439 - 1) / 1⌉x 10 = 14841 |
- 1234๋ฒ ์ฐจ๋์ ์ถ์ฐจ ๋ด์ญ์ด ์์ผ๋ฏ๋ก, 23:59์ ์ถ์ฐจ๋์๋ค๊ณ ๊ฐ์ฃผํฉ๋๋ค.
ํ์ด
์นด์นด์ค ๋ฌธ์ ๋ต์ง ์๊ฒ ์น์ ํ ๋ฌธ์ ใ ใ ใ
import math
def solution(fees, records):
answer = []
parking_in_out = {}
parking_record = []
for i in range(len(records)): # ์๊ฐ ์ ๋ฆฌ
hour = int(records[i][:2])
mins = int(records[i][3:5])
carn = records[i][6:10]
if carn in parking_in_out:
parking_in_out[carn] += 1
else:
parking_in_out[carn] = 1
parking_record.append([carn, (hour * 60 + mins)])
for dic in parking_in_out.items(): # ์ถ์ฐจ ์๋ ์ ๋ค ์ถ๊ฐ
if dic[1] % 2 == 1:
parking_record.append([dic[0], 23 * 60 + 59])
parking_in_out[dic[0]] += 1
parking_record.sort(key=lambda x:(x[0],x[1])) # ์ฐจ๋ ๋ฒํธ ์ ์ ๋ ฌ
i = 0
while i < len(parking_record): # ์์ฆ ์ ์ฐ
fee, time = 0, 0
for ii in range(0,parking_in_out[parking_record[i][0]],2):
time += parking_record[i+ii+1][1]-parking_record[i+ii][1]
if time <= fees[0]:
fee = fees[1]
else:
time -= fees[0]
fee = fees[1] + math.ceil(time / fees[2]) * fees[3]
answer.append(fee)
i += parking_in_out[parking_record[i][0]]
return answer
๋ฌธ์ ๋ ์ด๋ ต์ง ์์๋๋ฐ ์ ์ฒ๋ฆฌ๊ฐ ์ค๋ ๊ฑธ๋ ธ๋ค.
์ ํ์ฑ ํ
์คํธ
ํ
์คํธ 1 ใ ํต๊ณผ (0.06ms, 10.3MB)
ํ
์คํธ 2 ใ ํต๊ณผ (0.03ms, 10.4MB)
ํ
์คํธ 3 ใ ํต๊ณผ (0.08ms, 10.4MB)
ํ
์คํธ 4 ใ ํต๊ณผ (0.09ms, 10.3MB)
ํ
์คํธ 5 ใ ํต๊ณผ (0.25ms, 10.4MB)
ํ
์คํธ 6 ใ ํต๊ณผ (0.29ms, 10.4MB)
ํ
์คํธ 7 ใ ํต๊ณผ (2.20ms, 10.7MB)
ํ
์คํธ 8 ใ ํต๊ณผ (1.47ms, 10.6MB)
ํ
์คํธ 9 ใ ํต๊ณผ (0.27ms, 10.4MB)
ํ
์คํธ 10 ใ ํต๊ณผ (1.89ms, 10.7MB)
ํ
์คํธ 11 ใ ํต๊ณผ (2.76ms, 10.7MB)
ํ
์คํธ 12 ใ ํต๊ณผ (2.96ms, 10.7MB)
ํ
์คํธ 13 ใ ํต๊ณผ (0.04ms, 10.4MB)
ํ
์คํธ 14 ใ ํต๊ณผ (0.04ms, 10.3MB)
ํ
์คํธ 15 ใ ํต๊ณผ (0.03ms, 10.4MB)
ํ
์คํธ 16 ใ ํต๊ณผ (0.02ms, 10.4MB)
- ์ฝ๋ ์คํ์ผ์ด ๋จผ์ง๋ค๊ณ ์ถ์ฒ์ ๋ง์ด ๋ฐ์ ์ฝ๋
from collections import defaultdict
from math import ceil
class Parking:
def __init__(self, fees):
self.fees = fees
self.in_flag = False
self.in_time = 0
self.total = 0
def update(self, t, inout):
self.in_flag = True if inout=='IN' else False
if self.in_flag: self.in_time = str2int(t)
else: self.total += (str2int(t)-self.in_time)
def calc_fee(self):
if self.in_flag: self.update('23:59', 'out')
add_t = self.total - self.fees[0]
return self.fees[1] + ceil(add_t/self.fees[2]) * self.fees[3] if add_t >= 0 else self.fees[1]
def str2int(string):
return int(string[:2])*60 + int(string[3:])
def solution(fees, records):
recordsDict = defaultdict(lambda:Parking(fees))
for rcd in records:
t, car, inout = rcd.split()
recordsDict[car].update(t, inout)
return [v.calc_fee() for k, v in sorted(recordsDict.items())]
- ๋ค๋ฅธ ์ฝ๋ ์ญ์ ๋๋ถ๋ถ ๋น์ทํ๊ฒ ์ฒ๋ฆฌ, ๋ฑํ ์ด๋ ค์ ์์๋ ๋ฌธ์
'๊ฒ์ ํ๋ก๊ทธ๋๋ฐ > Python ํ๋ก๊ทธ๋๋ฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๋ก๊ทธ๋๋จธ์ค ์คํฌ ์ฒดํฌ ํ ์คํธ Level 3 ํ๋ฝ ใ ใ ใ (0) | 2023.02.27 |
---|---|
ํ๋ก๊ทธ๋๋จธ์ค ๋ฑ๊ตฃ๊ธธ (๋์ ๊ณํ๋ฒ, Dynamic Programming) (0) | 2023.02.27 |
ํ๋ก๊ทธ๋๋จธ์ค [3์ฐจ] n์ง์ ๊ฒ์ (0) | 2023.02.27 |
ํ๋ก๊ทธ๋๋จธ์ค [3์ฐจ] ์์ถ (0) | 2023.02.26 |
ํ๋ก๊ทธ๋๋จธ์ค ์ผ๊ทผ์ง์ (0) | 2023.02.25 |