๐Today Code Test
[1] ๋ง๋ค ์ ์๋ ๊ธ์ก ๐ด
๋๋ค ํธ์์ ์ ์ฃผ์ธ์ธ ๋๋น์ด๋ N๊ฐ์ ๋์ ์ ๊ฐ์ง๊ณ ์์ต๋๋ค. ์ด๋ N๊ฐ์ ๋์ ์ ์ด์ฉํ์ฌ ๋ง๋ค ์ ์๋ ์์ ์ ์ ๊ธ์ก ์ค ์ต์๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์
์ ๋ ฅ ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์๋ ๋์ ์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์์ ์ ์ N์ด ์ฃผ์ ์ง๋๋ค. (1 ≤ N ≤ 1,000)
- ๋์งธ ์ค์๋ ๊ฐ ๋์ ์ ํํ ๋จ์๋ฅผ ๋ํ๋ด๋ N๊ฐ์ ์์ฐ์๊ฐ ์ฃผ์ด์ง๋ฉฐ, ๊ฐ ์์ฐ์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํฉ๋๋ค. ์ด๋, ๊ฐ ํํ ๋จ์๋ 1,000,000 ์ดํ์ ์์ฐ์ ์ ๋๋ค.
์ถ๋ ฅ ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ์ฃผ์ด์ง ๋์ ๋ค๋ก ๋ง๋ค ์ ์๋ ์์ ์ ์ ๊ธ์ก ์ค ์ต์๊ฐ์ ์ถ๋ ฅํฉ๋๋ค.
๐ Problem Approach
โ ํ ์ ์๋ ๋ชจ๋ ์กฐํฉ์ ๊ตฌํจ → ์กฐํฉ ์ ์๋ฅผ ์์๋๋ก ์ฒดํฌํจ → ์ฒดํฌ ์๋๋ ์ ์ถ๋ ฅ
๐Solution
#25'
n = int(input())
coins = list(map(int, input().split()))[:n]
coins.sort()
per = set(coins)
for i in range(len(coins)):
make = coins[i]
for j in range(i+1,len(coins)):
make += coins[j]
per.add(make)
cnt = 1
while True:
if cnt not in per:
print(cnt)
break
cnt += 1
# ์์ ์ฝ๋๋ ํ๋ฆผ
์์ ) input : 1 2 3 9 output : 7์ด ๋ต
๋ด ์ฝ๋๋ 4๊ฐ ๋์ด; ํฉ์ด ์๋ ๋ชจ๋ ์กฐํฉ์ ์ฐพ์ง ๋ชป ํ๊ธฐ ๋๋ฌธ
๐๊ตฌ์กฐ ์ดํด ํ๊ธฐ
step 0 1์ ๋ถํฐ ํ์ธํ๊ธฐ ์ํด target = 1
step 1 target์ด ์๋ค๋ฉด, target์ 1 + 1๋ก ์
๋ฐ์ดํธ (→ 2์๊น์ง ๋ชจ๋ ๊ธ์ก์ ๋ง๋ค ์ ์๋ค)
step 2 ๋ค์ ๋์ ์ผ๋ก ํ์ฌ target์ ๋ง์กฑ ์ํฌ ์ ์๋์ง ํ์ธ(ํ์ฌ ๋์ ๊ฐ๋ณด๋ค target์ด ์์์ผ ํ๋ค) → ๊ฐ๋ฅํ๋ค๋ฉด,
target update
step 3 ๊ณ์ ๋ฐ๋ณตํ๋ค๊ฐ, ๋์ ๊ฐ์ด target๋ณด๋ค ํฌ๋ค๋ฉด, ํ์ฌ target์ ๋ง๋ค ์ ์๋ค๋ ๋ง์ด๋ฏ๋ก ์ข
๋ฃ
step 4 target์ด ๋ง๋ค ์ ์๋ ๊ธ์ก์ด ๋๋ค.
n = int(input())
data = list(map(int, input().split())
data.sort()
target = 1
for x in data:
if target < x:
break
target += x
print target
[2] ๋ณผ๋ง๊ณต ๊ณ ๋ฅด๊ธฐ ๐ข
A, B ๋ ์ฌ๋์ด ๋ณผ๋ง์ ์น๊ณ ์์ต๋๋ค. ๋ ์ฌ๋์ ์๋ก ๋ฌด๊ฒ๊ฐ ๋ค๋ฅธ ๋ณผ๋ง๊ณต์ ๊ณ ๋ฅด๋ ค๊ณ ํฉ๋๋ค. ๋ณผ๋ง๊ณต์ ์ด N๊ฐ๊ฐ ์์ผ๋ฉฐ ๊ฐ ๋ณผ๋ง๊ณต๋ง๋ค ๋ฌด๊ฒ๊ฐ ์ ํ ์๊ณ , ๊ณต์ ๋ฒํธ๋ 1๋ฒ๋ถํฐ ์์๋๋ก ๋ถ์ฌ๋ฉ๋๋ค. ๋ํ ๊ฐ์ ๋ฌด๊ฒ์ ๊ณต์ด ์ฌ๋ฌ ๊ฐ ์์ ์ ์์ง๋ง, ์๋ก ๋ค๋ฅธ ๊ณต์ผ๋ก ๊ฐ์ฃผํฉ๋๋ค. ๋ณผ๋ง๊ณต์ ๋ฌด๊ฒ๋ 1๋ถํฐ M๊น์ง์ ์์ฐ์์ ํํ๋ก ์กด์ฌํฉ๋๋ค.
- N๊ฐ์ ๊ณต์ ๋ฌด๊ฒ๊ฐ ๊ฐ๊ฐ ์ฃผ์ด์ง ๋, ๋ ์ฌ๋์ด ๋ณผ๋ง๊ณต์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์.
์ ๋ ฅ ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ๋ณผ๋ง๊ณต์ ๊ฐ์ N, ๊ณต์ ์ต๋ ๋ฌด๊ฒ M์ด ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ๊ฐ๊ฐ ์์ฐ์ ํํ๋ก ์ฃผ์ด์ง๋๋ค.(1 ≤ N ≤ 1,000 , 1 ≤ M ≤ 10)
- ๋์งธ ์ค์ ๊ฐ ๋ณผ๋ง๊ณต์ ๋ฌด๊ฒ K๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์์๋๋ก ์์ฐ์ ํํ๋ก ์ฃผ์ด์ง๋๋ค. (1 ≤ K ≤ M)
์ถ๋ ฅ ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ๋ ์ฌ๋์ด ๋ณผ๋ง๊ณต์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
๐ Problem Approach
โ ์กฐํฉ ๊ฒฝ์ฐ์ ์ ์ถ๋ ฅํ๊ธฐ → ์กฐํฉ ๊ฒฝ์ฐ์ ์ ์ค์์ ๊ฐ์ ๋ฌด๊ฒ๋ฅผ ๊ฐ์ง ์ ๋นผ์ค์ผ → ์กฐ๊ฑด๋ฌธ์ผ๋ก ๊ฑธ๊ธฐ → ๊ฒฝ์ฐ์ ์๋๊น ํ์๋ง ์ธ๊ณ , ์ ์ฅ์ ๋ญ๋นํ์ง ๋ง๊ธฐ!
๐Solution
# 10'21"
n, m = map(int, input().split())
weights = list(map(int, input().split()))[:n]
cur = 0
cnt = 0
for i in range(len(weights)):
cur = weights[i]
for j in range(i+1,len(weights)):
if cur != weights[j]:
cnt += 1
print(cnt)
$O(n)$์ผ๋ก ํ๊ธฐ
n, m = map(int, input().split())
data = list(map(int, input().split()))
array = [0] * 11 # 1๋ถํฐ 10๊น์ง์ ๋ฌด๊ฒ๋ฅผ ๋ด์ ์ ์๋ ๋ฆฌ์คํธ
for x in data:
array[x] += 1 # ๊ฐ ๋ฌด๊ฒ์ ํด๋นํ๋ ๋ณผ๋ง๊ณต ๊ฐ์ ์นด์ดํธ
result = 0
#1๋ถํฐ m๊น์ง์ ๊ฐ ๋ฌด๊ฒ์ ๋ํ์ฌ ์ฒ๋ฆฌ
for i in range(1, m+1):
n -= array[i] # ๋ฌด๊ฒ๊ฐ i ์ธ ๋ณผ๋ง๊ณต์ ๊ฐ์ ์ ์ธ (A์ ํ)
result += array[i] * n # B๊ฐ ์ ํํ๋ ๊ฒฝ์ฐ์ ์์ ๊ณฑํ๊ธฐ
print(result)
'Code > Coding Test' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ด์ฝํ ] Implementation _ ์๋ฌผ์ ์ ์ด์ (0) | 2023.05.21 |
---|---|
[์ด์ฝํ ] Implementation _ ๋ฌธ์์ด ์์ถ (0) | 2023.05.06 |
[์ด์ฝํ ] 3์ผ์ฐจ Greedy _ ๋ฌธ์์ด ๋ค์ง๊ธฐ (0) | 2022.05.07 |
[์ด์ฝํ ] 2์ผ์ฐจ Greedy_1์ด ๋ ๋๊น์ง, ๋ชจํ๊ฐ ๊ธธ๋, ๊ณฑํ๊ธฐ ํน์ ๋ํ๊ธฐ (0) | 2022.05.06 |
[์ด์ฝํ ] 1์ผ์ฐจ Greedy _ ํฐ ์์ ๋ฒ์น, ์ซ์ ์นด๋ ๊ฒ์ (0) | 2022.05.04 |
๋๊ธ