๋ชฉ์ฐจ ๐
- ๊ฐ์
- ์ด์ง ํ์ ์ค๋ช
- ์ด์ง ํ์ template
- Array ๋ด์ ์ค๋ณต๋ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ
- Array ๋ด์ ์ค๋ณต๋ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ
- ์ฃผ์ ํจํด ์ค๋ช ์ ๋ค์์...
๊ฐ์
์ด์ง ํ์์ ํฌ๊ธฐ๊ฐ $n$ ์ธ search space์์ ์ฌ์ฉ๋๋ ํ์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก, worst case์์์ ๋ณต์ก๋๊ฐ $O(\log n)$ ์ธ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ด์ง ํ์์ ์ ๋ ฌ๋์ด ์๋ ํ์ ๊ณต๊ฐ์ ๋ํด์ ์ ์ฉ๋๋ค. ์ด์ง ํ์์ด ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ๋ค ์ค ์๋ฅผ ๋ค์ด๋ณด์๋ฉด...
- ์ ๋ ฌ๋ ๋ฐฐ์ด์ด ์ฃผ์ด์ง๊ณ ํน์ ๊ฐ์ด ์ถ๊ฐ๋์ด์ผ ํ ์์น๋ฅผ ๋ฌผ์ด๋ณด๋ ๊ฒฝ์ฐ
- ์ ๋ ฌ๋์ง ์์ ๋ฐฐ์ด์ ๋ํด์ ํน์ ๊ฐ ๋ณด๋ค ํฌ๊ฑฐ๋ ์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฐ์๋ฅผ ๋ฌผ์ด๋ณด๋ ๊ฒฝ์ฐ
- ์ด๋ฌํ ๋ฌธ์ ๋ ์ฃผ๋ก ์ฃผ์ด์ง ๋ฐฐ์ด์ด ์กฐ๊ฑด ๋ง์กฑ ์ฌ๋ถ์ ๋ฐ๋ผ ๋ ๊ฐ์ ์์ญ (๊ฐ๋ฅ, ๋ถ๊ฐ๋ฅ)์ผ๋ก ๋๋๋ ๊ฒฝ์ฐ์ ์ฌ์ฉ๋๋ค.
- ๋ฌด์จ๋ง์ด๋๋ฉด, ์๋ฅผ ๋ค์ด ์ฃผ๋ฌธ์ ๊ฐ๋๊ฐ array๋ก ์ฃผ์ด์ง๊ณ constant x ์ฃผ๋ฌธ ๊ฐ๋[i]๊ฐ strength (constraint ๊ฐ) ๋ณด๋ค ํฐ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๊ณ ์ถ๋ค๊ณ ํ์. ๊ทธ๋ฌ๋ฉด constant x ์ฃผ๋ฌธ ๊ฐ๋[i]์ ๊ฒฝ์ฐ, ํด๋น ๊ฐ์ด strength๋ณด๋ค ์๋ค๋ฉด ์ฃผ๋ฌธ ๊ฐ๋[i]๋ณด๋ค ์์ ๊ฐ์ ๋ํด์๋ ์์ ์กฐ๊ฑด์ ์ญ์๋ ๋ง์กฑํ์ง ์๋๋ค. ๋ฐ๋ผ์, ์ฃผ๋ฌธ๊ฐ๋[i]๋ณด๋ค ์์ ๊ฐ๋ค์ ๋ํด์๋ ๊ตณ์ด ์ฒดํฌ๋ฅผ ํ ํ์๊ฐ ์๋ค
- ๋ฐฐ์ด์ด ์ฃผ์ด์ง์ง ์๊ณ ํน์ ๋ฒ์ ๋ด์์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ์ต๋๊ฐ ํน์ ์ต์๊ฐ์ ๋ฌผ์ด๋ณด๋ ๊ฒฝ์ฐ
- ์ด ๊ฒฝ์ฐ๋ ๊ฒฐ๊ตญ ์์ ์์ ์ ๊ฐ๋ค. ์ด๋ค ์กฐ๊ฑด์ด ์ฃผ์ด์ง๊ณ , ํด๋น ์กฐ๊ฑด์ ๋ง์กฑ์ํค๋๋กํ๋ ์ต๋ ํน์ ์ต์์ $x$์ ๊ฐ์ ๋ฌป๋ ๋ฌธ์ ์์ ์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ง์กฑ์ฌ๋ถ๊ฐ $x$์ ๊ฐ์ ๋ฒ์์ ๊ด๋ จ์ด ์๋ค๋ฉด ์ญ์ binary search๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
์ค๋ช ์ด ์กฐ๊ธ ์ด์ํ๊ธดํ๋ฐ, ๋ฌดํผ, ์ด์ง ํ์์ ๋จ์ํ ํ์ ์ฉ๋๋ก๋ง ์ฌ์ฉ๋์ง ์๊ณ ์ต์ ํ ๋ฌธ์ ์๋ ํ์ฉ๋ ์ ์๋ค๋ ์ ์ ์๊ฐํด ๋๋ฉด ์ข์ ๊ฒ ๊ฐ๋ค. (์์ธํ ํจํด์ ๋ค์์ ๋ค๋ฃจ์ด๋ณด๊ฒ ์ต๋๋ค)
์ด์ง ํ์ ์ค๋ช
์ด์ ๋ถํฐ๋ ์ ๋ ฌ๋ ๋ฐฐ์ด arr ๊ฐ ์ฃผ์ด์ก๋ค๊ณ ์๊ฐํ๊ฒ ๋ค. ์ ๋ ฌ๋ ๋ฐฐ์ด arr ์ ๊ฐ x ๊ฐ ์ฃผ์ด์ก๋ค๊ณ ํ์, ๊ทธ๋ฌ๋ฉด $O(\log n)$์ ์๊ฐ ๋ณต์ก๋์ $O(1)$์ ๊ณต๊ฐ ๋ณต์ก๋๋ก ์ด์ง ํ์์ ๋ค์์ ์ํํ ์ ์๋ค:
- arr ๋ด์ ์กด์ฌํ๋ x ์ index
- x ๊ฐ ์ถ๊ฐ๋์์ ๋๋ ์ ๋ ฌ์ด ์ ์ง๋ ์ ์๋๋ก ํ๋ arr ๋ด์ ์์น (index)
์ด์ง ํ์์ ์์ด๋์ด๋ ๋ค์๊ณผ ๊ฐ๋ค.
arr ๋ด์ ์ํ๋ ๊ฐ x ์ด ์กด์ฌํ๋ค๊ณ ๊ฐ์ ํด ๋ณด์. ๊ทธ๋ฌ๋ฉด x ๋ arr ๋ด์ ์ด๋๊ฐ์ ์กด์ฌํ ๊ฒ์ด๋ค. ๋ค๋ฅธ ๋ง๋ก ํํํ์๋ฉด arr[idx] = x๋ฅผ ๋ง์กฑํ๋๋ก ํ๋ idx ๊ฐ ์๊ณ , ์ด ๊ฐ์ 0 <= idx <= len(arr)-1์ ๋ง์กฑํ ๊ฑฐ๋ค. ๊ทธ๋ฌ๋ฉด ๋ณธ๊ฒฉ์ ์ผ๋ก ์ฐพ์๋ณด์. ์ด๋์๋ถํฐ ์ฐพ์๊น ๊ณ ๋ฏผํ์ง ๋ง๊ณ ์ผ๋จ ์กด์ฌ ๊ฐ๋ฅํ ๋ฒ์ ์ค์์ ๊ฐ์ด๋ฐ๋ฅผ ๋จผ์ ์ฐ๋ฌ๋ณด์. ๋ค์ ๋งํด, arr ์ ์ค๊ฐ ๊ฐ์ ๋จผ์ ํ์ธํ๋ค. ์ค๊ฐ ๊ฐ์ arr[mid] ๋ผ๊ณ ํ ๋, arr[mid] ๊ฐ ์ฐพ๊ณ ์ ํ๋ ๊ฐ x ๋ณด๋ค ์๋ค๋ฉด ๋ด๊ฐ ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ mid +1 <= idx <= len(arr)-1 ์ฌ์ด์ ์กด์ฌํ๋ค. ๋ฐ๋ผ์ ์ฐ๋ฆฌ๊ฐ ํ์ํ๋ ๋ฒ์๋ฅผ mid +1 <= idx <= len(arr)-1๋ก ๋ฐ๊พธ๋ ๊ฒ์ด๋ค. ๊ทธ๋ฌ๋ฉด ๋ค์ ํ๋ฒ ํด๋น ๋ฒ์์์ ์ค๊ฐ ๊ฐ์ ๋ฐฉ๋ฌธํด ๋ณผ ๊ฒ์ด๋ค. (๋ฐ๋๋ก ์ค๊ฐ ๊ฐ์ด ์ฐพ๊ณ ์ ํ๋ ๊ฐ๋ณด๋ค ์ปธ๋ค๋ฉด ํ์ ๋ฒ์๋ 0 <= idx <= mid-1 ์ผ๋ก ์ค์ ๋๋ค.) (ํน์, ์ฐ์ฐ์ฐฎ๊ฒ ์ฐ๋ฆฌ๊ฐ ์ฐพ๊ณ ์ ํ๋ ๊ฐ๊ณผ ๊ฐ์๋ค๋ฉด ๊ทธ๋๋ก mid ๊ฐ์ ๋ฐํํ๋ฉด ๋๋ค.) ์ด ๊ณผ์ ์ด ๊ฒฐ๊ตญ ๋ฐ๋ณต๋๋ ํ์์์ ์ธ์งํ์๋๊ฐ?
์ด ์์ด๋์ด๋ฅผ ๊ตฌ์ฒดํํด์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ฎ๊ฒจ๋ณด์.
์ ๋จผ์ , ํ์์ ๋ฒ์๋ฅผ ๋ํ๋ด๋ ๋ณ์๋ฅผ ๋์ ํ์. ์ผ์ชฝ ๋ฒ์๋ฅผ ๋ํ๋ด๋ ๋ณ์๋ฅผ left , ์ค๋ฅธ์ชฝ ๋ฒ์๋ฅผ ๋ํ๋ด๋ ๋ณ์๋ฅผ right ๋ผ๊ณ ํ์. ๊ทธ๋ฌ๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํํ ์ ์๋ค:
- left = 0 , right = len(arr) - 1 ์ฐธ๊ณ ๋ก, ์ง๊ธ ์ด ๋ณ์๋ ํ์ ์์ญ์์ ๋ฑํธ๊ฐ ํฌํจ๋๋ค๋ ์ฌ์ค์ ์์ง ๋ง์ (inclusive)
- ์ฐ๋ฆฌ๋ ํ์์ ๋ฒ์๊ฐ ์ ํจํ ๋๊น์ง ํ์์ ์ํํ ๊ฑฐ๋ค.
while arr <= right :- ํ์ธํ ๊ฐ์ด๋ฐ ๊ฐ์ index ์ฐ์ฐํ๊ธฐ mid = (left + right) // 2
- arr[mid] ๊ฐ ํ์ธํ๊ธฐ:
- if arr[mid] == x : ์ฐพ์๋ค! return
- if arr[mid] > x : x ๊ฐ์ ์ด๋ณด๋ค ์์ ๋ฒ์์ ์กด์ฌํ๋๊น ์ค๋ฅธ์ชฝ ๋ฒ์๋ฅผ ์ค์ฌ์ฃผ์ right = mid - 1 .
- if arr[mid] < x : x ๊ฐ์ ์ด๋ณด๋ค ํฐ ๋ฒ์์ ์กด์ฌํ๋๊น ์ผ์ชฝ ๋ฒ์๋ฅผ ์ฆ๊ฐ์ํค์ left = mid + 1 .
์ด ์๊ณ ๋ฆฌ์ฆ์ ๊ฒฝ์ฐ ํ์ ๋ฒ์๋ฅผ 1/2๋ก ๊ณ์ํด์ ์ค์ฌ๋๊ฐ๊ธฐ ๋๋ฌธ์ ์๊ฐ ๋ณต์ก๋๊ฐ $O(\log n)$์์ ์ ์ ์๋ค.
์ด์ง ํ์ Code Template
arrary ๋ด์ ์ค๋ณต๋ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ
def binarySearch(arr, x):
left, right = 0, len(arr)-1
while left <= right:
mid = (left + right) // 2
if arr[mid] == x:
# do something with this
return
if arr[mid] > x:
right = mid - 1
else:
left = mid + 1
# if x is not in arr, left is the proper insertion point
return left
arrary ๋ด์ ์ค๋ณต๋ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ
ํ๊ฒ ๊ฐ x ๊ฐ ์ฌ๋ฌ ๊ฐ ์๋ ๊ฒฝ์ฐ, ์ ์ผ ์์ ์๋ x ๋ฅผ ๋ฐํํ์ฌ์ผ ํ ๊น? ์๋๋ฉด ์ ์ผ ๋ค์ ์๋ x ๋ฅผ ๋ฐํํ์ฌ์ผ ํ ๊น? ์ด๋ค ๋ฌธ์ ๋ฅผ ํ๊ณ ์๋์ง์ ๋ฐ๋ผ์ ๋ฌ๋ผ์ง ๊ฒ์ด๋ค. ์ ์ผ ์ผ์ชฝ์ x ์ ์์น๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ์ ์ ์ผ ์ค๋ฅธ์ชฝ์ x ๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ ๋ ๊ฐ์ง ๋ฒ์ ์ ๋ํ template์ ๋ค์๊ณผ ๊ฐ๋ค.
๋จผ์ , left-most index๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด ๋ณด์.
์ผ๋จ, ์๊ณ ๋ฆฌ์ฆ์ ์ด์ง ๋ณํํ ๊ฒ์ด๋ค. ์์์์ ๋ฌ๋ฆฌ, ํ์ ๋ฒ์๋ฅผ left <= idx < right ๋ก ์์ ํ์. (์ค๋ฅธ์ชฝ ๋ฑํธ๋ฅผ ์์ด์ต๋๋ค. ์ฐธ๊ณ ๋ก, ์์์๋ left <= idx <= right ์๋ค) ๊ทธ๋ฆฌ๊ณ ์ถ๊ฐ๋ก, ์์์๋ arr[mid] == x ์ธ ๊ฒฝ์ฐ ๋ฐ๋ก ๋ฐํํ๋ค๋ฉด, ์ด๋ฒ์๋ ๋ฐํํ์ง ์๊ณ ์ด mid ๊ฐ์ ์๋ก์ด ํ์ ๋ฒ์๋ก ์ง์ ํด ์ค ๊ฒ์ด๋ค.
def binarySearch(arr, x):
left, right = 0, len(arr)
while left < right:
mid = (left + right) // 2
if arr[mid] >= x:
right = mid
else:
left = mid + 1
return left
์์ ๊ฒฝ์ฐ์ ๋ฌ๋ฆฌ ์ฌ๊ธฐ์๋ ํ์ ๋ฒ์์์ ์ค๋ฅธ์ชฝ์ ๋ฑํธ๋ฅผ ๋นผ๋ฒ๋ ธ๋ค. ๊ทธ๋ฆฌ๊ณ ์ต์ข ์ ์ผ๋ก ์กฐ๊ฑด์ ๋ง์กฑํ ๋๊น์ง ํ์ ๋ฒ์๋ฅผ ์ขํ ๋ค, ํ์ ๋ฒ์์ ์ผ์ชฝ ๊ฐ์ ์ต์ข ์ ์ธ ๊ฐ์ผ๋ก ๋ฐํํ๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ค๋ณต๋ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ ๋ฐ๋ก ๋ฐํํ์ง ์๊ณ ๊ฐ์ ๊ฐ์ด ์์ ๋ ์ ์ผ ์ผ์ชฝ ๊ฐ๊น์ง ํ์์ ๊ณ์ํ๋ค๊ณ ์ดํดํ๋ฉด ๋๋ค. ์์ ๋ฒ์ (์ค๋ณต ๊ฐ์ด ์๋ ๊ฒฝ์ฐ)๊ณผ ๋ฌ๋ผ์ง ์ ์ ์ ๋ฆฌํด ๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค:
- ์์ ์ค๋ช ํ ๊ฒ์ฒ๋ผ ํ์ ๋ฒ์์์ ์ค๋ฅธ์ชฝ ๋ฑํธ๊ฐ ๋ค์ด๊ฐ์ง ์๊ธฐ ๋๋ฌธ์ right ๋ณ์์ ์ด๊ธฐํ๊ฐ ๋ฌ๋ผ์ง ๊ฒ์ ํ์ธํ ์ ์๋ค. (์์ ๋ฒ์ ์์๋ right = len(arr) - 1 ๋ก ์ด๊ธฐํ ํ์๋ค!)
- ์์์ ๋ฒ์ ์ฒดํฌ์์ while left <= right ๋ฅผ ์ ํจ ๋ฒ์๋ก ๋ดค๋ ๊ฒ๊ณผ ๋ค๋ฅด๊ฒ while left < right while ์กฐ๊ฑด๋ฌธ์์๋ ๋ฑํธ๊ฐ ๋น ์ง๋ค. (์กฐ๊ธ ์๊ฐํด๋ณด๋ฉด ์ดํดํ ์ ์๋ค. left <= idx < left ๋ ์ ํจํ ๋ฒ์๊ฐ ์๋๋ค!)
- if arr[mid] > x ์ธ ๊ฒฝ์ฐ์ if arr[mid] == x ๋ฅผ ๋ชจ๋ ํ ๋ฒ์ ์ฒ๋ฆฌํด์ฃผ๊ณ ์๋ค. ํ๋ง๋๋ก, ๊ฐ์ ๊ฐ์ธ ๊ฒฝ์ฐ์๋ ํ์์ ๋ฉ์ถ์ง ์๊ณ ์ ์ผ ์ผ์ชฝ ๊ฐ์ ์ฐพ๊ธฐ๊น์ง ํ์์ ์ด์ด๊ฐ๊ฒ ๋ค๋ ๊ฒ์ด๋ค.
- if arr[mid] >= x ์ผ ๋์ right ์ ๋ฐ์ดํธ ๋ฐฉ์์ด ๋ฌ๋ผ์ก๋ค. ์ด์ ์๋ right = mid + 1 ์ด์์ง๋ง, ์ด์ ๋ right = mid ์ด๋ค. (์ด ์ญ์ ์ ํจ๋ฒ์ ์ค๋ฅธ์ชฝ์ ๋ฑํธ๊ฐ ๋ค์ด๊ฐ์ง ์๋ ๊ฒ์ ์๊ฐํด ๋ณด๋ฉด trivial ํ๋ค)
ํ ๊ฐ์ง ์๋ฌธ์ด ๋ค ์ ์๋ค. ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ํ๋๋ฐ์ ์๋ ๊ฒฝ์ฐ์๋ ๋์ํ๋๊ฐ? ๋ต์ "๊ทธ๋ ๋ค"์ด๋ค. [1,2,3] ์ธ ๋ฐฐ์ด์ ๋ํด 2๊ฐ target์ธ ๊ฒฝ์ฐ๋ฅผ ์ฝ๊ฒ ์๊ฐํด ๋ณด์. left = 0, right = 3์ด ๋๊ณ , mid = 1์ด ๋๋ค.
1) while 1 < 3, mid = 1, arr[mid] = 2 == 2 ์ด๋ฏ๋ก right = 1์ด ๋๋ค.
2) while 1 < 1์ด ๋์ด๋ฒ๋ ค์ ํ์์ด ๋ ์ด์ ๋ถ๊ฐ๋ฅํ๊ณ while๋ฌธ์ ์ข ๋ฃํ๋ค
3) return 1 <-- ์ ๋ต์ ๋๋ค !
์ด์ , right-most index๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด๋ณด์.
์์ ๊ฒฝ์ฐ์ ํฌ๊ฒ ๋ฌ๋ผ์ง๋ ๊ฒ์ ์๋ค. ๋์ , ์ด์ ์๋ ํ๊ฒ ๊ฐ๊ณผ ๊ฐ์ ๊ฒฝ์ฐ์ right ์ ๋ฒ์๋ฅผ ์ผ์ชฝ์ผ๋ก ์ขํ์คฌ๋ค๋ฉด, ์ด์ ํ๊ฒ ๊ฐ๊ณผ ๊ฐ์ ๊ฒฝ์ฐ left์ ๋ฒ์๋ฅผ ์ค๋ฅธ์ชฝ์ผ๋ก ๋๊น์ง ์ขํ์ค ๊ฑฐ๋ค. ๊ทธ๋ฌ๋ฉด ์ต์ข ์ ์ผ๋ก left <= idx < right์ ๋ฒ์์์ ๋ง์กฑํ๋ ๊ฐ์ฅ ํ์ดํธํ left๋ฅผ ์ฐพ๊ฒ ๋๊ณ , left๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ๊ฐ์ ๋ฐํํ๊ฒ ๋๋ค. ์ด๋ฅผ ์ฝ๋๋ก ๋ํ๋ด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
def binarySearch(arr, x):
left, right = 0, len(arr)
while left < right:
mid = (left + right) // 2
if arr[mid] > x:
right = mid
else:
left = mid + 1
return left
์ฃผ์ ํจํด ์ค๋ช ์ ๋ค์์...
์์์ ์์ ๋ก ์ ๊น ์ธ๊ธ๋ ๊ฒ์ฒ๋ผ ์ด์ง ํ์์ ๋จ์ํ ํ์์๋ง ์ฌ์ฉ๋๋ ๊ฒ์ด ์๋๋ผ, ์ต์ ํ ๋ฌธ์ ๋ฅผ ํธ๋๋ฐ๋ ์ฌ์ฉ๋๋ค. ํฌ๊ฒ ๋๋์ด ์ด์ผ๊ธฐํด ๋ณด์๋ฉด ์ด์ง ํ์์ ์ฌ์ฉํ๋ ๋ํ์ ์ธ ํจํด์๋ ๋ฐฐ์ด์์ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ด ์๊ณ , ๋ค๋ฅธ ํ๋๋ ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ min/max ๊ฐ์ ์ฐพ๋ ๋ฌธ์ ๋ค ์ค solution space๋ฅผ ํ์ํ๋ ๋ฐ ์ฌ์ฉ๋ ์ ์๋ค.
๋ ๊ฐ์ ๋ํ์ ์ธ ํจํด์ ๋ํด์๋ ๋ค์์ ๋ค๋ฃจ๋๋ก ํ๊ฒ ๋ค. (์๋ก ๊ธ ์์ฑํ๋ ๋๋ก ๋ณธ ํฌ์คํ ์ ๋ฐฑ๋งํฌ ๊ฑธ์ด๋๊ฒ์)
๋ โผ๏ธ
'IN DEPTH CAKE > Coding-WIKI' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Hello! c++] constexpr const char *์ ๋ํด์ (51) | 2024.04.21 |
---|---|
[์ฝ๋ฉ] ์ต๋๊ณต์ฝ์ ๊ตฌํ๊ธฐ - ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ (Euclidean Algorithm) (0) | 2023.07.19 |
[๋ชจ์ ๋๊ณ ๋งํด๋ณด์] ์ ๋ ฌ์๊ณ ๋ฆฌ์ฆ (0) | 2023.05.29 |
sphinx-js ๋ก javascript ์ฝ๋ ๋ฌธ์ํํ๊ธฐ (0) | 2023.05.03 |
No module named 'tensorboard' ํด๊ฒฐ (0) | 2023.03.28 |