๐ ์๊ณ ๋ฆฌ์ฆ(Algorithm)/๋ฐฑ์ค
๐ ๋ฌธ์ ๋ํ์ด๋ ๋ฐ๊ตฌ๋๋ฅผ ์ด N๊ฐ ๊ฐ์ง๊ณ ์๊ณ , ๊ฐ๊ฐ์ ๋ฐ๊ตฌ๋์๋ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ๋ฒํธ๊ฐ ์์๋๋ก ์ ํ์ ธ ์๋ค. ๋ฐ๊ตฌ๋๋ ์ผ๋ ฌ๋ก ๋์ฌ์ ธ ์๊ณ , ๊ฐ์ฅ ์ผ์ชฝ ๋ฐ๊ตฌ๋๋ฅผ 1๋ฒ์งธ ๋ฐ๊ตฌ๋, ๊ทธ ๋ค์ ๋ฐ๊ตฌ๋๋ฅผ 2๋ฒ์งธ ๋ฐ๊ตฌ๋, ..., ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋ฐ๊ตฌ๋๋ฅผ N๋ฒ์งธ ๋ฐ๊ตฌ๋๋ผ๊ณ ๋ถ๋ฅธ๋ค. ๋ํ์ด๋ ์์ผ๋ก M๋ฒ ๋ฐ๊ตฌ๋์ ์์๋ฅผ ํ์ ์ํค๋ ค๊ณ ๋ง๋ค๋ ค๊ณ ํ๋ค. ๋ํ์ด๋ ๋ฐ๊ตฌ๋์ ์์๋ฅผ ํ์ ์ํฌ ๋, ์์๋ฅผ ํ์ ์ํฌ ๋ฒ์๋ฅผ ์ ํ๊ณ , ๊ทธ ๋ฒ์ ์์์ ๊ธฐ์ค์ด ๋ ๋ฐ๊ตฌ๋๋ฅผ ์ ํํ๋ค. ๋ํ์ด๊ฐ ์ ํํ ๋ฐ๊ตฌ๋์ ๋ฒ์๊ฐ begin, end์ด๊ณ , ๊ธฐ์ค์ด ๋๋ ๋ฐ๊ตฌ๋๋ฅผ mid๋ผ๊ณ ํ์ ๋, begin, begin+1, ..., mid-1, mid, mid+1, ..., end-1, end ์์๋ก ๋์ด์๋ ๋ฐ๊ตฌ๋์ ์์๋ฅผ mid, mid+1, ..
๐ ์๊ณ ๋ฆฌ์ฆ(Algorithm)/๋ฐฑ์ค
๐ ๋ฌธ์ ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ง ๋จ์ด S๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ๊ฐ์ ์ํ๋ฒณ์ ๋ํด์, ๋จ์ด์ ํฌํจ๋์ด ์๋ ๊ฒฝ์ฐ์๋ ์ฒ์ ๋ฑ์ฅํ๋ ์์น๋ฅผ, ํฌํจ๋์ด ์์ง ์์ ๊ฒฝ์ฐ์๋ -1์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๐ ์
๋ ฅ ์ฒซ์งธ ์ค์ ๋จ์ด S๊ฐ ์ฃผ์ด์ง๋ค. ๋จ์ด์ ๊ธธ์ด๋ 100์ ๋์ง ์์ผ๋ฉฐ, ์ํ๋ฒณ ์๋ฌธ์๋ก๋ง ์ด๋ฃจ์ด์ ธ ์๋ค. ๐ ์ถ๋ ฅ ๊ฐ๊ฐ์ ์ํ๋ฒณ์ ๋ํด์, a๊ฐ ์ฒ์ ๋ฑ์ฅํ๋ ์์น, b๊ฐ ์ฒ์ ๋ฑ์ฅํ๋ ์์น, ... z๊ฐ ์ฒ์ ๋ฑ์ฅํ๋ ์์น๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด์ ์ถ๋ ฅํ๋ค. ๋ง์ฝ, ์ด๋ค ์ํ๋ฒณ์ด ๋จ์ด์ ํฌํจ๋์ด ์์ง ์๋ค๋ฉด -1์ ์ถ๋ ฅํ๋ค. ๋จ์ด์ ์ฒซ ๋ฒ์งธ ๊ธ์๋ 0๋ฒ์งธ ์์น์ด๊ณ , ๋ ๋ฒ์งธ ๊ธ์๋ 1๋ฒ์งธ ์์น์ด๋ค. ์์ ์
๋ ฅ baekjoon ์์ฒด ์ถ๋ ฅ 1 0 -1 -1 2 -1 -1 -1 -1 4 3 -1 -1 7 ..
๐ ์๊ณ ๋ฆฌ์ฆ(Algorithm)/๋ฐฑ์ค
๐ ๋ฌธ์ ๋ ์ ์ A์ B๋ฅผ ์
๋ ฅ๋ฐ์ ๋ค์, A+B๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๐ ์
๋ ฅ ์
๋ ฅ์ ์ฌ๋ฌ ๊ฐ์ ํ
์คํธ ์ผ์ด์ค๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. ๊ฐ ํ
์คํธ ์ผ์ด์ค๋ ํ ์ค๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ๊ฐ ์ค์ A์ B๊ฐ ์ฃผ์ด์ง๋ค. (0 < A, B < 10) ๐ ์ถ๋ ฅ ๊ฐ ํ
์คํธ ์ผ์ด์ค๋ง๋ค A+B๋ฅผ ์ถ๋ ฅํ๋ค. ์์ ์
๋ ฅ 1 1 2 3 3 4 9 8 5 2 ์์ ์ถ๋ ฅ 2 5 7 17 7 ๐ ๋ด ์ฝ๋ # 10951_A+B-4.Python # Algorithm # Created by ์ก์ง์ธ on 2023/05/03 while True: try: A, B = map(int, input().split()) print(A+B) except: break ๐ก ํ์ด ์
๋ ฅ์ ์ข
๋ฃ ์กฐ๊ฑด์ ์ฃผ์ง ์์ ๋๊ฐ ์๋ค. ์ด๋ด ๋๋ while ..
๐ ์๊ณ ๋ฆฌ์ฆ(Algorithm)/๋ฐฑ์ค
๋ฌธ์ 9๊ฐ์ ์๋ก ๋ค๋ฅธ ์์ฐ์๊ฐ ์ฃผ์ด์ง ๋, ์ด๋ค ์ค ์ต๋๊ฐ์ ์ฐพ๊ณ ๊ทธ ์ต๋๊ฐ์ด ๋ช ๋ฒ์งธ ์์ธ์ง๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์๋ฅผ ๋ค์ด, ์๋ก ๋ค๋ฅธ 9๊ฐ์ ์์ฐ์ 3, 29, 38, 12, 57, 74, 40, 85, 61 ์ด ์ฃผ์ด์ง๋ฉด, ์ด๋ค ์ค ์ต๋๊ฐ์ 85์ด๊ณ , ์ด ๊ฐ์ 8๋ฒ์งธ ์์ด๋ค. ์
๋ ฅ ์ฒซ์งธ ์ค๋ถํฐ ์ํ ๋ฒ์งธ ์ค๊น์ง ํ ์ค์ ํ๋์ ์์ฐ์๊ฐ ์ฃผ์ด์ง๋ค. ์ฃผ์ด์ง๋ ์์ฐ์๋ 100 ๋ณด๋ค ์๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์ต๋๊ฐ์ ์ถ๋ ฅํ๊ณ , ๋์งธ ์ค์ ์ต๋๊ฐ์ด ๋ช ๋ฒ์งธ ์์ธ์ง๋ฅผ ์ถ๋ ฅํ๋ค. ์์ ์
๋ ฅ 1 3 29 38 12 57 74 40 85 61 ์์ ์ถ๋ ฅ 1 85 8 ๋ด ์ฝ๋ L = [] for n in range(9): n = int(input()) L.append(n) print(max(L)) prin..
๐ ์๊ณ ๋ฆฌ์ฆ(Algorithm)/๋ฐฑ์ค
๋ฌธ์ N๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋, ์ต์๊ฐ๊ณผ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์
๋ ฅ ์ฒซ์งธ ์ค์ ์ ์์ ๊ฐ์ N (1 ≤ N ≤ 1,000,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ N๊ฐ์ ์ ์๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด์ ์ฃผ์ด์ง๋ค. ๋ชจ๋ ์ ์๋ -1,000,000๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 1,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์ฃผ์ด์ง ์ ์ N๊ฐ์ ์ต์๊ฐ๊ณผ ์ต๋๊ฐ์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด ์ถ๋ ฅํ๋ค. ์์ ์
๋ ฅ 1 ๋ณต์ฌ 5 20 10 35 30 7 ์์ ์ถ๋ ฅ 1 ๋ณต์ฌ 7 35 ๋ด ์ฝ๋ N = int(input()) #N ์ ์ L = list(map(int, input().split())) print(min(L), max(L), end=" ")
๐ ์๊ณ ๋ฆฌ์ฆ(Algorithm)/๋ฐฑ์ค
๋ฌธ์ ์ ์ N๊ฐ๋ก ์ด๋ฃจ์ด์ง ์์ด A์ ์ ์ X๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋, A์์ X๋ณด๋ค ์์ ์๋ฅผ ๋ชจ๋ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์
๋ ฅ ์ฒซ์งธ ์ค์ N๊ณผ X๊ฐ ์ฃผ์ด์ง๋ค. (1 ≤ N, X ≤ 10,000) ๋์งธ ์ค์ ์์ด A๋ฅผ ์ด๋ฃจ๋ ์ ์ N๊ฐ๊ฐ ์ฃผ์ด์ง๋ค. ์ฃผ์ด์ง๋ ์ ์๋ ๋ชจ๋ 1๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 10,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์์ด๋ค. ์ถ๋ ฅ X๋ณด๋ค ์์ ์๋ฅผ ์
๋ ฅ๋ฐ์ ์์๋๋ก ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด ์ถ๋ ฅํ๋ค. X๋ณด๋ค ์์ ์๋ ์ ์ด๋ ํ๋ ์กด์ฌํ๋ค. ์์ ์
๋ ฅ 1 10 5 1 10 4 9 2 3 8 5 7 6 ์์ ์ถ๋ ฅ 1 1 4 2 3 ๋ด ์ฝ๋ N, X = map(int, input().split()) a = list(map(int, input().split())) for num in a: if num < X:..