์ด๊ฒ์ด ์ทจ์ ์ ์ํ ์ฝ๋ฉํ ์คํธ๋ค์์ ์ ๊ณตํ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด์๋ค.
๋๋ถ๋ถ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ์ ๊ณตํ๋ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๊ฐ์ฅ ํจ์จ์ ์ด๊ฒ ๊ตฌํ๋์ด ์๋ค. ํ์ด์ฌ์ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๋ณํฉ ์ ๋ ฌ์ ์ฝ์
์ ๋ ฌ์ ์์ด๋์ด๋ฅผ ๋ํ ํ์ด๋ธ๋ฆฌ๋ ๋ฐฉ์์ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๊ณ ์๊ธฐ ๋๋ฌธ์ ์ต์
์ ๊ฒฝ์ฐ์๋ O(N logN)
์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค๊ณ ํ๋ค. ๊ฒฐ๊ตญ, ์ฐ๋ฆฌ๊ฐ ์ง์ ํต ์ ๋ ฌ์ ๊ตฌํํ๋ ๊ฒ๋ณด๋ค ๋์ฑ ํจ๊ณผ์ ์ด๋ค. ๋ฐ๋ผ์, ๋ฌธ์ ์์ ํน๋ณํ ์๊ตฌ๋ฅผ ํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ ์ด์ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ต๋ํ ํ์ฉํ๋๋ก ํ์.
์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ด๋ก ์ ํด๋น ํฌ์คํธ์ ์ ๋ฆฌํด ๋์์ผ๋, ์ฐธ๊ณ ํ์๊ธธ ๋ฐ๋๋ค.
์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ฆ์ฐจ์์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ ๊ณตํ๋ค. ํด๋น ๋ฌธ์ ์์๋ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ์๊ตฌํ๋๋ฐ, sorted()
ํจ์์ reverse
๋งค๊ฐ๋ณ์๋ฅผ ์ ํ์ฉํ๋ฉด ์ฝ๊ฒ ํด๊ฒฐํ ์ ์๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
n = int(input())
_list = []
for _ in range(n):
_list.append(int(input()))
_list.sort(reverse=True)
# unpacking
print(*_list)
๋ฆฌ์คํธ์ ์์๊ฐ 2๊ฐ ์ด์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๊ณ ์์ ๋, ํ์ด์ฌ์ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ฒซ๋ฒ์งธ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ์ ํ๋ค. ํด๋น ๋ฌธ์ ์์๋ ๋๋ฒ์งธ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ ๊ฒ์ ์๊ตฌํ๋๋ฐ, ์ด๋ key
๋งค๊ฐ๋ณ์๋ฅผ ํตํด ์ฝ๊ฒ ํด๊ฒฐํ ์ ์๋ค. key
๋งค๊ฐ๋ณ์๋ฅผ ๊ฐ๋ sorted()
ํจ์๋ key
๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
n = int(input())
_list = []
for _ in range(n):
a, b = input().split()
_list.append((a, int(b)))
_list.sort(key=lambda x: x[-1])
for i in _list:
print(i[0], end=" ")
๋ฐฐ์ด A๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก, ๋ฐฐ์ด B๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ 0๋ฒ ์ธ๋ฑ์ค๋ถํฐ k-1๋ฒ ์ธ๋ฑ์ค๊น์ง์ ๊ฐ๋ค์ ๋ฐ๊พธ์ด์ฃผ๋ฉด ๋๋ค.
์์ ์ฝ๋
n, k = map(int, input().split())
listA = list(map(int, input().split()))
listB = list(map(int, input().split()))
listA.sort()
listB.sort(reverse=True)
for idx in range(k):
if listA[idx] < listB[idx]:
listA[idx], listB[idx] = listB[idx], listA[idx]
# ๊ต์ฒดํ์ง ์๋ ๊ฒฝ์ฐ
else:
break
print(sum(listA))
์ฒ์์ ๊ฐ๊ณผํ ๊ฒ์ด list A
์ ๊ฐ์ฅ ์์ ๊ฐ์ด list B
์ ๊ฐ์ฅ ํฐ ๊ฐ๋ณด๋ค ํฐ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ ์ ์๋ค. ๊ทธ๋์ ์กฐ๊ฑด๋ฌธ์ ํตํด ํด๋น ์กฐ๊ฑด์ ์ฒ๋ฆฌํด์ฃผ์๋ค.
์์ ๋งํ๋ฏ์ด, 2๊ฐ ์ด์์ ๋ฐ์ดํฐ๋ฅผ ์์๋ก ํ๋ ๋ฆฌ์คํธ์ ์ ๋ ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ ์ฉํ๋ฉด ์ฒซ๋ฒ์งธ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ๋๋ค. ์ด ๋, key
๋งค๊ฐ๋ณ์๋ฅผ ํ์ฉํ์ฌ ์ ๋ ฌ ๊ธฐ์ค์ ์ ํ ์ ์๊ณ , 2๊ฐ ์ด์์ key
๋ฅผ ์ ๊ณตํ๋ค๋ฉด ์ด๋ ์ฐ์ ์์์ ์ญํ ์ ํ๊ฒ ๋๋ค. ๊ทธ๋์ key
์ ์ฒซ๋ฒ์งธ ์์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๊ณ , ์ฒซ๋ฒ์งธ ์์๊ฐ ๊ฐ์ ๊ฐ๋ค์ด ์์ผ๋ฉด ํด๋น ๋ฐ์ดํฐ๋ ๋๋ฒ์งธ ์์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
import sys
input = sys.stdin.readline
n = int(input())
_list = []
for _ in range(n):
name, kor, eng, math = input().split()
_list.append((name, int(kor), int(eng), int(math)))
_list.sort(key=lambda x: (-x[1], x[2], -x[3], x[0]))
for item in _list:
print(item[0])
ํด๋น ๋ฌธ์ ์ ํต์ฌ ์์ด๋์ด๋ ์ ๋ ฌํ ๊ฐ ์ค ๊ฐ์ฅ ๊ฐ์ด๋ฐ์ ๊ฐ์ ์ ํํ๋ฉด ์ต์ ์ ํด๋ฅผ ๋ฝ์๋ผ ์ ์๋ค๋ ๊ฒ์ด๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
n = int(input())
house = list(map(int, input().split()))
print(sorted(house)[(n-1) // 2])
๊ณ์ ์ ๋ ฌ์ ํ์ฉํ์ฌ ๊ฐ ์คํ
์ด์ง์ ๋จธ๋ฌผ๋ฌ ์๋ ํ๋ ์ด์ด๋ค์ ์๋ฅผ ๋ฐฐ์ด์ ์ ์ฅํ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ฐ๋ณต๋ฌธ์ ํตํด ๋ฎ์ ์คํ
์ด์ง๋ถํฐ ์ฐจ๋ก๋ก ์ ๊ทผํ์ฌ ํ์ฌ ์คํ
์ด์ง์ ๋จธ๋ฌผ๋ฌ ์๋ ํ๋ ์ด์ด ์ / ํ์ฌ ์คํ
์ด์ง์ ์ง์
ํ ํ๋ ์ด์ด
๋ฅผ ๊ตฌํด์ฃผ์๊ณ , ์ ์ฒด ํ๋ ์ด์ด์์ ํ์ฌ ์คํ
์ด์ง์ ๋จธ๋ฌผ๋ฌ ์๋ ํ๋ ์ด์ด๋ฅผ ๋นผ์ฃผ์ด ๋ค์ ์คํ
์ด์ง์ ์ง์
ํ ํ๋ ์ด์ด ์๋ฅผ ๋ฐํํ๋ค. ์ด๋ฅผ ์คํ
์ด์ง ๋๋ฒ์ ํจ๊ป answer
๋ฐฐ์ด์ ๋ฃ์ด ๋ฐ๋ณต๋ฌธ์ด ๋๋ ๋ค์๋ sorted()
ํจ์์ key
๋งค๊ฐ๋ณ์๋ฅผ ํ์ฉํ์ฌ ์คํจ์จ์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํด์ฃผ์๋ค.
๋ด๊ฐ ์์ฑํ ์ฝ๋
# ๊ณ์ ์ ๋ ฌ
stay = [0] * (n + 1)
for i in range(len(stages)):
stay[stages[i]-1] += 1
# ์ ์ฒด ํ๋ ์ด์ด ์
player = len(stages)
answer = []
for idx in range(n):
if player:
answer.append((idx, stay[idx] / player))
# ํ์ฌ ์คํ
์ด์ง์ ์ง์
ํ ํ๋ ์ด์ด๊ฐ 0๋ช
์ธ ๊ฒฝ์ฐ
else:
answer.append((idx, 0))
player -= stay[idx]
# ์คํจ์จ์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ
answer.sort(key=lambda x: -x[1])
answer = [i[0] + 1 for i in answer]
print(answer)
--
๐๐ปโโ๏ธ ๋ ๋๋น, ์ด๊ฒ์ด ์ทจ์ ์ ์ํ ์ฝ๋ฉํ ์คํธ๋ค