์ด๊ฒ์ด ์ทจ์ ์ ์ํ ์ฝ๋ฉํ ์คํธ๋ค with ํ์ด์ฌ
6์ฅ. ์ ๋ ฌ
ํ์ด์ฌ์ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- sorted() ํจ์ : ๊ธฐ๋ณธ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ. ํต ์ ๋ ฌ๊ณผ ๋์ ๋ฐฉ์์ด ๋น์ทํ ๋ณํฉ ์ ๋ ฌ์ ๊ธฐ๋ฐ์ผ๋ก ๋ง๋ค์ด์ก๋๋ฐ, ๋ณํฉ ์ ๋ ฌ์ ์ผ๋ฐ์ ์ผ๋ก ํต ์ ๋ ฌ๋ณด๋ค ๋๋ฆฌ์ง๋ง ์ต์ ์ ๊ฒฝ์ฐ์๋ ์๊ฐ ๋ณต์ก๋ O(NlogN)์ ๋ณด์ฅํ๋ค๋ ํน์ฑ์ด ์๋ค. ๋ฆฌ์คํธ, ๋์ ๋๋ฆฌ ์๋ฃํ ๋ฑ์ ์ ๋ ฅ๋ฐ์์ ์ ๋ ฌ๋ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค.
array = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8]
result = sorted(array)
print(result)
# ์ถ๋ ฅ
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- sort() ํจ์ : ๋ฆฌ์คํธ ๊ฐ์ฒด์ ๋ด์ฅ ํจ์. ๋ณ๋์ ์ ๋ ฌ๋ ๋ฆฌ์คํธ๊ฐ ๋ฐํ๋์ง ์๊ณ ๋ด๋ถ ์์๊ฐ ๋ฐ๋ก ์ ๋ ฌ๋๋ค.
array = [7, 5, 9, 0, 3, 1, 6, 2, 4, 8]
array.sort()
print(array)
# ์ถ๋ ฅ
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
- key ๋งค๊ฐ๋ณ์๋ฅผ ์ ๋ ฅ๋ฐ์ ์ ์๋ค. key ๊ฐ์ผ๋ก๋ ํ๋์ ํจ์๊ฐ ๋ค์ด๊ฐ์ผํ๋ฉฐ ์ด๋ ์ ๋ ฌ ๊ธฐ์ค์ด ๋๋ค.
์์ ) ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ key๋ฅผ ํ์ฉํ ์์ค์ฝ๋
array = [('๋ฐ๋๋', 2), ('์ฌ๊ณผ', 5), ('๋น๊ทผ', 3)]
def setting(data):
return data[1]
result = sorted(array, key=setting)
print(result)
# ์ถ๋ ฅ
# [('๋ฐ๋๋', 2), ('๋น๊ทผ', 3), ('์ฌ๊ณผ', 5)]
์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์๊ฐ ๋ณต์ก๋
- ํญ์ ์ต์ ์ ๊ฒฝ์ฐ์๋ O(NlogN)์ ๋ณด์ฅํ๋ค
1. ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก ํ ์ ์๋ ๋ฌธ์ : ๋จ์ํ ์ ๋ ฌ ๊ธฐ๋ฒ์ ์๊ณ ์๋์ง ๋ฌผ์ด๋ณด๋ ๋ฌธ์
2. ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์๋ฆฌ์ ๋ํด์ ๋ฌผ์ด๋ณด๋ ๋ฌธ์ : ์ ํ ์ ๋ ฌ, ์ฝ์ ์ ๋ ฌ, ํต ์ ๋ ฌ ๋ฑ์ ์๋ฆฌ๋ฅผ ์๊ณ ์์ด์ผ ๋ฌธ์ ๋ฅผ ํ ์ ์๋ค.
3. ๋ ๋น ๋ฅธ ์ ๋ ฌ์ด ํ์ํ ๋ฌธ์ : ํต ์ ๋ ฌ ๊ธฐ๋ฐ์ ์ ๋ ฌ ๊ธฐ๋ฒ์ผ๋ก๋ ํ ์ ์์ผ๋ฉฐ ๊ณ์ ์ ๋ ฌ ๋ฑ์ ๋ค๋ฅธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ๊ฑฐ๋ ๋ฌธ์ ์์ ๊ธฐ์กด์ ์๋ ค์ง ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌ์กฐ์ ์ธ ๊ฐ์ ์ ๊ฑฐ์ณ์ผ ํ ์ ์๋ค.
์ค์ ๋ฌธ์ 2. ์์์ ์๋๋ก
- ๋ชจ๋ ์๋ 1์ด์ 100,000์ดํ์ด๋ฏ๋ก ์ด๋ ํ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํด๋ ๋ฌธ์ ํด๊ฒฐ ๊ฐ๋ฅํ๋ค
- ๊ฐ์ฅ ์ฝ๋๊ฐ ๊ฐ๊ฒฐํด์ง๋ ํ์ด์ฌ์ ๊ธฐ๋ณธ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ด์ฉํ๋ ๊ฒ์ด ํจ๊ณผ์ ์ด๋ค
# N์ ์
๋ ฅ๋ฐ๊ธฐ
n = int(input())
# N๊ฐ์ ์ ์๋ฅผ ์
๋ ฅ๋ฐ์ ๋ฆฌ์คํธ์ ์ ์ฅ
arr = []
for i in range(n):
arr.append(int(input()))
# ํ์ด์ฌ ๊ธฐ๋ณธ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ด์ฉํ์ฌ ์ ๋ ฌ ์ํ
arr = sorted(arr, reverse=True)
# arr.sort(reverse=True)
# ์ ๋ ฌ์ด ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅ
for i in arr:
print(i, end=" ")
์ค์ ๋ฌธ์ 3. ์ฑ์ ์ด ๋ฎ์ ์์๋ก ํ์ ์ถ๋ ฅํ๊ธฐ
- ํ์์ ๋ณด๋ฅผ (์ ์, ์ด๋ฆ)์ผ๋ก ๋ฌถ์ ๋ค์ ์ ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ์ ์ํํด์ผ ํ๋ค
- ํํ ๋ฌธ๋ฒ ์ฐธ๊ณ
# N์ ์
๋ ฅ๋ฐ๊ธฐ
n = int(input())
# N๋ช
์ ์ ๋ณด๋ฅผ ์
๋ ฅ๋ฐ์ ๋ฆฌ์คํธ์ ์ ์ฅ
student = []
for i in range(n):
input_data = input().split()
# ์ด๋ฆ์ ๋ฌธ์์ด ๊ทธ๋๋ก, ์ ์๋ ์ ์ํ์ผ๋ก ๋ณํํ์ฌ ์ ์ฅ
student.append((input_data[0], int(input_data[1])))
# ํค๋ฅผ ์ด์ฉํ์ฌ, ์ ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ
student = sorted(student, key=lambda student : student[1])
# ์ ๋ ฌ์ด ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅ
for i in student:
print(i[0], end=' ')
์ค์ ๋ฌธ์ 4. ๋ ๋ฐฐ์ด์ ์์ ๊ต์ฒด
- ๋ฐฐ์ด A์์ ๊ฐ์ฅ ์์ ์์๋ฅผ ๊ณจ๋ผ์, ๋ฐฐ์ด B์์ ๊ฐ์ฅ ํฐ ์์์ ๊ต์ฒด๋ฅผ ํ๋ค. ๋จ ๋ฐฐ์ด A์์ ๊ฐ์ฅ ์์ ์์๊ฐ B์์ ๊ฐ์ฅ ํฐ ์์๋ณด๋ค ์์ ๋๋ง ๊ต์ฒด๋ฅผ ์ํํด์ผ ํ๋ค. ์ด๋ฌํ ๊ณผ์ ์ K๋ฒ ๋ฐ๋ณตํ๋ค
- ๋ ๋ฐฐ์ด์ ์์๊ฐ ์ต๋ 100,000๊ฐ๊น์ง ์ ๋ ฅ๋ ์ ์์ผ๋ฏ๋ก O(NlogN)์ ๋ณด์ฅํ๋ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํด์ผ ํ๋ค.
n, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort() # ๋ฐฐ์ด A๋ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ ์ํ
b.sort(reverse=True) # ๋ฐฐ์ด B๋ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ ์ํ
# ์ฒซ ๋ฒ์งธ ์ธ๋ฑ์ค๋ถํฐ ํ์ธํ๋ฉฐ, ๋ ๋ฐฐ์ด์ ์์๋ฅผ ์ต๋ K๋ฒ ๋น๊ต
for i in range(k):
# A์ ์์๊ฐ B์ ์์๋ณด๋ค ์์ ๊ฒฝ์ฐ
if a[i] < b[i]:
# ๋ ์์๋ฅผ ๊ต์ฒด
a[i], b[i] = b[i], a[i]
else: # A์ ์์๊ฐ B์ ์์๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ๋, ๋ฐ๋ณต๋ฌธ์ ํ์ถ
break
print(sum(a)) # ๋ฐฐ์ด A์ ๋ชจ๋ ์์์ ํฉ์ ์ถ๋ ฅ