๐ ๋ฌธ์
https://school.programmers.co.kr/learn/courses/30/lessons/42883
๐ ๋์ ํ์ด
๊ฐ์ฅ์ค์ํ ๊ฒ์ ์ ๋ ฅ๋ ์์ ๊ทธ๋๋ก๋ฅผ ์ ์งํ๊ณ ์ซ์๋ฅผ ์ญ์ ์ํค๋ ๊ฒ์ด์๋ค. ๋ฌด์กฐ๊ฑด ์์ ์ซ์๋ง์ ์ฐพ์์ ์ญ์ ํ๋ ๊ฒ์ด ์๋๋ผ, ์ ๋ ฅ๋ฐ์ number์์ ์ ์ ํ ์์น์ ์๋ ์ซ์๋ค์ ์ญ์ ํ์ฌ ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ง๋ค์ด๋ด๋๊ฒ ํต์ฌ์ด์๋ค.
์ฌ๊ธฐ์ ๋ด๊ฐ ์บ์นํด๋ธ๊ฑด, ๋จผ์ K๋ฒ์งธ ์๊น์ง ๋น๊ตํด์ ๋งจ์์๋ฆฌ์ ๊ฐ์ฅ ์ ๋นํ ํฐ ์๊ฐ ์ค๊ฒ ๋ง๋ค์ด์ฃผ๋๊ฒ.
๋จผ์ ์ด๊ฒ์ ํ์ ํ๋ค. ์ด๋ ๊ฒ ํ๊ฒ ๋๋ฉด, ์ด ์ดํ์ ์ซ์๋ค์ ๋น๊ตํด๊ฐ๋ฉด์ ํฐ ์๋ฅผ ๋ฝ์์ฃผ๋๊ฒ ์๋๊ฐ? ์ถ์๋ค. ์ฝ๋๋ฅผ ์ด๋ป๊ฒ ์ง์ผํ ์ง ๋ง๋งํ์ง๋ง ์ผ๋จ ๋ง ํ์ด๋ฅผ ์๊ฐํด๋ดค๋ค.
๊ทธ๋ฆฌ๊ณ ์ด๊ฒ์ ์ด์ ๋ฐ๋ณต๋ฌธ์ ๋๋ ค์ ์ฐพ์์ฃผ์ด์ผํ๋๋ฐ,,, ์ด๋ฐ์ ์ด๋ป๊ฒ for๋ฌธ์ ๋๋ ค์ผํ ์ง ๋ง๋งํ๋ค. ํ์ฌ ์ธ๋ฑ์ค๋ก ์ ํ๋ ์น๊ตฌ ๊ทธ ๋ค์๋ถํฐ ๋ด์ผํ๊ธฐ ๋๋ฌธ์ currentIdx์ nextIdx๋ฅผ ๋์ด์ for๋ฌธ์ ๋๋ ค์ฃผ์๋ค. ๊ทธ๋ฆฌ๊ณ ์ด 6์๋ฆฌ๊ฐ ๋์์ผํ๊ธฐ ๋๋ฌธ์ ์ซ์ ์ ํ๋ for๋ฌธ์ ์ด์ฉํด์ 6๋ฒ๋ง ํด์ฃผ๋ฉด ๋ ๊ฒ์ด๋ผ๊ณ ํ๋จํ๋ค. ๊ทธ๋ฆฌ๊ณ ์๋์ ๊ฐ์ด ์๊ฐ์ ํ๊ณ ์ฝ๋๋ก ๊ตฌํํ๋ค.
โ ์ฒซ๋ฒ์งธ ํ์ด - ํ ์ผ 10 ์๊ฐ์ด๊ณผ
๊ทธ๋ฅ ๋ ๋ค ๊ตฌํํ๋๋ฐ, ์ ๋ต์ ๋ง์์ง๋ง ํ ์ผ 10๋ฒ ํ๋์์ ์๊ฐ์ด๊ณผ๊ฐ ๋ฌ๋ค. ๋ญ ๋๋ฌธ์ผ๊น ใ ใ
import Foundation
func solution(_ number:String, _ k:Int) -> String {
let numArr = number.map{ Int(String($0))! }
var answer = [Int]()
var nextIdx = 0
var currentIdx = 0
for i in 0..<number.count - k {
var tempMax = -999
for j in nextIdx...i+k {
if tempMax < numArr[j] {
tempMax = numArr[j]
currentIdx = j
}
}
answer.append(tempMax)
nextIdx = currentIdx + 1
}
return answer.map{ String($0) }.joined()
}
์ผ๋จ ๋ด๊ฐ ์ง๊ธ ์ง ์ฝ๋๋ O(n^2)์ด๊ณ , ์ฃผ์ด์ง๋ nubmer๊ฐ์ฅ ํฐ ์๊ฐ 100๋ง์ด๋ค. 100๋งx100๋ง์ด ๋๋ค๋ฉด, ๊ฑฐ์ 1์ต ๊ฐ๊น์ด ๋๋ ๋งํผ for๋ฌธ์ด ๋์๊ฐ ๊ฒ์ด๋ค. ์๊ฐ์ด๊ณผ๊ฐ ๋๋ฏ๋ก ์๊ฐ๋ณต์ก๋๋ฅผ O(n)์ผ๋ก ์ค์ฌ์ฃผ๋ ํ์ด๊ฐ ํ์ํด ๋ณด์ธ๋ค.
๋ฏธ์ณ๋์๊ฐ๋ค.. ์๊ฐ์ด๊ณผ......
โ ๋๋ฒ์งธ ํ์ด - stack์ ์ฌ์ฉํ ํ์ด (์ ๋ต์ฝ๋)
์ธํฐ๋ท์ ์ฐธ๊ณ ํ๋ค.... stack์ ์ฌ์ฉํด์ ํ์ด๋ณด๋ผ๋ ์๊ฒฌ์ด ๋ง์๋ค. ๊ทธ๋ผ O(n)์ ์๊ฐ๋ณต์ก๋๋ก ํ ์ ์๋ค๊ณ ํ๋ค. ๋ด๊ฐ ์ง๊ธ ํผ ํ์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก stack์ ์ด๋ป๊ฒ ์ฌ์ฉํ ๊ฒ์ธ์ง ๋จธ๋ฆฌ๋ฅผ ๊ตด๋ ค๋ณด์๋ฐ. ... ...... .์ด๋ ต๋ค....... stack์ ํ์ฉํ ์๊ณ ๋ฆฌ์ฆ์ ๋๋์ฒด ์ด๋ป๊ฒ ์๊ฐํด๋ธ๊ฑฐ์ง? ๋ค๋ค ๋๋ํ๋ค...
๋๋์ฒด stack์ ํ์ฉํด์ ํผ๋ค๋๊ฒ ์ดํด๊ฐ ๋์ง ์์์ ๋ค์ํ ์ฌ๋๋ค์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ๋ค. stack์ ํ์ฉํ ํ์ด๋ for์ while๋ฌธ์ด ์ค์ฒฉ๋๋๋ฐ ์ด๋ ๋ถ๋ถ์์ ์๊ฐ๋ณต์ก๋๊ฐ ์์๊ฑธ๊น?
์,, ๋ด์๊ฐ์๋ ์ผ๋จ ๋ด ํ์ด๋ ๋ชจ๋ ์๊ฐ ์ด์ค for๋ฌธ์ ๊ฑฐ์น๊ฒ ๋๋ค. ํ์ง๋ง stack์ ํ์ฉํ (์๋) ํ์ด๋ k๋งํผ ์๊ฐ ๋ค ์ง์์ก๋ค๋ฉด, ๋จ์ ์๋ค์ ๋ชจ์กฐ๋ฆฌ stack์ ๋ฃ์ด์ค์ผ๋ก์จ ๋ฐ๋ณต๋ฌธ์ด ๋์๊ฐ๋ ํ์๋ฅผ ์ต์ํ์์ผฐ๋ค. ์๋ฌด๋๋ ์ด ๋ถ๋ถ์์ ์๊ฐ๋ณต์ก๋๊ฐ ์กฐ๊ธ ์ค์ด๋ค์๊ธฐ ๋๋ฌธ์ ํต๊ณผํ ์ ์์์ง ์์๊น ์ถ๋ค.
์ฝ๋ ์ค๋ช ์ ์ฃผ์์ผ๋ก ๋ฌ์๋จ๋ค.
func solution(_ number:String, _ k:Int) -> String {
let numArr = number.map{ Int(String($0))! }
var answer = [Int]()
var newk = k
for i in 0..<number.count {
// ์์ง k๋ฒ๋งํผ ์์ง์์ก๊ณ , answe๊ฐ ๋น์์ ธ์์ง ์๊ณ , answer์ ๋ง์ง๋ง์ ์๋ ๊ฐ์ด ์ง๊ธ ๋ฃ์ผ๋ ค๋ ๊ฐ๋ณด๋ค ์์ผ๋ฉด
// answer์ ์๋ ๋ง์ง๋ง ๊ฐ์ ์ง์๋ฒ๋ฆฌ์ธ์.
while newk > 0, !answer.isEmpty, answer.last! < numArr[i] {
answer.removeLast()
newk -= 1
}
// ๋ง์ฝ k๋ฒ๋งํผ ์ ๋ถ ์ง์ ๋ค๋ฉด
// answer์ ์ง๊ธ ๊ฒ์ฌํ์ง ์์ ๋จ์ ๋ค์์๋ numArr๋ฅผ ๋ชจ๋ ๋ฃ์ด์ฃผ์ธ์.
// ๋ง์ฝ k๋ฒ๋งํผ ์ ๋ถ ์ง์ฐ์ง ์์๋ค๋ฉด
// answer์ ์ง๊ธ์ numArr[i]๋ฅผ ๋ฃ์ด์ฃผ์ธ์.
if newk <= 0 {
answer.append(contentsOf: numArr[i...])
break
} else {
answer.append(numArr[i])
}
}
// prefix : ์์์๋ถํฐ ์ํ๋ ๊ฐฏ์์ ์์๋ค๋ง ์ถ๋ ฅํด์ค๋ค.
// ์ฐ๋ฆฌ๋ number.count - k ์๋ฆฌ์๋ฅผ ์ํดํ๊ธฐ ๋๋ฌธ์ ๋ฃ์ด์ค์ผํ๋ค.
// number = 999 , k = 1 ์์ answer์ [9, 9, 9]๊ฐ ๋๊ธฐ ๋๋ฌธ์ ์ฌ๊ธฐ์ ํ๊ฐ๋ง ์ถ๋ ฅํด์ค๋ค. prefix์ ์ญํ
return String(answer.map{ String($0) }.joined().prefix(number.count-k))
}
์ฐธ๊ณ ์ฝ๋ - https://rldd.tistory.com/159?category=963241
์ฐธ๊ณ ์ฝ๋ ๋ฐ ํ์ด -
'Algorithm > Programmers' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] (Swift) ์ฌ ์ฐ๊ฒฐํ๊ธฐ (lv.3, ๊ทธ๋ฆฌ๋, ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ) (0) | 2023.02.08 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] (Python) ๊ตฌ๋ช ๋ณดํธ (lv.2, ๊ทธ๋ฆฌ๋) (0) | 2023.02.08 |
[ํ๋ก๊ทธ๋๋จธ์ค] ์กฐ์ด์คํฑ (lv.2 ๊ทธ๋ฆฌ๋) (0) | 2023.02.02 |
[ํ๋ก๊ทธ๋๋จธ์ค] ์ฒด์ก๋ณต (lv.1 ๊ทธ๋ฆฌ๋) (0) | 2023.02.02 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Swift) ๊ฐ์ฅ ํฐ ์ ์ฌ๊ฐํ ์ฐพ๊ธฐ (Lv.2) (0) | 2023.01.23 |