๋ชฉ์ฐจ
์ด์งํ์ : ํ์ ๋ฒ์๋ฅผ ๋ฐ์ผ๋ก ์ขํ๊ฐ๋ฉฐ ๋น ๋ฅด๊ฒ ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ
- ์์์ , ์ค๊ฐ์ , ๋์ ์ ์ธ๋ฑ์ค์ด๋ค.
- ์ค๊ฐ์ ์ด 2๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ์๋ ์์์ ์ดํ๋ ์ ๊ฑฐํ์ฌ ์ค๊ฐ์ ์ ํ์ํ ์ ์๋ค.
ํ ๋จ๊ณ๋ฅผ ๊ฑฐ์น ๋๋ง๋ค ๋ฐ์ดํฐ์ ๊ฐ์๊ฐ ๋ฐ์ฉ ์ค์ด๋ ๋ค.
๐ก์ฝ๋ฉํ ์คํธ์์์ ์ด์ง ํ์
๐ซฑ ์ฝ๋ฉ ํ ์คํธ์์ ์ด์ง ํ์ ๋ฌธ์ ๋ ํ์ ๋ฒ์๊ฐ ํฐ ์ํฉ์์์ ํ์์ ๊ฐ์ ํ๋ ๊ฒฝ์ฐ ๅค
๐ซฑ ํ์ ๋ฒ์๊ฐ 2000๋ง์ ๋์ด๊ฐ๋ฉด ์ด์ง ํ์์ผ๋ก ์ ๊ทผํด๋ณด์
๐ซฑ ์ฒ๋ฆฌํด์ผํ ๋ฐ์ดํฐ์ ๊ฐ์๋ ๊ฐ์ด 1000๋ง ๋จ์ ์ด์์ผ๋ก ๋์ด๊ฐ๋ฉด ์ด์ง ํ์๊ณผ ๊ฐ์ด 0(logN)์ ์๋๋ฅผ ๋ด์ผํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ ์ฌ๋ ค์ผ ํ ์ ์๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค๋ ๊ฒ์ ๊ธฐ์ตํ์!!!
๐ก๋น ๋ฅด๊ฒ ์ ๋ ฅ๋ฐ๊ธฐ
์ด์งํ์์ ์ ๋ ฅ ๋ฐ์ดํฐ๊ฐ ๋ง๊ฑฐ๋, ํ์ ๋ฒ์๊ฐ ๋งค์ฐ ๋๋ค. ๋ฐ์ดํฐ์ ๊ฐ์๊ฐ 1000๋ง๊ฐ๋ฅผ ๋์ด๊ฐ๊ฑฐ๋ ํ์ ๋ฒ์์ ํฌ๊ธฐ๊ฐ 1000์ต ์ด์์ด๋ผ๋ฉด ์ด์ง ํ์ ์๊ณ ๋ฆฌ์ฆ์ ์์ฌํด๋ณด์ !! ๐
์ ๋ ฅ ๋ฐ์ดํฐ์ ๋ํด ์ด๋ป๊ฒ ํ๊ณ ์๋?
input์ผ๋ก๋ง ์ฒ๋ฆฌํ๊ณ ์๋ค๋ฉด ์ด๋ ๊ฒ ์ ๋ ฅ ๋ฐ์ดํฐ์ ๊ฐ์๊ฐ ๋ง์ ๋ฌธ์ ์์๋ ๋์ ์๋๊ฐ ๋๋ ค ์๊ฐ ์ด๊ณผ๊ฐ ๋์ฌ ์ ์๋ค.
๋ฐ๋ผ์ ์ ๋ ฅ ๋ฐ์ดํฐ๊ฐ ๋ง์ ๋ฌธ์ ๋ sys ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ readline()ํจ์๋ฅผ ์ด์ฉํ์ฌ ์๊ฐ ์ด๊ณผ๋ฅผ ํผํ ์ ์๋ค.
import sys
# ํ๋์ ๋ฌธ์์ด ์
๋ ฅ ๋ฐ๊ธฐ
input_data = sys.stdin.readline().rstrip()
print(input_data)
- sys ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ ๋์๋ ํ์ค์ ์ ๋ ฅํ ๋๋ง๋ค rstrip() ํจ์๋ฅผ ๊ผญ ํธ์ถํด์ค์ผํจ.
์ด์ ๋ ?
์์ค ์ฝ๋์ readline()์ผ๋ก ์ ๋ ฅํ๋ฉด ์ ๋ ฅ ํ ์ํฐ๊ฐ ์ค๋ฐ๊ฟ ๊ธฐํธ๋ก ์ ๋ ฅ๋๋๋ฐ ์ด ๊ณต๋ฐฑ๋ฌธ์๋ฅผ ์ ๊ฑฐํ๋ ค๋ฉด rstrip() ํจ์๋ฅผ ์ฌ์ฉํด์ผํ๋ค.
ํ์ด์ฌ ์ด์ง ํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- bisect_left ๋ก ์ด์งํ์์ ์ํํ๋ฉด ์์ 4๊ฐ ๋ค์ด๊ฐ ์ ์๋ ์ฒซ ๋ฒ์งธ ์์น์ธ [2]๊ฐ ๋ฐํ๋๋ค.
- bisect_right ๋ก ์ด์งํ์์ ์ํํ๋ฉด ์์ 4๊ฐ ๋ค์ด๊ฐ ์ ์๋ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์์น์ธ ์ธ๋ฑ์ค[4]๊ฐ ๋ฐํ๋๋ค.
๊ฐ์ด ํน์ ๋ฒ์์ ์ํ๋ ๋ฐ์ดํฐ ๊ฐ์ ๊ตฌํ๊ธฐ ์์
from bisect import bisect_left,bisect_right
def count_by_range(a, left_value, right_value):
right_index = bisect_right(a,right_value)
left_index = bisect_left(a,left_value)
return right_index-left_index
a = [1,2,3,3,3,3,4,4,8,9]
#๊ฐ์ด 4์ธ ๋ฐ์ดํฐ ๊ฐ์ ์ถ๋ ฅ
print(count_by_range(a,4,4,))
# ๊ฐ์ด [-1,3] ๋ฒ์์ ์๋ ๋ฐ์ดํฐ ๊ฐ์ ์ถ๋ ฅ
print(count_by_range(a,-1,3))
ํ๋ผ๋ฉํธ๋ฆญ ์์น
์ต์ ํ ๋ฌธ์ ๋ ๊ฐ๋ฅํ ํจ์์ ๊ฐ์ ์ต๋ํ ๋ฎ์ถ๊ฑฐ๋ ์ต๋ํ ๋์ด๋ ๊ฒ์ ์๋ฏธํ๋ค.
1๏ธโฃ์ค์ ๋ฌธ์ 1 ๋ถํ ์ฐพ๊ธฐ
์ด์ง ํ์์ผ๋ก ํด๊ฒฐ
์ด์ง ํ์ ๊ธฐ๋ณธ ํํ
def binary_search(array, target, start, end):
while 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)
return None
n = int(input())
n_list = list(map(int,input().split()))
n_list.sort()
m = int(input())
m_list = list(map(int,input().split()))
for target in m_list:
result = binary_search(n_list,target,0,n)
if result != None:
print("yes", end =' ')
else:
print("no", end=' ')
๐ก ๋ฆฌ์คํธ ์์ฑ ํ ์ ๋ ฌํ ๋ ์ฃผ์์ฌํญ
// ์ด๋ ๊ฒ ํ๋ฉด ์๋๋ค.
n_list = list(map(int,input().split())).sort()
// ์ด๋ ๊ฒ ํด์ผํ๋ค.
n_list = list(map(int,input().split()))
n_list.sort()
๐ก์ด๋ ค์ ๋ ์ & ๋ฐฐ์ด ์
- ์ด์ง ํ์์ ์ํํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ์ด๋ป๊ฒ ์ถ๋ ฅํด์ค ์ง๊ฐ ์ด๋ ค์ ๋ค.
์ด์ง ํ์ ํจ์๋ while๋ฌธ์ ํตํด ์ฌ๊ท์ ์ผ๋ก ํธ์ถ๋๋ค. while์ ์กฐ๊ฑด์ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ์ return None์ ์์ฑํด์ฃผ๊ณ ํจ์๋ฅผ ์ข ๋ฃํ๋ฉด ๋๋ค!!
๊ทธ๋ฆฌ๊ณ ํจ์ ํธ์ถ์ ๊ฒฐ๊ณผ๊ฐ None์ด ์๋ ๊ฒฝ์ฐ์ None์ธ ๊ฒฝ์ฐ๋ก ๋๋์ด์ ์ฒ๋ฆฌํด์ฃผ๋ฉด ๋๋ค.
- ์ถ๋ ฅ ์ ๊ณต๋ฐฑ์ ์ด๋ป๊ฒ ์ ๋ ฅํ๋์ง์ ๋ํด ์๊ฒ๋์๋ค.
print("yes")
print(" ")
// ์ด๋ ๊ฒ ํ๋ฉด ๋๋ค!
print("yes", end= ' ')
๊ณ์ ์ ๋ ฌ๋ก ํ์ด๋ณด๊ธฐ
# ๊ณ์ ์ ๋ ฌ๋ก ํ์ด๋ณด๊ธฐ
n = int(input())
array = [0] * 10000001
for i in input().split():
array[int(i)] = 1
m = int(input())
x = list(map(int,input().split()))
for i in x:
if(array[i]==1):
print("yes", end=' ')
else:
print("no", end=' ')
n_list๋ฅผ ์ ๋ ฅํ์ฌ ๊ทธ๋๋ก ์ฌ์ฉํ์ง ์๊ณ , ๊ณ์ ์ ๋ ฌ์ ํตํด ํด๋น ๊ฐ์ 1๋ก ์ ๋ฐ์ดํธํด์ฃผ๋ฉด ๋๋ค.
์งํฉ ์๋ฃํ์ ์ด์ฉํด์ ํ์ด๋ณด๊ธฐ
n = int(input())
array = set(map(int,input().split()))
m = int(input())
x= list(map(int, input().split()))
for i in x:
if i in array:
print("yes", end=' ')
else:
print("no", end=' ')
๐ก๋ฐฐ์ด ์
์งํฉ ์๋ฃํ์ set( ) ํจ์๋ฅผ ํตํด ๋ง๋ค ์ ์๋ค.
๋จ์ํ ํน์ ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ๋์ง ๊ฒ์ฌํ ๋์ ์์ฃผ ์ ์ฉํ๊ฒ ์ธ ์ ์๋ค.
๋ํ set์ ํตํด ์งํฉ์ ๋ง๋ค๋ฉด ์ ๋ ฌ๋ ๊ฐ์ด ๋๋ค!
2๏ธโฃ์ค์ ๋ฌธ์ 2 : ๋ก๋ณถ์ด ๋ก ๋ง๋ค๊ธฐ
# ๋ก์ ๊ฐ์ n, ์์ฒญํ ๋ก์ ๊ธธ์ด m
n,m = map(int,input().split())
# ๋ก์ ๊ธธ์ด ๋ฆฌ์คํธ
rice_cake_list = list(map(int,input().split()))
# ์ด์ง ํ์์ ์ํ ์์์ & ๋์
start = 0
end = max(rice_cake_list)
# ์ ๋จ๊ธฐ ๋์ด๋ฅผ ์ ์ฅํ ๋ณ์
result = 0
# ์ด์ง ํ์ ๋ฐ๋ณต๋ฌธ ๊ตฌํ
while(start <= end):
mid = (start + end )//2
# ์๋ฆฐ ๋ก์ ๊ธธ์ด
total = 0
for rice_cake in rice_cake_list:
if mid < rice_cake:
total += rice_cake-mid
if total < m:
end = mid-1
else:
result = mid
start= mid+1
print(result)
ํ๋ผ๋ฉํธ๋ฆญ ์์น ์ ํ
ํ๋ผ๋ฉํธ๋ฆญ ์์น๋ ์ต์ ํ ๋ฌธ์ ๋ฅผ ๊ฒฐ์ ๋ฌธ์ (์ ๋๋ ์๋์ค๋ก ๋ตํ๋ ๋ฌธ์ ) ๋ก ๋ฐ๊พธ์ด ํด๊ฒฐํ๋ ๊ธฐ๋ฒ์ ๋งํ๋ค.
์ํ๋ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฐ์ฅ ์๋ง์ ๊ฐ์ ์ฐพ๋ ๋ฌธ์ ์ ์ฃผ๋ก ์ฌ์ฉ๋๋ค.
์๋ฅผ ๋ค์ด ๋ฒ์ ๋ด์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ฐพ์ผ๋ผ๋ ์ต์ ํ ๋ฌธ์ ๋ผ๋ฉด ์ด์ง ํ์์ผ๋ก ๊ฒฐ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉด์ ๋ฒ์๋ฅผ ์ขํ ์ ์๋ค. ์ฝ๋ฉ ํ ์คํธ๋ ํ๋ก๊ทธ๋๋ฐ ๋ํ์์ ๋ณดํต ํ๋ผ๋ฉํธ๋ฆญ ์์น ์ ํ์ ์ด์ง ํ์์ผ๋ก ํด๊ฒฐํ๋ค.
ํ์ด ์์ด๋์ด
์ ์ ํ ๋์ด๋ฅผ ์ฐพ์ ๋๊น์ง ์ ๋จ๊ธฐ์ ๋์ด h๋ฅผ ๋ฐ๋ณตํด์ ์กฐ์ ํ๋ ๊ฒ์ด๋ค.๊ทธ๋์ ํ์ฌ ์ด ๋์ด๋ก ์๋ฅด๋ฉด ์กฐ๊ฑด์ ๋ง์กฑํ ์ ์๋๊ฐ? ๋ฅผ ํ์ธ ํ๊ณ ์กฐ๊ฑด์ ๋ง์กฑ ์ฌ๋ถ(์ ๋๋ ์๋์ค)์ ๋ฐ๋ผ ํ์ํ๋ ๋ฒ์๋ฅผ ์ขํ๋๊ฐ๋ฉด ํด๊ฒฐํ ์ ์๋ค.
๋ฒ์๋ฅผ ์ขํ๋๊ฐ ๋ ์ด์ง ํ์์ ์๋ฆฌ๋ฅผ ์ด์ฉํ์ฌ ํ์ ๋ฒ์๋ฅผ ์ ๋ฐ์ฉ ์ขํ๋๊ฐ๋ค.
์ ๋จ๊ธฐ์ ๋์ด(ํ์ ๋ฒ์)
1๋ถํฐ 10์ต๊น์ง์ ์ ์ ์ค ํ๋์ด๋ค.
์ด๋ ๊ฒ ํฐ ์๋ฅผ ๋ณด๋ฉด ์ด์ง ํ์์ ๋ ์ฌ๋ฆฌ์!!
'์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ ๊ธฐ๋ก' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๊ตฌํ ๋ฌธ์ (0) | 2024.09.29 |
---|---|
[์ด์ฝํ /python] ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ๊ฐ๋ ์ ๋ฆฌ & ๋ฌธ์ ํ์ด ๊ธฐ๋ก โ ๋ฐฑ์ค dp ๋ฌธ์ ํ์ด (0) | 2024.05.29 |
์ด์ฝํ ํ์ด์ฌ : ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ ์ ๋ฆฌ (0) | 2024.05.05 |
[DFS/BFS : python] ์ด์ฝํ ๋ด์ฉ ์ ๋ฆฌ ๋ฐ ๋ฌธ์ ํ์ด ๊ธฐ๋ก (1) | 2024.04.06 |
[๊ตฌํ: python]๊ฐ๋ ๊ณผ ๋ฌธ์ ํ์ด ์ ๋ฆฌํ๊ธฐ (1) | 2024.03.28 |