์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |
- https://youtube.com/playlist?list=PLuHgQVnccGMA5836CvWfieEQy0T0ov6Jh&si=FTaYv8m21EhO-A2K
- eport
- ๋๊ธฐ
- ajax
- https://m.blog.naver.com/tt2t2am1118/221010125300
- sql
- JS #ํ๋ก์ ํธ
- ํผํ
- ๋น๋๊ธฐ
- db
- json
- promise
- object
- js
- webpack
- slow and steady
- Project
- async
- setTimeout()
- callback
- database
- await
- Porject
- ๊ฒ์
- addEventListener
- ์ฐธ๊ณ ๋ธ๋ก๊ทธ
- prj
- mysql
- Import
- execCommand
- Today
- Total
๋ชฉ๋ก๐ง Algorithm (52)
C-log

split()ํจ์๋ ์ ํํ ๋ฌด์์ธ๊ฐ. split์ ๋ฌธ์์ด์ ํน์ ๊ตฌ๋ถ์๋ฅผ ๊ธฐ์ค์ผ๋ก list๋ก ์ ํํด์ฃผ๋ ํจ์์ด๋ค. ์ฆ, input, ๋ฌธ์์ด์ list๋ก ๋ฐ์๊ณ ๊ทธ๊ฒ์ listํ์์ผ๋ก ์ ์๋๋ ๊ฒ์ด๋ค. ์์๋ฅผ ๋ณด๋ฉฐ ํด๋น ํจ์๋ฅผ ์ดํดํด๋ณด์ N = input().split() print(N) 1 2 3 4 ['1', '2', '3', '4'] ์ด์ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค. ๋ค๋ฅธ ์์๋ ํ๋ฒ ์ดํด๋ณด์. n = "a.b.c.d.e.f" sp0 = n.split() sp1 = n.split('.') print(f"sp0 =>{sp0}") print(f"sp0 =>{sp1}") n = "a b c d e f" sp2 = n.split(sep=' ') print(f"sp0 =>{sp2}") sp0 =>['a.b.c.d.e..

์ฐ์ํด์ ๊ฐ์ ๋ฌดํ์ผ๋ก ์ ๋ ฅ๋ฐ๋ ์ฝ๋์ด๋ค. while True: print(input()) ์ด๋ ๊ฒ ์์ฑํ๋ฉด ๋ฐํ์์๋ฌ EOFError๊ฐ ์ถ๋ ฅ๋๋ค. ๋ฐ๋ผ์ ์์ธ์ฒ๋ฆฌ๋ฅผ ํ๊ธฐ ์ํด์ ์๋์ ๊ฐ์ด ์์ฑํด์ผ ํ๋ค. while True: try: print(input()) except EOFError: break try, except๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค. ์ฌ๊ธฐ์ EOFError๊ฐ ๋ฌด์์ธ์ง ํ์ธํด ๋ณด์. EOF๋ End Of File์ ์ฝ์๋ก ์ ๋ ฅ์ด ๋๋ ๋๊น์ง ์ข ๋ฃ๋ฅผ ํ๋ ๊ฒ์ด๋ค. ์ฆ ์ ๋ ฅ๊ฐ์ด ์์๋๊น์ง์ธ๋ฐ ์ด๋ฅผ ์์ธ์ฒ๋ฆฌ๋ฅผ ํจ์ผ๋ก์จ ๋ฐํ์์๋ฌ๋ฅผ ์์ธ์ฒ๋ฆฌ ํ ์ ์ด๋ ๊ฒ์ด๋ค. ์๋ ํฌ์คํ ๋ ํ๋ฒ ํ์ธํด๋ณด์. [๋ฐฑ์ค/Python] 11718๋ฒ : ๊ทธ๋๋ก ์ถ๋ ฅํ๊ธฐ ์๊ฐ ์ ํ ๋ฉ๋ชจ๋ฆฌ ์ ํ ๋ฌธ์ ํฐ์ด ์ ๋ต ๋น์จ 1 ์ด 256MB..

์ค๋ ์ค๊ฐ์ ๊ฒ์ ํต์ฌ ์ฝ๋๋ฅผ ๋จผ์ ์ดํด๋ณด์. a = ['TEST'] # -> False a = 'TEST' # -> True a = input() # -> True ์ด ์ ์ ์ฐจ์ด๋ ๋ฌด์์ด๊ฐ. ์ฒซ๋ฒ์งธ list์ธ a๋ ํ๋์ ์์๋ก ์ธ์ํ๋ค. ์ฆ, '[]'๊ดํธ ์์ ์๋ ์์๋ฅผ ํ๋์ index๋ก ์ธ์ํ๋ ๊ฒ์ด๋ค. ๋๋ฒ์งธ์ ์ธ๋ฒ์งธ a๋ ๋ฌธ์์ด์ด๋ค. in์ ์ฌ์ฉํด์ ํด๋น ๊ฐ์ ์ดํด ๋ณด์. n = ['apple'] N = 'ace' for i in range(len(N)): print(f"f/{N[i]}:{type(N[i])} n :{type(n)}=>{N[i] in n}") print(f"t/{N[i]}:{type(N[i])} n :{type(str(n))}=>{N[i] in str(n)}") f/a: n :..

์ ๋ ฅ๋ฐ์ ๋ฌธ์์ด์ reverseํ๋ ๋ฌธ์ ์๋ค. ์ฌ๊ธฐ์ ๋ฌธ์ ๋ ๋ณดํต ์ง์ ์ ์ด ๋์ ๋ฌธ์์ด์ reverse์ํค๋ ํจ์๋ฅผ ์ฌ์ฉํ๋๋ฐ ์ ๋ ฅ๋ฐ์ ๊ฐ์ ๋ค์ง๋ ๋ฐฉ๋ฒ์ ๋ฌธ์์ด ์ฌ๋ผ์ด์ฑ์ ํตํด์ ๊ฐ์ ๋ค์ง๋๋ค. reverse์ ๊ด๋ จ๋ ๊ธ์ ์ด์ ์ ํฌ์คํ ํด ๋์ ๊ธ์ ํ๋ฒ ์ดํด๋ณด๋ฉด ์ข์ ๋ฏํ๋ค. N1, N2 = input().split() N1 = int(N1[::-1]) N2 = int(N2[::-1]) print(max(N1, N2)) ๋ค๋ฅธ ์ฌ๋๋ค์ด ์ ์ ์ฝ๋๋ฅผ ๋ณด๋ if๋ else๋ฅผ ์ฌ์ฉํด์ N1๊ณผ N2์ ๊ฐ์ ๋น๊ตํ์ง๋ง ๊ฐ๋จํ๊ฒ maxํจ์๋ฅผ ์ฌ์ฉํด์ ๋ ๊ฐ์ ๋ฐฐ๊ตํด์ ํฐ ๊ฐ์ ์ฐพ์๋ด๋ ์ฝ๋๋ฅผ ์์ฑํ๋ค. ๋ณดํต max๋ฅผ list์์ ๊ฐ์ฅ ํฐ์๋ฅผ ์ฐพ์์ฃผ๋ ๋ฐฉ์์ผ๋ก๋ ์ฌ์ฉํ๋ค. ์๋์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ test = [3, ..

sortํจ์ ์ฌ์ฉํ๊ธฐ N = [3, 6, 2] print(f"{type(N[0])} -> {N}") N.sort() print(N.sort()) print(f"{type(N[0])} -> {N}") -> [3, 6, 2] None -> [2, 3, 6] sort๋ฅผ ์ฌ์ฉํ๊ณ ๋ ํ์ N์ list๊ฐ ์ ๋ ฌ์ด ๋์ด ์๋ ๋ชจ์ต์ ํ์ธ ํ ์ ์๋ค. print(N.sort())๋ฅผ ์ฌ์ฉํ๋ฉด ์๋ฌด๊ฒ๋ ๋ฐํ๋์ง ์๋ ๊ฒ์ ํ์ธ ํ ์ ์๋ค. ์ฌ์ค์ ์ฌ๊ธฐ์ sort๋ฅผ ๋๋ฒ ํธ์ถ ํ๋ค. ์์์ ๋ถํฐ print(N.sort())๊น์ง ํด์ ์ด 2๋ฒ์ ํธ์ถ ํ ๊ฒ์ด๋ค. ์ด๋ฅผ ๊ผญ ๊ธฐ์ตํด๋์. reverseํจ์ ์ฌ์ฉํ๊ธฐ N = [3, 6, 2] print(f"{type(N[0])} -> {N}") N.reverse() # prin..

*map์ ์ด์ฉํ input ๋ฐ๊ธฐ ์ด์ ๊น์ง map์ ์ด์ฉํด์ ์ฌ๋ฌ๊ฐ์ง ๊ฐ์ ์ ๋ ฅ๋ฐ์๋ค. ๊ธฐ๋ณธ์ ์ผ๋ก ์๋์ ๊ฐ์ด ์ฌ์ฉํ๋ค. ๊ฐ๊ธฐ int๋ก ๊ฐ ๋ณ์์ ์ ๋ ฅ์ ๋ฐ๋๋ค. A, B = map(int, input().split()) print(f"{A} and {B} type : {type(A)}") 123 123 123 and 123 type : 2๊ฐ์ง์ ๋ณ์์ 2๊ฐ์ง ๊ฐ์ ์ ๋ ฅ๋ฐ์ ๋ ๋ณดํต ์ด๋ ๊ฒ ์ ์๋ค. ํ์ง๋ง ํ๋์ ๋ณ์์ ์์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ๊ฐ์ ๋ฃ์ผ๋ฉด ์๋์ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป๋๋ค. N = map(int, input().split()) print(f"{N} type : {type(N)}") 123 type : ๋ฐ๋ก ํด๋น ๋ณ์์ ํ์ ์ด map์ผ๋ก ๋์ค๊ธฐ ๋๋ฌธ์ด๋ค. ์ด๋ฅผ ํ๋์ ๋ณ์๋ก ๋ด์์ ์ฌ๋ฌ ์ ๋ ฅ๋ฐ์ ๊ฐ์..

๋ด๊ฐ ํ์ด๋ธ ๋ฐฉ์์ 2์ฐจ์ ๋ฐฐ์ด์ ์ฌ์ฉํด์ ํ์๋ค. ์ ๋ต์ ๋ง์์ผ๋ ์ด์ ๋ค๋ฅด๊ฒ ํ์ด๋ธ ์ฌ๋๋ค์ ์ฝ๋๋ฅผ ํ๋ฒ ์ดํด๋ณด๊ณ ๋น๊ตํด๋ณด๋ ค๊ณ ํ๋ค. R = int(input()) for _ in range(R): S = input().split() for _ in range(len(S[1])): print(S[1][_] * int(S[0]), end="") print() ์๋ ์ฝ๋๋ ๋ค๋ฅธ ์ฌ๋์ด ํ์ด๋ธ ๋ฐฉ์์ด๋ค. n = int(input()) for _ in range(n): cnt, word = input().split() for x in word: print(x*int(cnt), end='') # end='' ์์ผ๋ก ๋ถ์ print() # ์ค๋๊น ์ ๋ฐ์ ์ผ๋ก ์์ ๋น์ทํ์ผ๋ ๋ณ์์ ๊ฐ์๊ฐ ๋ค๋ฅด๋ค. ๋๋ S๋ผ๋ ๋ณ..

str์ ๋ฐฐ์ด list์ list๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ์์ด์ ๋ง์ ํผ๋์ด ์์ด์ ์ค๊ฐ์ ๊ฒ์ผ๋ก ์ด๋ ๊ฒ ๊ธ์ ์จ๋ณธ๋ค. ์ฐ์ ์ฐ๋ฆฌ๊ฐ ์ผ๋ฐ์ ์ผ๋ก intํ์ ์ ์ ๋ ฅ๋ฐ๋ ๋ฐฉ๋ฒ๊ณผ str์ ์ ๋ ฅ๋ฐ์ for๋ฌธ์ ํตํด์ ํด๋น ๊ฐ๋ค์ ๋ฐํํ๋ ์ฝ๋๋ฅผ ์์ฑ ํด๋ณด๊ฒ ๋ค. *์ฐ์ intํ์ ์ผ๋ก ์ ๋ ค๋ฐ๋ ๋ฐฉ๋ฒ์ด๋ค. intํ์ ์ mapํจ์๋ก list๋ก ๋ง๋ค์ด input์ผ๋ก ์ง์ ์ ๋ ฅํ๋ ์ฝ๋์ด๋ค. ์ฌ๊ธฐ์ '_'๋ intํ์ ์ผ๋ก N์ ๊ฐ์ ๋ฐ๋๋ค. (์ฐธ๊ณ ๋ก range๋ฅผ ์ฌ์ฉํ์ง ์์ ๊ฒ์ด๋ค. ๋ง์ฝ range๋ก ๋ฐ์ผ๋ ค๋ฉด intํ์ ์ผ๋ก lenํจ์๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.) N = list(map(int, input())) print(N, type(N), type(N[0])) # N์ list๋ก ๋ฐํ๋๊ณ N[0]์ธ list์์๋ int๋ก ๋ฐํ๋๋ค. f..