๋ชฉ๋ก์ฝ๋ฉํ ์คํธ/๋ฐฑ์ค(BOJ) (41)
๐ฉ๐ปโ๐พ

1๏ธโฃ๋ฌธ์ ์ค๋ช N๊ฐ์ ์๊ฐ ์ฃผ์ด์ก์ ๋, ์ด๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์์ ๊ฐ์ N(1 โค N โค 10,000,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด ์๋ 10,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. 3๏ธโฃ์ถ๋ ฅ ์ฒซ์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๊ฒฐ๊ณผ๋ฅผ ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ import sys input = sys.stdin.readline n = int(input())# ์ ๋ ฅ ๋ฐ์ ์์ ๊ฐ์ cnt = [0] * 10001 for i in range(n): cnt[int(input())] += 1 for i in range(10001): if cnt[i] != 0: for _ in range(cnt[..

1๏ธโฃ๋ฌธ์ ์ค๋ช N๊ฐ์ ์๊ฐ ์ฃผ์ด์ก์ ๋, ์ด๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์์ ๊ฐ์ N(1 โค N โค 1,000,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด ์๋ ์ ๋๊ฐ์ด 1,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค. ์๋ ์ค๋ณต๋์ง ์๋๋ค. 3๏ธโฃ์ถ๋ ฅ ์ฒซ์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๊ฒฐ๊ณผ๋ฅผ ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ 1. ๋ณํฉ์ ๋ ฌ์ ์ฌ์ฉํ ์ฝ๋ import sys input = sys.stdin.readline def merge_sort(list): if len(list)

1๏ธโฃ๋ฌธ์ ์ค๋ช ๋ฐฐ์ด์ ์ ๋ ฌํ๋ ๊ฒ์ ์ฝ๋ค. ์๊ฐ ์ฃผ์ด์ง๋ฉด, ๊ทธ ์์ ๊ฐ ์๋ฆฌ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํด๋ณด์. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์ ๋ ฌํ๋ ค๊ณ ํ๋ ์ N์ด ์ฃผ์ด์ง๋ค. N์ 1,000,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. 3๏ธโฃ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์๋ฆฌ์๋ฅผ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ ์๋ฅผ ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ 1. ์ ํ์ ๋ ฌ์ ์ด์ฉํ ์ฝ๋ n = list(input())# ์ ๋ ฌํ ์ for i in range(len(n)): max_idx = i# ์ต๋๊ฐ idx for j in range(i+1, len(n)): if n[j]>n[max_idx]: max_idx = j if n[j] > n[i]: temp = n[j] n[j]=n[i] n[i]=temp for i in range(len(n)): print(..

1๏ธโฃ๋ฌธ์ ์ค๋ช ์ธํ์ํ์๋ ATM์ด 1๋๋ฐ์ ์๋ค. ์ง๊ธ ์ด ATM์์ N๋ช ์ ์ฌ๋๋ค์ด ์ค์ ์์๋ค. ์ฌ๋์ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ๋ฒํธ๊ฐ ๋งค๊ฒจ์ ธ ์์ผ๋ฉฐ, i๋ฒ ์ฌ๋์ด ๋์ ์ธ์ถํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ Pi๋ถ์ด๋ค. ์ฌ๋๋ค์ด ์ค์ ์๋ ์์์ ๋ฐ๋ผ์, ๋์ ์ธ์ถํ๋๋ฐ ํ์ํ ์๊ฐ์ ํฉ์ด ๋ฌ๋ผ์ง๊ฒ ๋๋ค. ์๋ฅผ ๋ค์ด, ์ด 5๋ช ์ด ์๊ณ , P1 = 3, P2 = 1, P3 = 4, P4 = 3, P5 = 2 ์ธ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด๋ณด์. [1, 2, 3, 4, 5] ์์๋ก ์ค์ ์ ๋ค๋ฉด, 1๋ฒ ์ฌ๋์ 3๋ถ๋ง์ ๋์ ๋ฝ์ ์ ์๋ค. 2๋ฒ ์ฌ๋์ 1๋ฒ ์ฌ๋์ด ๋์ ๋ฝ์ ๋ ๊น์ง ๊ธฐ๋ค๋ ค์ผ ํ๊ธฐ ๋๋ฌธ์, 3+1 = 4๋ถ์ด ๊ฑธ๋ฆฌ๊ฒ ๋๋ค. 3๋ฒ ์ฌ๋์ 1๋ฒ, 2๋ฒ ์ฌ๋์ด ๋์ ๋ฝ์ ๋๊น์ง ๊ธฐ๋ค๋ ค์ผ ํ๊ธฐ ๋๋ฌธ์, ์ด 3+1+4 = 8๋ถ์ด ํ..

1๏ธโฃ๋ฌธ์ ์ค๋ช ์จ๋ผ์ธ ์ ์ง์ ๊ฐ์ ํ ์ฌ๋๋ค์ ๋์ด์ ์ด๋ฆ์ด ๊ฐ์ ํ ์์๋๋ก ์ฃผ์ด์ง๋ค. ์ด๋, ํ์๋ค์ ๋์ด๊ฐ ์ฆ๊ฐํ๋ ์์ผ๋ก, ๋์ด๊ฐ ๊ฐ์ผ๋ฉด ๋จผ์ ๊ฐ์ ํ ์ฌ๋์ด ์์ ์ค๋ ์์๋ก ์ ๋ ฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์จ๋ผ์ธ ์ ์ง ํ์์ ์ N์ด ์ฃผ์ด์ง๋ค. (1 โค N โค 100,000) ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ๊ฐ ํ์์ ๋์ด์ ์ด๋ฆ์ด ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค. ๋์ด๋ 1๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉฐ, 200๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๊ณ , ์ด๋ฆ์ ์ํ๋ฒณ ๋์๋ฌธ์๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ , ๊ธธ์ด๊ฐ 100๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๋ฌธ์์ด์ด๋ค. ์ ๋ ฅ์ ๊ฐ์ ํ ์์๋ก ์ฃผ์ด์ง๋ค. 3๏ธโฃ์ถ๋ ฅ ์ฒซ์งธ ์ค๋ถํฐ ์ด N๊ฐ์ ์ค์ ๊ฑธ์ณ ์จ๋ผ์ธ ์ ์ง ํ์์ ๋์ด ์, ๋์ด๊ฐ ๊ฐ์ผ๋ฉด ๊ฐ์ ํ ์์ผ๋ก ํ ์ค์ ํ ๋ช ์ฉ ๋์ด์ ์ด๋ฆ์ ๊ณต๋ฐฑ์ผ๋ก ..

1๏ธโฃ๋ฌธ์ ์ค๋ช ๋ฒ๋ธ ์ํธ ์๊ณ ๋ฆฌ์ฆ์ ๋ค์๊ณผ ๊ฐ์ด C++๋ก ์์ฑํ๋ค. ์ ์์ค์์ N์ ๋ฐฐ์ด์ ํฌ๊ธฐ์ด๊ณ , A๋ ์ ๋ ฌํด์ผ ํ๋ ๋ฐฐ์ด์ด๋ค. ๋ฐฐ์ด์ A[1]๋ถํฐ ์ฌ์ฉํ๋ค. ์์ ๊ฐ์ ์์ค๋ฅผ ์คํ์์ผฐ์ ๋, ์ด๋ค ๊ฐ์ด ์ถ๋ ฅ๋๋์ง ๊ตฌํด๋ณด์. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค. N์ 500,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ A[1]๋ถํฐ A[N]๊น์ง ํ๋์ฉ ์ฃผ์ด์ง๋ค. A์ ๋ค์ด์๋ ์๋ 1,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์ ๋๋ 0์ด๋ค. 3๏ธโฃ์ถ๋ ฅ ์ ๋ต์ ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ import sys input = sys.stdin.readline n = int(input())# ์ ๋ ฅ ๋ฐ์ ์์ ๊ฐ์ num = []# ์ ๋ ฅ ๋ฐ์ n๊ฐ์ ์๋ฅผ ์ ์ฅํ ๋ฆฌ์คํธ for i in range..

1๏ธโฃ๋ฌธ์ ์ค๋ช N๊ฐ์ ์๊ฐ ์ฃผ์ด์ก์ ๋, ์ด๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์์ ๊ฐ์ N(1 โค N โค 1,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด ์๋ ์ ๋๊ฐ์ด 1,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค. ์๋ ์ค๋ณต๋์ง ์๋๋ค. 3๏ธโฃ์ถ๋ ฅ ์ฒซ์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๊ฒฐ๊ณผ๋ฅผ ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค. ๐ฉ๐ปโ๐ป์์ฑํ ์ฝ๋ 1. ๋ฒ๋ธ์ ๋ ฌ์ ์ฌ์ฉํ ์ฝ๋ n = int(input())# ์ ๋ ฅ ๋ฐ์ ์์ ๊ฐ์ num = []# ์ ๋ ฅ ๋ฐ์ n๊ฐ์ ์ ์ ์ฅํ ๋ฆฌ์คํธ for i in range(n): num.append(int(input())) for i in range(n-1): for j in range(n-1-i): if num[j] >..

1๏ธโฃ๋ฌธ์ ์ค๋ช ์ ๋๊ฐ ํ์ ๋ค์๊ณผ ๊ฐ์ ์ฐ์ฐ์ ์ง์ํ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ๋ฐฐ์ด์ ์ ์ x (x โ 0)๋ฅผ ๋ฃ๋๋ค. ๋ฐฐ์ด์์ ์ ๋๊ฐ์ด ๊ฐ์ฅ ์์ ๊ฐ์ ์ถ๋ ฅํ๊ณ , ๊ทธ ๊ฐ์ ๋ฐฐ์ด์์ ์ ๊ฑฐํ๋ค. ์ ๋๊ฐ์ด ๊ฐ์ฅ ์์ ๊ฐ์ด ์ฌ๋ฌ๊ฐ์ผ ๋๋, ๊ฐ์ฅ ์์ ์๋ฅผ ์ถ๋ ฅํ๊ณ , ๊ทธ ๊ฐ์ ๋ฐฐ์ด์์ ์ ๊ฑฐํ๋ค. ํ๋ก๊ทธ๋จ์ ์ฒ์์ ๋น์ด์๋ ๋ฐฐ์ด์์ ์์ํ๊ฒ ๋๋ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์ฐ์ฐ์ ๊ฐ์ N(1โคNโค100,000)์ด ์ฃผ์ด์ง๋ค. ๋ค์ N๊ฐ์ ์ค์๋ ์ฐ์ฐ์ ๋ํ ์ ๋ณด๋ฅผ ๋ํ๋ด๋ ์ ์ x๊ฐ ์ฃผ์ด์ง๋ค. ๋ง์ฝ x๊ฐ 0์ด ์๋๋ผ๋ฉด ๋ฐฐ์ด์ x๋ผ๋ ๊ฐ์ ๋ฃ๋(์ถ๊ฐํ๋) ์ฐ์ฐ์ด๊ณ , x๊ฐ 0์ด๋ผ๋ฉด ๋ฐฐ์ด์์ ์ ๋๊ฐ์ด ๊ฐ์ฅ ์์ ๊ฐ์ ์ถ๋ ฅํ๊ณ ๊ทธ ๊ฐ์ ๋ฐฐ์ด์์ ์ ๊ฑฐํ๋ ๊ฒฝ์ฐ์ด๋ค. ์ ๋ ฅ๋๋ ์ ์๋ -231๋ณด๋ค ํฌ๊ณ , 231๋ณด๋ค ์๋ค. 3๏ธโฃ์ถ๋ ฅ ์ ๋ ฅ..

1๏ธโฃ๋ฌธ์ ์ค๋ช N์ฅ์ ์นด๋๊ฐ ์๋ค. ๊ฐ๊ฐ์ ์นด๋๋ ์ฐจ๋ก๋ก 1๋ถํฐ N๊น์ง์ ๋ฒํธ๊ฐ ๋ถ์ด ์์ผ๋ฉฐ, 1๋ฒ ์นด๋๊ฐ ์ ์ผ ์์, N๋ฒ ์นด๋๊ฐ ์ ์ผ ์๋์ธ ์ํ๋ก ์์๋๋ก ์นด๋๊ฐ ๋์ฌ ์๋ค. ์ด์ ๋ค์๊ณผ ๊ฐ์ ๋์์ ์นด๋๊ฐ ํ ์ฅ ๋จ์ ๋๊น์ง ๋ฐ๋ณตํ๊ฒ ๋๋ค. ์ฐ์ , ์ ์ผ ์์ ์๋ ์นด๋๋ฅผ ๋ฐ๋ฅ์ ๋ฒ๋ฆฐ๋ค. ๊ทธ ๋ค์, ์ ์ผ ์์ ์๋ ์นด๋๋ฅผ ์ ์ผ ์๋์ ์๋ ์นด๋ ๋ฐ์ผ๋ก ์ฎ๊ธด๋ค. ์๋ฅผ ๋ค์ด N=4์ธ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด ๋ณด์. ์นด๋๋ ์ ์ผ ์์์๋ถํฐ 1234 ์ ์์๋ก ๋์ฌ์๋ค. 1์ ๋ฒ๋ฆฌ๋ฉด 234๊ฐ ๋จ๋๋ค. ์ฌ๊ธฐ์ 2๋ฅผ ์ ์ผ ์๋๋ก ์ฎ๊ธฐ๋ฉด 342๊ฐ ๋๋ค. 3์ ๋ฒ๋ฆฌ๋ฉด 42๊ฐ ๋๊ณ , 4๋ฅผ ๋ฐ์ผ๋ก ์ฎ๊ธฐ๋ฉด 24๊ฐ ๋๋ค. ๋ง์ง๋ง์ผ๋ก 2๋ฅผ ๋ฒ๋ฆฌ๊ณ ๋๋ฉด, ๋จ๋ ์นด๋๋ 4๊ฐ ๋๋ค. N์ด ์ฃผ์ด์ก์ ๋, ์ ์ผ ๋ง์ง๋ง์ ๋จ๊ฒ ๋๋ ์นด๋๋ฅผ ..

1๏ธโฃ๋ฌธ์ ์ค๋ช ํฌ๊ธฐ๊ฐ N์ธ ์์ด A = A1, A2, ..., AN์ด ์๋ค. ์์ด์ ๊ฐ ์์ Ai์ ๋ํด์ ์คํฐ์ NGE(i)๋ฅผ ๊ตฌํ๋ ค๊ณ ํ๋ค. Ai์ ์คํฐ์๋ ์ค๋ฅธ์ชฝ์ ์์ผ๋ฉด์ Ai๋ณด๋ค ํฐ ์ ์ค์์ ๊ฐ์ฅ ์ผ์ชฝ์ ์๋ ์๋ฅผ ์๋ฏธํ๋ค. ๊ทธ๋ฌํ ์๊ฐ ์๋ ๊ฒฝ์ฐ์ ์คํฐ์๋ -1์ด๋ค. ์๋ฅผ ๋ค์ด, A = [3, 5, 2, 7]์ธ ๊ฒฝ์ฐ NGE(1) = 5, NGE(2) = 7, NGE(3) = 7, NGE(4) = -1์ด๋ค. A = [9, 5, 4, 8]์ธ ๊ฒฝ์ฐ์๋ NGE(1) = -1, NGE(2) = 8, NGE(3) = 8, NGE(4) = -1์ด๋ค. 2๏ธโฃ์ ๋ ฅ ์ฒซ์งธ ์ค์ ์์ด A์ ํฌ๊ธฐ N (1 โค N โค 1,000,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์ ์์ด A์ ์์ A1, A2, ..., AN (1 โค ..