์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 | 31 |
- ์ฝ๋์
- ํ๋ IT&E
- ๊ฐ์ฒด์งํฅํ๋ก๊ทธ๋๋ฐ
- URN
- datepicker
- OOP
- udp
- fontstyle
- tcp
- FACTORY
- uri
- http method
- Python
- Factory Method Pattern
- ์ฑ์ฉํ์ ํ
- Dialog
- ์ด๋ ธํ ์ด์
- swagger
- 2024-08-21
- AndroidStudio
- Android Studio
- 2024-08-20
- url
- IOC
- ๊ธฐ์ด100์
- OpenAPI
- di
- menutab
- reflection
- Kotlin
dingdong coding
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ์ด์ง ํ์ ๋ณธ๋ฌธ
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ์ด์ง ํ์
๐ถ ๊ฐ๋ฐ๊ฐ๋ฐ ๐พ 2022. 3. 23. 15:45
โฃ ์์ฐจํ์(Sequential Search) : ๋ฆฌ์คํธ ์์ ์๋ ํน์ ํ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๊ธฐ ์ํด ์์์ ๋ฐ์ดํฐ๋ฅผ ํ๋์ฉ ํ์ธํ๋ ๋ฐฉ๋ฒ
# ์์ฐจ ํ์ ์์ค์ฝ๋ ๊ตฌํ
def sequential_search(n, target, array):
# ๊ฐ ์์๋ฅผ ํ๋์ฉ ํ์ธํ๋ฉฐ
for i in range(n):
# ํ์ฌ์ ์์๊ฐ ์ฐพ๊ณ ์ ํ๋ ์์์ ๋์ผํ ๊ฒฝ์ฐ
if array[i] == target:
return i + 1# ํ์ฌ์ ์์น ๋ฐํ(์ธ๋ฑ์ค๋ 0๋ถํฐ ์์ํ๋ฏ์ค 1๋ํ๊ธฐ)
print("์์ฑํ ์์ ๊ฐ์๋ฅผ ์
๋ ฅํ ๋ค์ ํ ์นธ ๋๊ณ ์ฐพ์ ๋ฌธ์์ด์ ์
๋ ฅํ์ธ์.")
input_data = input().split()
n = int(input_data[0]) # ์์์ ๊ฐ์
target = input_data[1] # ์ฐพ๊ณ ์ ํ๋ ๋ฌธ์์ด
print("์์ ์ ์ ์์ ๊ฐ์๋งํผ ๋ฌธ์์ด์ ์
๋ ฅํ์ธ์. ๊ตฌ๋ถ์ ๋์ด์ฐ๊ธฐ ํ ์นธ์ผ๋ก ํ๋ค.")
array = input().split()
# ์์ฐจ ํ์ ์ํ
๊ฒฐ๊ณผ ์ถ๋ ฅ
print(sequential_search(n, target, array))
โฃ ์ด์งํ์(Binary Search) : ์ ๋ ฌ๋์ด ์๋ ๋ฆฌ์คํธ์์ ํ์ ๋ฒ์๋ฅผ ์ ๋ฐ์ฉ ์ขํ๊ฐ๋ฉฐ ๋ฐ์ดํฐ๋ฅผ ํ์ํ๋ ๋ฐฉ๋ฒ
* ์ด์งํ์์ ์์์ , ๋์ , ์ค๊ฐ์ ์ ์ด์ฉํ์ฌ ํ์ ๋ฒ์๋ฅผ ์ค์ ํฉ๋๋ค.
์ด์งํ์์ ์๊ฐ ๋ณต์ก๋ : O(logN)
์ด์ง ํ์์ ๊ตฌํ๋ฐฉ๋ฒ 1) ์ฌ๊ทํจ์ ์ด์ฉ 2) ๋ฐ๋ณต๋ฌธ ์ด์ฉ
1) ์ฌ๊ทํจ์ ์ด์ฉ
# ์ด์ง ํ์ ์์ค์ฝ๋ ๊ตฌํ(์ฌ๊ทํจ์)
def binary_search(array, target, start, end):
if start > end:
return None
mid = (start + end) // 2
# ์ฐพ์ ๊ฒฝ์ฐ ์ค๊ฐ์ ์ธ๋ฑ์ค ๋ฐํ
if array[mid] == target:
return mid
# ์ค๊ฐ์ ์ ๊ฐ๋ณด๋ค ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ์์ ๊ฒฝ์ฐ ์ผ์ชฝ ํ์ธ
elif array[mid] > target:
return binary_search(array, target, start, mid - 1)
# ์ค๊ฐ์ ์ ๊ฐ๋ณด๋ค ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ํฐ ๊ฒฝ์ฐ ์ค๋ฅธ์ชฝ ํ์ธ
else:
return binary_search(array, target, mid + 1, end)
# n(์์์ ๊ฐ์)๊ณผ target(์ฐพ๊ณ ์ ํ๋ ๋ฌธ์์ด)์ ์
๋ ฅ๋ฐ๊ธฐ
n, target = list(map(int, input().split()))
# ์ ์ฒด์์ ์
๋ ฅ๋ฐ๊ธฐ
array = list(map(int, input().split()))
# ์ด์ง ํ์ ์ํ ๊ฒฐ๊ณผ ์ถ๋ ฅ
result = binary_search(array, target, 0, n - 1)
if result == None:
print("์์๊ฐ ์กด์ฌํ์ง ์์ต๋๋ค.")
else:
print(result + 1)
2) ๋ฐ๋ณต๋ฌธ ์ด์ฉ
# ์ด์ง ํ์ ์์ค์ฝ๋ ๊ตฌํ(๋ฐ๋ณต๋ฌธ)
def binary_serach(array, target, start, end):
while start <= end:
mid = (start + end) // 2
# ์ฐพ์ ๊ฒฝ์ฐ ์ค๊ฐ์ ์ธ๋ฑ์ค ๋ฐํ
if array[mid] == target:
return mid
# ์ค๊ฐ์ ์ ๊ฐ๋ณด๋ค ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ์์ ๊ฒฝ์ฐ ์ผ์ชฝ ํ์ธ
elif array[mid] > target:
end = mid - 1
# ์ค๊ฐ์ ์ ๊ฐ๋ณด๋ค ์ฐพ๊ณ ์ ํ๋ ๊ฐ์ด ํฐ ๊ฒฝ์ฐ ์ค๋ฅธ์ชฝ ํ์ธ
else:
start = mid + 1
return None
# n(์์์ ๊ฐ์)๊ณผ target(์ฐพ๊ณ ์ ํ๋ ๋ฌธ์์ด)์ ์
๋ ฅ๋ฐ๊ธฐ
n, target = list(map(int, input().split()))
# ์ ์ฒด ์์ ์
๋ ฅ๋ฐ๊ธฐ
array = list(map(int, input().split()))
# ์ด์ง ํ์ ์ํ๊ฒฐ๊ณผ ์ถ๋ ฅ
result = binary_serach(array, target, 0, n-1)
if result == None:
print("์์๊ฐ ์กด์ฌํ์ง ์์ต๋๋ค.")
else:
print(result+1)
1. ๋ถํ ์ฐพ๊ธฐ (์ค์ ๋ฌธ์ )
2. ๋ก๋ณถ์ด ๋ก ๋ง๋ค๊ธฐ (์ค์ ๋ฌธ์ )
[ ์ค์ ๋ฌธ์ ] ๋ถํ ์ฐพ๊ธฐ
โป ๋ฌธ์
๋๋น์ด๋ค ์ ์ ๋งค์ฅ์๋ ๋ถํ์ด N๊ฐ ์๋ค. ๊ฐ ๋ถํ์ ์ ์ ํํ์ ๊ณ ์ ํ ๋ฒํธ๊ฐ ์๋ค. ์ด๋ ๋ ์๋์ด M๊ฐ์ ์ข ๋ฅ์ ๋ถํ์ ๋๋์ผ๋ก ๊ตฌ๋งคํ๊ฒ ๋ค๋ฉฐ ๋น์ผ ๋ ๊ฒฌ์ ์๋ฅผ ์์ฒญํ๋ค. ๋๋น์ด๋ ๋๋ ๋์น์ง ์๊ณ ์๋์ด ๋ฌธ์ํ ๋ถํ M๊ฐ ์ข ๋ฅ๋ฅผ ๋ชจ๋ ํ์ธํด์ ๊ฒฌ์ ์๋ฅผ ์์ฑํด์ผ ํ๋ค. ์ด ๋ ๊ฐ๊ฒ ์์ ๋ถํ์ด ๋ชจ๋ ์๋์ง ํ์ธํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์
์ ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ์ ์ N์ด ์ฃผ์ด์ง๋ค.
- ๋์งธ ์ค์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ N๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋ ์ ์๋ 1๋ณด๋ค ํฌ๊ณ 1,000,000 ์ดํ์ด๋ค.
- ์ ์งธ ์ค์๋ ์ ์ M์ด ์ฃผ์ด์ง๋ค.
- ๋ท์งธ ์ค์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ M๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋ ์ ์๋ 1๋ณด๋ค ํฌ๊ณ 1,000,000 ์ดํ์ด๋ค.
์ถ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ๊ฐ ๋ถํ์ด ์กด์ฌํ๋ฉด yes๋ฅผ ์์ผ๋ฉด no๋ฅผ ์ถ๋ ฅํ๋ค.
# ๋ถํ ์ฐพ๊ธฐ
def binary_serach(array, target, start, end):
if start > end:
return None
mid = (start + end) // 2
if array[mid] == target:
return mid
elif array[mid] > target:
return binary_serach(array, target, start, mid - 1)
else:
return binary_serach(array, target, mid + 1, end)
n = int(input())
arr = []
arr = list(map(int, input().split()))
m = int(input())
arr2 = [] # ์ฐพ๊ณ ์ ํ๋ target
arr2 = list(map(int, input().split()))
for i in arr2:
result = binary_serach(arr, i, 0, n - 1)
if result == None:
print("no", end=' ')
else:
print("yes", end=' ')
[ ์ค์ ๋ฌธ์ ] ๋ก๋ณถ์ด ๋ก ๋ง๋ค๊ธฐ
โป ๋ฌธ์
์ค๋ ๋๋น์ด๋ ์ฌํ ๊ฐ์ ๋ถ๋ชจ๋์ ๋์ ํด์ ๋ก์ง ์ผ์ ํ๊ธฐ๋ก ํ๋ค. ์ค๋์ ๋ก๋ณถ์ด ๋ก์ ๋ง๋๋ ๋ ์ด๋ค. ๋๋น์ด๋ค ๋ก๋ณถ์ด ๋ก์ ์ฌ๋ฐ๊ฒ๋ ๋ก๋ณถ์ด ๋ก์ ๊ธธ์ด๊ฐ ์ผ์ ํ์ง ์๋ค. ๋์ ์ ํ ๋ด์ง ์์ ๋ค์ด๊ฐ๋ ๋ก์ ์ด ๊ธธ์ด๋ ์ ๋จ๊ธฐ๋ก ์๋ผ์ ๋ง์ถฐ์ค๋ค.
์ ๋จ๊ธฐ ๋์ด(H)๋ฅผ ์ง์ ํ๋ฉด ์ค์ง์ด ๋ก์ ํ ๋ฒ์ ์ ๋จํ๋ค. ๋์ด๊ฐ H๋ณด๋ค ๊ธด ๋ก์ H ์์ ๋ถ๋ถ์ด ์๋ฆด ๊ฒ์ด๊ณ , ๋ฎ์ ๋ก์ ์๋ฆฌ์ง ์๋๋ค.
์๋ฅผ ๋ค์ด ๋์ด๊ฐ 19, 14, 10, 17cm์ธ ๋ก์ด ๋๋ํ ์๊ณ ์ ๋จ๊ธฐ ๋์ด๋ฅผ 15cm๋ก ์ง์ ํ๋ฉด ์๋ฅธ ๊ท ๋ก์ ๋์ด๋ 15, 14, 10, 15cm๊ฐ ๋ ๊ฒ์ด๋ค. ์๋ฆฐ ๋ก์ ๊ธธ์ด๋ ์ฐจ๋ก๋๋ก 4, 0, 0, 2cm์ด๋ค. ์๋์ 6cm๋งํผ์ ๊ธธ์ด๋ฅผ ๊ฐ์ ธ๊ฐ๋ค.
์๋์ด ์์ ๋ ์์ฒญํ ์ด ๊ธธ์ด๊ฐ M์ผ ๋ ์ ์ด๋ M๋งํผ์ ๋ก์ ์ป๊ธฐ ์ํด ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ๋ก์ ๊ฐ์ N์ ์์ฒญํ ๋ก์ ๊ธธ์ด M์ด ์ฃผ์ด์ง๋ค.
- ๋์งธ ์ค์๋ ๋ก์ ๊ฐ๋ณ ๋์ด๊ฐ ์ฃผ์ด์ง๋ค. ๋ก ๋์ด์ ์ดํฉ์ ํญ์ M ์ด์์ด๋ฏ๋ก, ์๋์ ํ์ํ ์๋งํผ ๋ก์ ์ฌ๊ฐ ์ ์๋ค. ๋์ด๋ 10์ต๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ ์ ์ ๋๋ 0์ด๋ค.
์ถ๋ ฅ์กฐ๊ฑด
- ์ ์ด๋ M๋งํผ์ ๋ก์ ์ง์ ๊ฐ์ ธ๊ฐ๊ธฐ ์ํด ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๋ค.
# ๋ก๋ณถ์ด ๋ก ๋ง๋ค๊ธฐ
# ๋ก์ ๊ฐ์ (N)์ ์์ฒญํ ๋ก์ ๊ธธ์ด (M)์ ์
๋ ฅ๋ฐ๊ธฐ
n, m = list(map(int, input().split()))
# ๊ฐ ๋ก์ ๊ฐ๋ณ ๋์ด ์ ๋ณด ์
๋ ฅ๋ฐ๊ธฐ
arr = list(map(int, input().split()))
# ์ด์ง ํ์์ ์ํ ์์์ ๊ณผ ๋์ ์ค์
start = 0
end = max(arr)
# ์ด์ง ํ์ ์ํ(๋ฐ๋ณต์ )
result = 0
while start <= end:
total = 0
mid = (start + end) // 2
for x in arr:
# ์๋์ ๋ ๋ก์ ์ ๊ณ์ฐ
if x > mid:
total += x - mid
# ๋ก์ ์์ด ๋ถ์กฑํ ๊ฒฝ์ฐ ๋ ๋ง์ด ์๋ฅด๊ธฐ(์ผ์ชฝ ๋ถ๋ถ ํ์)
if total < m:
end = mid - 1
# ๋ก์ ์์ด ์ถฉ๋ถํ ๊ฒฝ์ฐ ๋ ์๋ฅด๊ธฐ(์ค๋ฅธ์ชฝ ๋ถ๋ถ ํ์)
else:
result = mid # ์ต๋ํ ๋ ์๋์ ๋๊ฐ ์ ๋ต์ด๋ฏ๋ก, ์ฌ๊ธฐ์์ result์ ๊ธฐ๋ก
start = mid + 1
print(result)
๊ฐ์ ๋ฐ ์ถ์ฒ
'๐ตCoding Test > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ์ต๋จ ๊ฒฝ๋ก (0) | 2022.05.02 |
---|---|
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ (0) | 2022.04.29 |
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] ์ ๋ ฌ (0) | 2022.03.23 |
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] DFS/BFS (0) | 2022.03.21 |
[ ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ ] Implementaion (0) | 2022.02.25 |