ํ์ด์ฌ์์ ์ด์ฐจ์ ๋ฆฌ์คํธ๋ฅผ ์ถ๋ ฅํ ๋, ๊ฐ ํ์ ๋ณด๊ธฐ ์ข๊ฒ ์ถ๋ ฅํ๋ ๋ค์ํ ๋ฐฉ๋ฒ์ด ์๋ค.์ด๋ฒ ํฌ์คํ
์์๋ ๋ํ์ ์ธ 5๊ฐ์ง ๋ฐฉ๋ฒ์ ์ ๋ฆฌํด๋ณด๋ ค๊ณ ํ๋ค. 1. join๊ณผ map์ ์ด์ฉํ ๋ฐฉ๋ฒ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ๋ฐฉ๋ฒ ์ค ํ๋๋ join๊ณผ map์ ์ด์ฉํด ๊ฐ ํ์ ๋ฌธ์์ด๋ก ๋ณํํ ํ ์ถ๋ ฅํ๋ ๊ฒ์ด๋ค.for row in distances: print(' '.join(map(str, row)))map ํจ์๋ ๋ฆฌ์คํธ์ ๊ฐ ์์์ str ํจ์๋ฅผ ์ ์ฉํด ๋ฌธ์์ด๋ก ๋ณํํ๊ณ , join ๋ฉ์๋๋ ์ด๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ํ๋์ ๋ฌธ์์ด๋ก ํฉ์น๋ค. 2. ์ธํจํน ์ฐ์ฐ์ *๋ฅผ ์ด์ฉํ ๋ฐฉ๋ฒํ์ด์ฌ์ print ํจ์๋ ์ฌ๋ฌ ์ธ์๋ฅผ ๋ฐ์ ๋ ๊ธฐ๋ณธ์ ์ผ๋ก ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ์ถ๋ ฅํ๋ค. ์ด๋ฅผ ์ด์ฉํ๋ฉด ๋ณด๋ค ์ง๊ด์ ์ผ๋ก ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค..
1. ์ ์ ์๋ฆฟ์ ๋ง์ถ๊ธฐ์ ์์ ์๋ฆฟ์๋ฅผ ๋ง์ถ๋ ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ์ zfill ๋ฉ์๋, ํฌ๋งท ๋ฌธ์์ด, ๊ทธ๋ฆฌ๊ณ rjust ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. zfill ๋ฉ์๋zfill ๋ฉ์๋๋ ๋ฌธ์์ด์ ์ผ์ชฝ์ 0์ ์ถ๊ฐํ์ฌ ์ง์ ๋ ๊ธธ์ด๋ก ๋ง์ถ๋ค.number = 42formatted_number = str(number).zfill(4)print(formatted_number) # ์ถ๋ ฅ: 0042 ํฌ๋งท ๋ฌธ์์ดํฌ๋งท ๋ฌธ์์ด์ ์ฌ์ฉํ๋ฉด ๋ ์ ์ฐํ๊ฒ ์ซ์๋ฅผ ํฌ๋งทํ ์ ์๋ค. ์๋ฅผ ๋ค์ด, ์ ์๋ฅผ ๋ค ์๋ฆฌ๋ก ๋ง์ถ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ํ๋ค.number = 42formatted_number = f"{number:04}"print(formatted_number) # ์ถ๋ ฅ: 0042 rjust ๋ฉ์๋rjust ๋ฉ์๋๋ ๋ฌธ์์ด์ ์ผ์ชฝ์ ..
Python์์ ๋ฆฌ์คํธ๋ฅผ ์ ๋ ฌํ๋ ๋ฐ ์ฌ์ฉ๋๋ ๋ ๊ฐ์ง ์ฃผ์ ๋ฐฉ๋ฒ์ sort() ๋ฉ์๋์ sorted() ํจ์์ด๋ค. 1. sort() ๋ฉ์๋sort()๋ ๋ฆฌ์คํธ ์์ฒด๋ฅผ ์ ๋ ฌํ๋ค. ์ฆ, ํธ์ถ๋ ๋ฆฌ์คํธ๋ฅผ ์ง์ ์์ ํ๊ณ ์๋ฌด๊ฒ๋ ๋ฐํํ์ง ์๋๋ค. (๋ฐํ ๊ฐ None)์ด ๋ฉ์๋๋ ๋ฆฌ์คํธ์๋ง ์ ์ฉ๋๋ฉฐ, ๋ค๋ฅธ ๋ฐ๋ณต ๊ฐ๋ฅํ(iterable) ๋ฐ์ดํฐ ์ ํ์๋ ์ฌ์ฉํ ์ ์๋ค. 2. sorted() ํจ์sorted()๋ ์ด๋ค ๋ฐ๋ณต ๊ฐ๋ฅํ ๊ฐ์ฒด๋ ์
๋ ฅ์ผ๋ก ๋ฐ์ ์ ๋ ฌ๋ ์ ๋ฆฌ์คํธ๋ฅผ ๋ฐํํ๋ค. ์ด๋ ๋ฆฌ์คํธ๋ฟ๋ง ์๋๋ผ ๋ฌธ์์ด, ํํ, ๋์
๋๋ฆฌ์ ํค ๋ฑ ๋ค์ํ ๋ฐ์ดํฐ ์ ํ์ ์ฌ์ฉ๋ ์ ์๋ค.์๋ ๋ฐ์ดํฐ๋ ์์ ๋์ง ์๊ณ , ์ ๋ ฌ๋ ์๋ก์ด ๋ฆฌ์คํธ๊ฐ ๊ฒฐ๊ณผ๋ก ๋ฐํ๋๋ค. ์ฑ๋ฅ ์ฐจ์ด์๋ ์ธก๋ฉด: sort()์ sorted()๋ ๋ด๋ถ์ ์ผ๋ก ๋..
์ฒซ ๋ฒ์งธ ์์๋ ๋ด๋ฆผ์ฐจ์์ผ๋ก, ๋ ๋ฒ์งธ ์์๋ ์ค๋ฆ์ฐจ์์ผ๋ก, ์ธ ๋ฒ์งธ ์์๋ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ์์ # 2์ฐจ์ ๋ฆฌ์คํธ ์์ฑ two_dim_list = [ [3, 6, 9], [2, 5, 8], [3, 6, 7], [1, 4, 7], [2, 5, 10] ] # ์ฐ์ ์์์ ๋ฐ๋ผ ์ ๋ ฌํ๋ ํจ์ ์ ์ sorted_list = sorted(two_dim_list, key=lambda x: (-x[0], x[1], -x[2])) # ๊ฒฐ๊ณผ ์ถ๋ ฅ for item in sorted_list: print(item) ๊ด๋ จ ๋ฌธ์ ) ๋ฐฑ์ค 10825. ๊ตญ์์ n = int(input()) students = [] for _ in range(n): name, kor, eng, math = input().split() stud..
ํด์ฆ๋ค์ ์ฝ๋๋ค์ ์ฌ์ฉํ๋ ์ํฉ์ ๊ตฌ๋ถํด๋ณด์.a = [list(map(int, input())) for _ in range(n)]a = [list(map(int, input().split())) for _ in range(n)]std_list = [input().split() for _ in range(n)]for _ in range(n): name, kor, eng, math = input().split() students.append((name, int(kor), int(eng), int(math)))a, *b = map(int, input().split()) ์ ๋ตa = [list(map(int, input())) for _ in range(n)]-> ์ ์๋ก ๋ณํํด์ผ๋๊ณ , ์
๋ ฅ ๊ฐ ๋์ด..
table = copy ? table = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] copy = table ์ ์ฝ๋๋ ์ด๋ป๊ฒ ๋์ํ๊ฒ ๋ ๊น? `copy = table`๋ผ๋ ์ฝ๋๋ ์ค์ ๋ก 2์ฐจ์ ๋ฐฐ์ด `table`์ ์ฐธ์กฐ๋ฅผ `copy`๋ผ๋ ๋ณ์์ ํ ๋นํ๋ ๊ฒ์ด๋ค. ์๋ก์ด 2์ฐจ์ ๋ฐฐ์ด์ ์์ฑํ๋ ๊ฒ์ด ์๋๋ผ, `table`๊ณผ `copy`๊ฐ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ฐธ์กฐํ๊ฒ ๋๋ค. ์ฆ, ํ๋์ ๋ฆฌ์คํธ๋ฅผ ๋ ๊ฐ์ ์ด๋ฆ์ผ๋ก ๊ฐ๋ฆฌํค๋ ๊ฒ์ด๋ค. ์ด๋ ํ์ด์ฌ์์ ๊ฐ์ฒด์ ์ฐธ์กฐ๋ฅผ ๋ค๋ฃฐ ๋ ์ผ๋ฐ์ ์ธ ๋์ ๋ฐฉ์์ด๋ค. table = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]] copy = table table[0][0] = 100 print(copy) # ..
๋ฌธ์ ์์ฝ ๊ณ ์๋๋ก๋ฅผ ์ด๋ํ๋ ์ฐจ๋์ ๊ฒฝ๋ก routes ๊ฐ ๋งค๊ฐ๋ณ์, ๋ชจ๋ ์ฐจ๋์ด ํ๋ฒ์ ๋จ์์ฉ ์นด๋ฉ๋ผ๋ฅผ ๋ง๋๋ ค๋ฉด ์ต์ ๋ช ๋์ ์นด๋ฉ๋ผ ์ค์นํด์ผํ๋์ง return ์ฐจ๋์ ๋์๋ 1๋ ์ด์ 10,000๋ ์ดํ routes์๋ ์ฐจ๋์ ์ด๋ ๊ฒฝ๋ก ํฌํจ, routes[i][0]์๋ i๋ฒ์งธ ์ฐจ๋์ด ๊ณ ์๋๋ก์ ์ง์
ํ ์ง์ , routes[i][1]์๋ i๋ฒ์งธ ์ฐจ๋์ด ๊ณ ์๋๋ก์์ ๋๊ฐ ์ง์ ์ง์
/์ง์ถ ์ง์ ์์๋ ์นด๋ฉ๋ผ๋ฅผ ๋ง๋ ๊ฒ return routes return [[-20,-15], [-14,-5], [-18,-13], [-5,-3]] 2 return 5 ์ง์ ์ ์นด๋ฉ๋ผ๋ฅผ ์ค์นํ๋ฉด ๋ ๋ฒ์งธ, ๋ค ๋ฒ์งธ ์ฐจ๋์ด ์นด๋ฉ๋ผ๋ฅผ ๋ง๋ฉ๋๋ค. 15 ์ง์ ์ ์นด๋ฉ๋ผ๋ฅผ ์ค์นํ๋ฉด ์ฒซ ๋ฒ์งธ, ์ธ ๋ฒ์งธ ์ฐจ๋์ด ์นด๋ฉ๋ผ๋ฅผ ๋ง๋ฉ๋๋ค. ๋์ ํ์ด (..
๋ฌธ์ ์์ฝ ๊ตฌ๋ช
๋ณดํธ๋ฅผ ์ต๋ํ ์ ๊ฒ ์ฌ์ฉํ์ฌ ๋ชจ๋ ์ฌ๋์ ๊ตฌ์ถํ๋ ค๊ณ ํฉ๋๋ค. ์ฌ๋๋ค์ ๋ชธ๋ฌด๊ฒ๋ฅผ ๋ด์ ๋ฐฐ์ด people๊ณผ ๊ตฌ๋ช
๋ณดํธ์ ๋ฌด๊ฒ ์ ํ limit๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๋ชจ๋ ์ฌ๋์ ๊ตฌ์ถํ๊ธฐ ์ํด ํ์ํ ๊ตฌ๋ช
๋ณดํธ ๊ฐ์์ ์ต์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ์ฌํญ ๋ฌด์ธ๋์ ๊ฐํ ์ฌ๋์ 1๋ช
์ด์ 50,000๋ช
์ดํ์
๋๋ค. ๊ฐ ์ฌ๋์ ๋ชธ๋ฌด๊ฒ๋ 40kg ์ด์ 240kg ์ดํ์
๋๋ค. ๊ตฌ๋ช
๋ณดํธ์ ๋ฌด๊ฒ ์ ํ์ 40kg ์ด์ 240kg ์ดํ์
๋๋ค. ๊ตฌ๋ช
๋ณดํธ์ ๋ฌด๊ฒ ์ ํ์ ํญ์ ์ฌ๋๋ค์ ๋ชธ๋ฌด๊ฒ ์ค ์ต๋๊ฐ๋ณด๋ค ํฌ๊ฒ ์ฃผ์ด์ง๋ฏ๋ก ์ฌ๋๋ค์ ๊ตฌ์ถํ ์ ์๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค. ์
์ถ๋ ฅ ์ people limit return [70, 50, 80, 50] 100 3 [70, 80, 50] 100..
1์ฐจ ์๋ (์ค๋ต) def solution(n, lost, reserve): answer = 0 # ๊ณตํต๋ ์์ ์ ๊ฑฐํ ๋ฐฐ์ด valid_lost = [x for x in lost if x not in reserve] valid_reserve = [x for x in reserve if x not in lost] count = 0 for i, value in enumerate(valid_lost): # ํ๋ ํฐ ๊ฐ ์๋์ง, ํ๋ ์์ ๊ฐ ์๋์ง if valid_lost[i] + 1 in valid_reserve: valid_reserve.remove(valid_lost[i] + 1) count += 1 elif valid_lost[i] - 1 in valid_reserve: valid_reserve.rem..
์ด๊ฒ์ด ์ทจ์
์ ์ํ ์ฝ๋ฉํ
์คํธ๋ค with ํ์ด์ฌ ํ์ด์ฌ์ ์ผ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์๋ชป ์ฌ์ฉํ๋ฉด ์ํ ์๊ฐ์ด ๋นํจ์จ์ ์ผ๋ก ์ฆ๊ฐํ๋ฏ๋ก ๋ฌธ๋ฒ๊ณผ ์ ์์ ์ ์ ๊ธฐ์ตํด๋์. ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ : ํน์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ์์ฃผ ์ฌ์ฉ๋๋ ํ์ค ์์ค์ฝ๋๋ฅผ ๋ฏธ๋ฆฌ ๊ตฌํํด ๋์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฝํ
์์๋ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ ์ ์๋๋ก ํ์ฉํ๋ฏ๋ก ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ฉด ์์ค์ฝ๋ ์์ฑ๋์ ๋ํ ๋ถ๋ด์ ์ค์ผ ์ ์๋ค. C++ ์ STL ์ ๊ฐ์ด, ํ์ด์ฌ์์๋ ํ์ด์ฌ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ด์ฉํ ์ ์๋ค. ํ์ํ ๊ธฐ๋ฅ์ด ์๋ค๋ฉด ์ฐพ์์ ์๋์ ๊ณต์ ๋ฌธ์์์ ์ฐพ์์ ์ฌ์ฉํ๋ ์ต๊ด์ ๊ธฐ๋ฅด์. https://docs.python.org/ko/3/library/index.html The Python Standard Library While The ..