๋ค์ด๋ฒ ์ฝํ ๋ฅผ ๋ณด๊ธฐ ์ํด์ Codility๋ฅผ ์ฒ์์ผ๋ก ์ด์ฉํด๋ณด์๋ค. codility์์ ์ฝ๋๋ฅผ ์์ฑํ๋ ๋ถ๋ถ์ programmers์ ํฌ๊ฒ ๋ค๋ฅผ๋ฐ๊ฐ ์์๊ณ , ๋ ์ข์๋ ์ ์, ์๊ฐ๋ณต์ก๋์ ๋ํ ๊ฒ์ฆ์ ๋ ์์ธํ๊ฒ ํด์ค๋ค๋ ๊ฒ์ด์๋ค!
์ผ๋จ '๊ธฐ์ด'๋ถํฐ ๋ค์ ์ก์๋ ๋ง์ธ๋๋ก ๊ณต๋ถ์ค์ธ ์์ฆ, ์ผ๋จ Lesson์ ์๋ Medium ๋ฌธ์ ๋ค๋ง ๋จผ์ ๊ณจ๋ผ์ ํ์๋ค.
๐ ๋ฌธ์
https://app.codility.com/programmers/lessons/4-counting_elements/max_counters/start/
๋ฌธ์ ๋ ์ ๋ถ... ์์ด๋ค...๐ฅน
๐ ์ค๋ต์ผ๋ก ์์๊ฐ๋ ๋ด ์ฝ๋์ ๋ฌธ์ ์
์ฒ์ ์ค๋ต ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค
public func solution(_ N : Int, _ A : inout [Int]) -> [Int] {
var answer = Array(repeating: 0, count: N)
for idx in 0..<A.count {
if A[idx] == N+1 {
let max = answer.max()!
answer = Array(repeating: max, count: N)
} else {
answer[A[idx]-1] += 1
}
print(answer)
}
return answer
}
print(solution(N, &A))
์ด๋ ๊ฒ ํ๋๊น, ์ ๋ต์ ๋ง์ท์ง๋ง, ํจ์จ์ฑํ ์คํธ(์๊ฐ๋ณต์ก๋)์์ ์ ๋ถ fail์ ๋ฐ์๋ค. ์์ผ๊น?
์ด ๋ฌธ์ ์์๋ ๋๊ฐ์ง์ ์ฐ์ฐ์ด ์ํ๋๋ค. N+1๊ณผ ๊ฐ์ง ์๋ค๋ฉด, +1 ์ฐ์ฐ์ ์ํํ๊ณ , ๊ฐ๋ค๋ฉด ๋ฐฐ์ด ์ ์ฒด๋ฅผ Max๋ก ๋ฐ๊ฟ์ฃผ๋ ์ฐ์ฐ์ ์ํํด์ผํ๋ค. ์ฌ๊ธฐ์ ํต์ฌ์, ๋ฐฐ์ด ์ ์ฒด๋ฅผ ๋ฐ๊ฟ์ฃผ๋ ๋ถ๋ถ์์ ๋ฐ์ํ๋ค.
๋๋ ์ญ์๋, answer๋ฐฐ์ด์ ์๋กญ๊ฒ max๊ฐ์ผ๋ก ๊ฐฑ์ ํ๋ ๋ฐฉ์์ผ๋ก ์งํํ๋ค. ์ด ๊ณผ์ ์์, ๋ฐฐ์ด์ด ์์ฃผ ์ปค์ง ๊ฒฝ์ฐ, ์๊ฐ๋ณต์ก๋๊ฐ ๊ต์ฅํ ์ปค์ง๊ฒ์ผ๋ก ์์๋๋ค. ์ ์๋ฅผ๋ค์ด ํ์ฌ ๋ด๊ฐ ์ง ์ฝ๋์ ์๊ฐ๋ณต์ก๋๋ O(N+M)์ธ๋ฐ, ๋ง์ฝ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ 10000์ผ๊ฒฝ์ฐ, for๋ฌธ ๋ด์์ ์ต๋ 10000๋ฒ์ ๋ฐฐ์ด๊ฐฑ์ ์ด ์ด๋ฃจ์ด์ง๋ค. fo๋ฌธ์ ์ค์ผ ์๋ ์๊ณ , ์ด ์ฐ์ฐ์ ์ต์ํํ ์ ์์๊น?
(์ธํฐ๋ท์ ๋์์ ์กฐ๊ธ ๋ฐ์๋คใ ใ ์์ง ๋๋ฌด ๋ฉ์ฒญ,,ํด,, ํ) max์ฐ์ฐ์ ์ต์ํํด์ผํ๋ค. ๊ทธ๋ ๋ค๋ฉด, max๊ฐ์ ๋ค๋ฅธ๊ณณ์ ์ ์ฅํด๋๊ณ , ํ์ํ ๋๋ง max๊ฐ์ ๊ฐฑ์ ํด์ฃผ๋ฉด ์ด๋จ๊น! ์ด ๋ฐฉ์์ผ๋ก ์ฝ๋๋ฅผ ์ง๋ด์ผํ๋ค.
๐ ์ ๋ต์ฝ๋
์๋์ ๊ฐ์ ํ์์ผ๋ก ์ฝ๋๋ฅผ ์งฐ๋ค. ์ฝ๋๋ฅผ ์กฐ๊ธ ํ์ด๋ณด์๋ฉด ์๋์ ๊ฐ๋ค.
- currentMax: N+1์ผ ๋, ๋ฐ๊ฟ์ค ํ์ฌ ๊ฐ์ฅ ํฐ max ๊ฐ์ด๋ค.
- nextMax: +1ํ์๋ ๋ง์ฝ ํด๋น ๊ฐ์ด ๊ฐ์ฅ max๊ฐ์ด๋ผ๋ฉด, nextMax์ ์ ๊น ๋ฃ์ด์ค๋ค.
- for๋ฌธ
- N+1์ด ์๋๋ผ๋ฉด, +1 ์ฐ์ฐ์ ์ํํ๋ค.
- ํ์ฌ ๊ฐ์ด currentMax๊ฐ๋ณด๋ค ์๋ค๋ฉด, max๊ฐ์ด ์๋๋๊น max๊ฐ์ผ๋ก ๋ฐ๊ฟ์ค๋ค.
- ๊ทธ๋ฆฌ๊ณ +1 ํด์ค๋ค.
- ๋ง์ฝ, ํด๋น ๊ฐ์ด nextMax๋ณด๋ค์์ผ๋ฉด, currentMax๊ฐ์ด ๋ ๋ช ๋ถ์ด ์ถฉ๋ถํ ๋๋๊น, next์ ์ ๊น ๋ฃ์ด์ค๋ค.
- N+1 ์ด๋ผ๋ฉด
- currentMax์ nextMax๋ฅผ ๋ฃ์ด์ฃผ๋ฉด์, max๊ฐ์ ๊ฐฑ์ ํด์ค๋ค.
- ๋ง์ง๋ง์ max๊ฐ์ผ๋ก ๋ณํ์ง ์์ ๊ฒ๋ค์ currentMax์ ๋น๊ตํด์ ๋ฐ๊ฟ์ค๋ค.
public func solution(_ N : Int, _ A : inout [Int]) -> [Int] {
var answer = Array(repeating: 0, count: N)
var currentMax = 0
var nextMax = 0
for a in A {
// N+1 ์ด ์๋๋ผ๋ฉด
if a != N+1 {
// +1 ์ฐ์ฐํด์ค์ผํด
// ๊ทธ์ ์ currentmax๊ฐ์ด ์กด์ฌํ๋ค๋ฉด, ๊ทธ ๊ฐ์ผ๋ก ๋ฐ๊ฟ์ฃผ๊ณ
// (max๊ฐ๋ณด๋ค ์์๊ฒฝ์ฐ, ๋ฐ๊ฟ์ค, ๋ง์ฝ ํฌ๋ฉด? ์ด๋ฏธ +1์ฉ ๋ํ๊ณ ์๋ค๋ ๋ป
if answer[a-1] <= currentMax {
answer[a-1] = currentMax
}
answer[a-1] += 1
// ๋ง์ฝ ์ง๊ธ +1 ํด์ค ๊ฐ์ด max๊ฐ ๋ ๊ฐ๋ฅ์ฑ์ด ์๋ค๋ฉด
// nextmax์ ๋ฃ์ด์ค,,, (๋ค์์ ๋ฐ๊ถ์ค๋ ์ฌ์ฉ)
if answer[a-1] > nextMax {
nextMax = answer[a-1]
}
} else {
currentMax = nextMax
}
}
// ์ต๋๊ฐ์ผ๋ก ๋ฐ๊ฟ์ง์ง ์์ ๊ฒ๋ค ๋ฐ๊ฟ์ฃผ๊ธฐ
for idx in 0..<answer.count {
if answer[idx] < currentMax {
answer[idx] = currentMax
}
}
return answer
}
print(solution(N, &A))
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] ๋ฐฑ์ค ๋ฌธ์ ํ์ด๋ฅผ ์ํ ์ ์ถ๋ ฅ ๋ฐฉ๋ฒ (sys.stdin.readline(), input() ์ฐจ์ด์ ) (0) | 2024.06.15 |
---|---|
[Codility] (Swift) CountDiv (0) | 2022.12.22 |