์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | |||||
3 | 4 | 5 | 6 | 7 | 8 | 9 |
10 | 11 | 12 | 13 | 14 | 15 | 16 |
17 | 18 | 19 | 20 | 21 | 22 | 23 |
24 | 25 | 26 | 27 | 28 | 29 | 30 |
- algorithm
- duno
- 0์ด๋์ด์๋๊ธธ
- binarySearch
- dfs
- ์ฐ์ํ์ค๋ถ๋ถ์์ด์ํฉ
- ๊ณ ๋์ kit
- IOS
- ๊ธฐ์ด๋ฌธ๋ฒ
- APPJAM
- ์ด์งํ์
- Swift
- HAVIT
- SOPT
- SQL
- URLSession
- GroupBy
- Til
- ๋ค์ด๋๋ฏนํ๋ก๊ทธ๋๋ฐ
- algoritm
- DynamicProgramming
- discardableResult
- SwiftUI Tutorials
- SwiftUI ํํ ๋ฆฌ์ผ
- SwiftUI
- GCD
- concurrency
- ๋์ ๊ณํ๋ฒ
- ํ๋ก๊ทธ๋๋จธ์ค
- BFS
- Today
- Total
suvera-dev ๐ฅฆ
20230329 TIL ๋ณธ๋ฌธ
์ด์ ์ฌ๋ฆฐ TIL๊ณผ ํฌ์คํ ์ ๋ช๋ช ๋ถ๋ค์ด ์์์ ๋๊ธ์ ๋ฌ์์ค์ ๋๋ฌด ํ์ด ๋์์ต๋๋ค !!!
๊ฐ์ฌํด์ฉ .. ๐ฅฒ ์๊ทธ๋๋ ์์ฆ ์ฌ๋๋ ์ ์๋ง๋๊ณ , ์ด๋ฐ์ ๋ฐ ๊ฑฑ์ ์ ์กฐ๊ธ ํ๋ค์๋๋ฐ
๋๋ถ์ ์ค๋๋ ์ด์๋ฏธ ๊ณต๋ถ ํ๊ตฌ.. ํฐ์คํ ๋ฆฌ๋ฅผ ์ฐ๋ฌ ์์ต๋๋ค >< !
1. ์๊ณ ๋ฆฌ์ฆ ํ์ด - ๋ ํ ํฉ ๊ฐ๊ฒ ๋ง๋ค๊ธฐ
- ์ฒ์์ ๋ฌธ์ ๋ฅผ ๋ณด๊ณ , removeFirst ์ฐ๋ฉด ๋ฌด์กฐ๊ฑด ์๊ฐ์ด๊ณผ ๋๊ฒ ๊ตฌ๋ ์ถ์ด์ ํฌ์ธํฐ๋ฅผ ํ์ฉํ์ต๋๋ค.
- ๊ทธ๋ฐ๋ฐ ์ด๋ ๊ฒ ํ์์์๋ ๋ถ๊ตฌํ๊ณ .. 11๋ฒ์ด๋ 28๋ฒ์์ ์๊ฐ์ด๊ณผ๊ฐ ๋๋ค์.... ๐
var sum1 = queue1.reduce(0,+)
var sum2 = queue2.reduce(0,+)
let sum = sum1 + sum2
let target = sum / 2
var queue1 = queue1
var queue2 = queue2
var moveCount = 0
var pointer1 = 0
var pointer2 = 0
if sum % 2 != 0 {
return -1
}
while sum1 != target {
let popNum1 = queue1[pointer1]
let popNum2 = queue2[pointer2]
if sum1 < sum2 {
queue1.append(popNum2)
pointer2 += 1
sum1 += popNum2
sum2 -= popNum2
} else {
queue2.append(popNum1)
pointer1 += 1
sum1 -= popNum1
sum2 += popNum1
}
if pointer1 >= queue1.count || pointer2 >= queue2.count {
return -1
}
moveCount += 1
}
return moveCount
- ๊ฒฐ๊ตญ, ํ์ด๋ฅผ ์ฐพ์๋ณด๋ ์ ๋ถ๋ค 2๊ฐ์ ํ๋ฅผ ํฉ์ณ์ ํ๋์ ๋ฐฐ์ด๋ก ๋ง๋ ๋ค์, ๊ฑฐ๊ธฐ์ ํฌ ํฌ์ธํฐ๋ฅผ ๋๋ฆฌ๋๋ผ๊ตฌ์ !
- ์ฐธ๊ณ ํด์ ์๋์ ๊ฐ์ด ๊ฐ์ ํด์คฌ์ต๋๋ค !
var sum1 = queue1.reduce(0,+)
var sum2 = queue2.reduce(0,+)
let sum = sum1 + sum2
let target = sum / 2
var queue = queue1 + queue2
var moveCount = 0
var pointer1 = 0
var pointer2 = queue1.count
if sum % 2 != 0 {
return -1
}
while sum1 != target {
if pointer2 >= queue.count || pointer1 >= pointer2 {
return -1
}
let popNum1 = queue[pointer1]
let popNum2 = queue[pointer2]
if sum1 < sum2 {
pointer2 += 1
sum1 += popNum2
sum2 -= popNum2
} else {
pointer1 += 1
sum1 -= popNum1
sum2 += popNum1
}
moveCount += 1
}
return moveCount
- ๋์ณค๋ ๋ถ๋ถ์ ํ 2๊ฐ๋ฅผ ์ด์ด ๋ถ์ด๊ฒ ๋๋ฉด, ์์์ ๋นผ์ฃผ๊ณ ๋ค๋ก ๋ถ์ฌ์ฃผ๋ ์์ ์ด๋์ ๊ตฌํํด ๋ผ ์ ์๋ค๋ ์ !
- ๊ทธ๋ฆฌ๊ณ ์ด์ฐจํผ ํ๋์ ํ๋ฅผ ๋ชจ๋ ํ์ธํ ๋๊น์ง ํฉ์ด ์๋ง์ผ๋ฉด -1์ return ํ๋ฉด ๋๊ธฐ ๋๋ฌธ์
queue์ ์์๋ค์ ๋ฐ๋ก ๊ฑด๋๋ฆด ํ์์์ด ๊ตฌํํด์ผ ์๊ฐ์ด๊ณผ๊ฐ ์๋๋ค๋ ์ฌ์ค...
2. ์๊ณ ๋ฆฌ์ฆ ํ์ด - ๋ณด์์ผํ
๋ ํ ํฉ ๊ฐ๊ฒ ๋ง๋ค๊ธฐ์ ๋์ผํ ์ ํ์ผ๋ก,
์๊ณ ๋ฆฌ์ฆ ์คํฐ๋ ์ง์ ๋ฌธ์ ์์ต๋๋ค.
ํต์ฌ : ์ง์ด๋ ๋ชจ๋ ์ข ๋ฅ์ ๋ณด์์ ์ ์ด๋ 1๊ฐ ์ด์ ํฌํจํ๋ ๊ฐ์ฅ ์งง์ ๊ตฌ๊ฐ์ ์ฐพ์์ ๊ตฌ๋งค
๊ฐ์ฅ ์งง์ ๊ตฌ๊ฐ์ ์์ ์ง์ด๋ ๋ฒํธ์ ๋ ์ง์ด๋ ๋ฒํธ๋ฅผ ์ฐจ๋ก๋๋ก ๋ฐฐ์ด์ ๋ด์์ return ํ๋๋ก ํ๋ฉฐ,
๋ง์ฝ ๊ฐ์ฅ ์งง์ ๊ตฌ๊ฐ์ด ์ฌ๋ฌ ๊ฐ๋ผ๋ฉด ์์ ์ง์ด๋ ๋ฒํธ๊ฐ ๊ฐ์ฅ ์์ ๊ตฌ๊ฐ์ return ํฉ๋๋ค.
-> ๊ตฌ๊ฐ์ ์ฐพ๋ ๋ฌธ์ ์ด๋ ํฌ ํฌ์ธํฐ๋ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ฅผ ์ด์ฉํ๋ฉด ๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๊ณ ,
ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด์์ง ์์ผ๋ ํฌํฌ์ธํฐ๋ฅผ ์ฌ์ฉํด์ ํ์ด์ผ๊ฒ ๋ค ์๊ฐ์ ํด์จ์.
๊ทธ๋ฐ๋ฐ ์์ ๋ฌธ์ ์ ๊ฒฝ์ฐ sum์ผ๋ก ๋ํ๊ณ ๋นผ์ฃผ๋ฉด ๋์ง๋ง,
๋ณด์ ์ผํ์ ๊ฒฝ์ฐ String๊ฐ์ด๊ธฐ ๋๋ฌธ์ ์ด๋ป๊ฒ ๊ด๋ฆฌ๋ฅผ ํด์ฃ ์ผ ํ ์ง ๊ณ ๋ฏผํ์ต๋๋ค.
์ฒ์์๋ ๋งค๋ฒ start์ end๋ฅผ updateํ๋ฉด์ Set(gems[start...end]) ๋ฅผ ๊ณ์ฐํด์ ํฌํจ๋์ด์๋์ง ํ์ธํ์ต๋๋ค.
๊ทผ๋ฐ ๋ํํฉ๊ฐ ํ๋์ ๋ง์ฐฌ๊ฐ์ง๋ก while ๋ฌธ ๋ด๋ถ์์ ์ ๋ ๊ฒ ๋งค๋ฒ Set์ ๋ง๋ค์ด๋ธ๋ค๋ฉด,
์๊ฐ ๋ณต์ก๋๊ฐ ์ต์ ์ ๊ฒฝ์ฐ O(N^2) ์ด ๋์ด๋ฒ๋ฆฝ๋๋ค. ( GPT๊ฐ ์๋ ค์ค ! ๋๋์ )
๊ทธ๋์ ํฌ์ธํฐ๋ฅผ ์ฎ๊ธฐ๋ฉด์ ์๋กญ๊ฒ ์ถ๊ฐ๋๊ฑฐ๋ ์ ๊ฑฐ๋๋ ๋ณด์์ ๋ด์ ๋ณ๋์ ์๋ฃํ์ด ํ์ํ๋ค๊ณ ์๊ฐํ์ต๋๋ค.
GPT์ ํํธ๋ฅผ ์ฐธ๊ณ ํด์, Dictionary๋ฅผ ๋ง๋ค์ด์คฌ์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋ณด์์ ์ข ๋ฅ๊ฐ ๋ถ์กฑํ๋ฉด right๋ฅผ ๋๋ ค์ฃผ๊ณ , ์ถฉ๋ถํ๋ฉด left๋ฅผ ๋๋ ค์ฃผ๋ ๊ณผ์ ์ ๋ฐ๋ณตํฉ๋๋ค.
์ด ๊ณผ์ ์์ Dictionary์ ๋ณด์์ ์ข ๋ฅ๋ฅผ ์ ์ฅํด์ฃผ๋ฉด ๋ฉ๋๋ค !
๋งค๋ฒ Set์ ๋ง๋ค์ง ์๊ณ ๋์ ๋๋ฆฌ ๊ฐ์ ์กฐํ๋ง ํด์ ํ์ธํ ์ ์์ต๋๋ค.
์์ฆ์ ๋ฐ๋ก ๋ค๋ฅธ ์ฌ๋์ ํ์ด์ ์ ์ฒด๋ฅผ ๋ณด๋ ๊ฒ์ด ์๋๋ผ, GPT๋ฅผ ํ์ฉํด์
์ ์ ๋ต์์์ ํ๋ฆฐ ์ ์ ์๋ ค๋ฌ๋ผ๊ณ ํ๋ค์์ ๊ทธ๊ฑธ ๋ฐํ์ผ๋ก ๊ณ ์ณ๋ณด๋ ์์ผ๋ก ํ๊ณ ์์ด์ !
func solution(_ gems:[String]) -> [Int] {
let gemSet = Set(gems)
var gemDict = [String: Int]()
var left = 0
var right = 0
var minLength = gems.count
var result: [Int] = [left+1, gems.count]
while true {
if gemDict.count == gemSet.count {
// ํ์ฌ ๊ตฌ๊ฐ์ด ๋ชจ๋ ๋ณด์์ ํฌํจํ๋ ๊ฒฝ์ฐ
if right - left < minLength {
minLength = right - left
result = [left+1, right]
}
if let count = gemDict[gems[left]] {
if count == 1 {
gemDict.removeValue(forKey: gems[left])
} else {
gemDict[gems[left]] = count - 1
}
}
left += 1
} else if right == gems.count {
break
} else {
// ํ์ฌ ๊ตฌ๊ฐ์ด ๋ชจ๋ ๋ณด์์ ํฌํจํ์ง ์๋ ๊ฒฝ์ฐ
if let count = gemDict[gems[right]] {
gemDict[gems[right]] = count + 1
} else {
gemDict[gems[right]] = 1
}
right += 1
}
}
return result
}
์ด๋ ๊ฒ ํ๋๋, ํต๊ณผํ์ต๋๋ค ! ํ์ง๋ง, ์ฝ๋๋ฅผ ๋ ๊น๋ํ๊ฒ ๊ณ ์น ์ ์์ ๊ฒ ๊ฐํ์.
๋ค์์ ๋ค์ ํ์ด๋ด์ผ๊ฒ ์ด์ !
์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ๋ฅผ ์ด์ฌํ ํ๊ณ ์๊ธดํ๋ฐ ์๊ฐ๋ณด๋ค ํ๋ฃจ์ ๋ง์ ๋ฌธ์ ๋ฅผ ํ์ง ๋ชปํ๋ค์.. ใ ใ
์๋กญ๊ฒ ์๊ฒ๋๋ ๊ฒ๋ ๋๋ฌด ๋ง๊ณ . ๋ฏธ๋ฆฌ๋ฏธ๋ฆฌ ์ํ๊ฑธ ๋ง์ด ํํ์ค์ด์์ฌ.. ์ฉ..
ํ์ง๋ง ๊ณผ๊ฑฐ์ ์๋ชป์ ๋นจ๋ฆฌ ์ฒญ์ฐํ๊ณ ใ ใ ์ด์ ์๋ผ๋ ์ด์ฌํ ํ์ด์ ๋คํ์ด๋ผ๊ณ ์๊ฐํ๊ธฐ๋ก..
Lv3์ ์์ง ํผ์ ํ์ผ๋ก ํ๊ธฐ ์ด๋ ต๋ค์ ๐
3. SwiftUI ํํ ๋ฆฌ์ผ
์ ์ง์ธ๋๋ ๊ฐ์ด ์ค์ ํํ ๋ฆฌ์ผ ํ๋ฃจ ํ ์ฑํฐ์ฉ 4์ผ์์ ๋ฝ๊ฐ๊ธฐ ! ใ ใ
์ค๋ ์ฑํฐ1 ๊น์ง ํ์ต๋๋ค์. ์ ๋ฆฌํ๋ฉด์ ํ๋๊น ์ฃ๊ธ ๊ท์ฐฎ๊ธด ํ๋ฐ ๋ ์ดํด๊ฐ ์๋๋ค์ฉ.
๊ทธ๋ฆฌ๊ณ ์ญ์ ๋ญ๊ฐ ํ ๋ ๋ค๋ฅธ ์ฌ๋๋ค์ด๋ ๊ฐ์ด ํ๋๊ฑธ ๋ ์ข์ํ๋ ๊ฒ ๊ฐ์์..
์์ฆ์ ๊ฑฐ์ ์คํฐ๋ ๊ตฌ๊ฑธ์ค.. ์ ๋ฐ ๋๋ ์คํฐ๋ ํด์ค .. ์ด๋ฐ ๋๋.. ?
SOPT ํ ๋๋ ์ ๋ง ์คํฐ๋ํ ๊ธฐํ๊ฐ ๋๋ฌด ๋ง์๋๋ฐ, ์์ฆ์ ๋ง์์ ๋ง๋ ์คํฐ๋์ ๊ตฌํ๊ธฐ๊ฐ
ํ๋์ ๋ณ๋ฐ๊ธฐ์ธ๋ฏ ํฉ๋๋ค.. ๊ทธ๋๋ ์ค์๋ฟ ์ฌ๋๋ค์ด ์์ด์ ๋คํ์ด์์.. ๐
SOPT ์ฌ๋๋ค ๋งํผ ์ด์ ์ ์ธ ์ฌ๋๋ค๋ก ์คํฐ๋๋ฅผ ๊ตฌ์ฑํ๊ธฐ๊ฐ ์ ๋ง ํ๋ ๊ฒ ๊ฐ๋ค์.. !!
๊ทธ๋์ ์ด๋ฒ ๋นํ๋ก ์คํฐ๋ ํ๋ฒ ์ฐธ์ฌํด๋ณผ๊นํ๋๋ฐ ๊ฑฐ์ ๋ค ํ๋๊ธฐ์ ์ ํ์ด๋๋ผ๊ตฌ์ ใ ใ ใ
์ง์ ์ด๊ธฐ์๋ ๋ ๋ถ๋ด์ค๋ฝ๊ธฐ๋ ํ๊ณ .. ๋ด์ผ๊น์ง๋ ํ๋ฒ ๊ณ ๋ฏผํด๋ด์ผ๊ฒ์จ์..
๋ฆ์์ง๋ง, ๋ค๋ค ์ค๋ ํ๋ฃจ ๊ณ ์ํ์ จ์ต๋๋ค ๐
'Private > TIL' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
20230402 TIL (0) | 2023.04.02 |
---|---|
20230401 TIL (0) | 2023.04.02 |
20230331 TIL (1) | 2023.04.01 |
20230330 TIL (2) | 2023.03.31 |
20230328 TIL (6) | 2023.03.29 |