๐๋ฐฑ์๋ : Backend
Spring JAVA EE dependency injection, transaction management์ ๊ธฐ๋ฅ์ ์ ๊ณตํ์ง๋ง ์ด๋ ค์, ๋ณต์ก๋๊ฐ ๋์, ์ฌ๋ฌ ๋์ฒ์ํฉ์ด ํ๋ฌ Spring ๋จ์ํ๊ฒ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ง ์ฐ๋ ๋ฐฉ์์ผ๋ก ๊น๋ํ๊ฒ ์ฒ๋ฆฌ dependency injection์ ๊ฐ์ด ์ฝ๊ฒ ๊ตฌํํ ์ ์๊ฒ ํด์ค JAVA EE์ ์์ญ์ ๋์ ํ๊ฒ ๋จ! Spring์ ์ฌ์ฉํ ์น๊ฐ๋ฐ (์ถ์ฒ : https://www.youtube.com/watch?v=XtXHIDnzS9c&t=491) ์น๊ฐ๋ฐ ํ ๋ ํ์ํ ์ธ๊ฐ์ง ์น MVC : SPRING์ด ์ ๊ณตํ๋ DI ๊ธฐ๋ฅ์ ์ดํดํด์ผ ํจ : DI์ ๋ํด์ ๋์จํ ๊ฒฐํฉ๋ ฅ๊ณผ ์ธํฐํ์ด์ค์ ๋ํด์ ์ดํด ํธ๋์ญ์
์ฒ๋ฆฌ๋ฐฉ๋ฒ : SPRING์ด ์ ๊ณตํ๋ AOP๋ฅผ ์ดํดํด์ผ ํจ ์ธ์ฆ๊ณผ ๊ถํ : Se..
๐๋ฐฑ์๋ : Backend
Spring Spring์ด ๊ฐ์ง๊ณ ์๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฅ๋ ฅ ์ํ๋ ๋ถํ(Dependency)์ด ๋ฌด์์ธ์ง, ์ด๋ป๊ฒ ๊ฒฐํฉ(Injection)๋์์ผ๋ฉด ํ๋์ง ์ค์ ํด์ฃผ๋ฉด Spring์ด DIํด์ค๋ค DI(Dependency Injection) (=๋ถํ ์กฐ๋ฆฝ) ํ๋ก๊ทธ๋จ์ ๊ฐ์ฒด์งํฅ์ผ๋ก ๋ง๋ค๊ฒ ๋ ๊ฒฝ์ฐ, ๊ฐ์ฒด๋ค์ ์กฐ๋ฆฝ๊ด๊ณ๋ก ๋ง๋ค์ด์ง๊ฒ ๋๋ค. A๋ผ๋ ํด๋์ค๊ฐ B๋ผ๋ ํด๋์ค๋ฅผ ๊ฐ์ฒดํ ํด์ ์ฌ์ฉํ๊ณ ์๋ค๊ณ ํ ๋ ๋๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ์ฌ์ฉํ ์ ์๋ค. 1.Composition has a (์ผ์ฒดํ)A๊ฐ ์์ฑ๋ ๋ B์ ๊ฐ์ฒด๋ฅผ ์์ฑํด์ ๊ฐ์ง๋ค. ์ด ๊ฒฝ์ฐ A๊ฐ B๋ฅผ ์ผ์ฒดํ์ผ๋ก ๊ฐ์ก๋ค๊ณ ํด์ Composition(์ผ์ฒดํ) has a ๊ด๊ณ๋ผ๊ณ ํ๋ค. ์ด๋ B๋ฅผ A์ ๋ถํ์ด๋ผ๊ณ ํ ์ ์๋๋ฐ, ์ด B๋ฅผ Dependency(๋ถํ)๋ผ๊ณ ํ๋ค. c..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
๊ธฐ์กด GCD๊ตฌํ๋ ๋ฐฉ๋ฒ for i in range(min(a,b),0,-1): if a%i==0 and b%i==0: print(i) break a์ b์ค ์์ ์ซ์๋ถํฐ ์์ํด์ 1๊น์ง ๊ฐ์ํ๋ฉด์, ์ ์ผ ์ฒ์ a์ b๋ชจ๋ ๋๋ ๋จ์ดํธ๋ฆฌ๋ ์๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ์ด๋ค. ์ด๋ฌํ ๊ฒฝ์ฐ๋ ๋ฌด์ฐจ๋ณ ๋์
(Brute Force)๋ก O(N)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค. ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ (Euclidean Algorithm) def gcd(a,b): # a>b if b==0: return a c=a%b return gcd(b,c) a๋ฅผ b๋ก ๋๋ ๋๋จธ์ง๋ฅผ r์ด๋ผ๊ณ ํ์๋, a์ b์ ์ต๋๊ณต์ฝ์๋ b์ r์ ์ต๋๊ณต์ฝ์์ ๊ฐ๋ค๋ ์ฑ์ง์ ์ด์ฉํ ๊ฒ์ด๋ค.(์ฌ๊ทํจ์ ์ด์ฉ) ์ด๋ฌํ ์ฑ์ง์ ํ์ฉํ์ฌ b์ r์ ์ต๋๊ณต์ฝ์ r0๋ฅผ ๊ตฌํ๊ณ r์ r0๋ก ..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
๋ณํฉ ์ ๋ ฌ(Merge Sort) ์ ๋ ฌ ์์ ๋ฆฌ์คํธ์ ๊ธธ์ด๊ฐ 1 ์ดํ์ด๋ฉด ์ด๋ฏธ ์ ๋ ฌ๋ ๊ฒ์ผ๋ก ๋ณธ๋ค. ๋ถํ (divide) : ์ ๋ ฌ๋์ง ์์ ๋ฐฐ์ด์ ์ ๋ฐ์ผ๋ก ์๋ผ ๋ ๋ฐฐ์ด๋ก ๋๋๋ค. ์ ๋ณต(conquer) : ๋๋ ์ง ๋ ๋ฐฐ์ด์ ์ฌ๊ท์ ์ผ๋ก ๋ณํฉ์ ๋ ฌ์ ์ฌ์ฉํด์ ์ ๋ ฌํ๋ค. ๊ฒฐํฉ(combine) : ๋ ๋ฐฐ์ด์ ๋ค์ ํ๋์ ์ ๋ ฌ๋ ๋ฐฐ์ด๋ก ํฉ๋ณํ๋ค. ๋ถํ ์ ๋ณต(divide and conquer)๊ธฐ๋ฒ๊ณผ ์ฌ๊ท ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ์ฌ ์ ๋ ฌํ๋ ๋ฐฉ์์ด๋ค. ์ํ ๊ณผ์ ์์ ๋ค์๊ณผ ๊ฐ์ด ์ ๋ ฌ๋์ง ์์ ๋ฐฐ์ด์ด ์๋ค. [6, 5, 3, 1, 8, 7, 2, 4]์ ๋ฐ์ผ๋ก ์๋ผ ๋ ๋ฐฐ์ด๋ก ๋๋๋ค. [6, 5, 3, 1] [8, 7, 2, 4]๋ค์ ๋ ๋ฐฐ์ด์ ๋๋ ๋ค ๊ฐ๋ก ๋๋๋ค. [6, 5] [3, 1] [8, 7] [2, 4]๋ง์ง๋ง์ผ๋ก ๋ค ..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
์นด์ดํ
์ ๋ ฌ(Counting Sort) ๊ณผ์ ๋ฐฐ์ด์ ์กด์ฌํ๋ ์์ ๊ฐ์๋ฅผ ์ธ์ด์, ์ด๋ฅผ ๋ฐํ์ผ๋ก ์ ๋ ฌ์ ์ํํ๋ค. 1.๋ฐฐ์ด์ ์กด์ฌํ๋ ๊ฐ ๊ฐ์ ๊ฐฏ์๋ฅผ ์ ์ฅํ๋ count ๋ณ์๋ฅผ ์์ฑํ๋ค. ์๋ฅผ๋ค์ด count[1]=4 ๋ผ๋ฉด ๋ฐฐ์ด์๋ 1์ ๊ฐ์ด 4๊ฐ ์๋ค๋ ๊ฒ์ ์๋ฏธํ๋ค. count๋ ๋ฐฐ์ด ์์์ ์ต๋๊ฐ๊น์ง๋ฅผ ์ธ๋ฑ์ค๋ก ์ฌ์ฉํ๋ค. arr = [4, 7, 9, 1, 3, 5, 2, 3, 4] cnt = [0] * (max(arr) + 1) for num in arr: cnt[num] += 1 print(cnt) # [0, 1, 1, 2, 2, 1, 0, 1, 0, 1] 2. count๋ฐฐ์ด์ ๋์ ํฉ์ผ๋ก ๊ณ์ฐํ์ฌ ๊ฐฑ์ ํ์ฌ ์ค๋ค. ๋์ ํฉ์ผ๋ก ๊ฐฑ์ ํ๋ ์ด์ ๋ ๋ฆฌํด ํ ์ ๋ ฌ๋ ๋ฐฐ์ด answer์ ์ ์ ํ ์์น์ ์ฝ์
ํ๊ธฐ ..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
์๊ฐ๋ณต์ก๋ = ์๊ณ ๋ฆฌ์ฆ์ ์์(resource) ์ฌ์ฉ๋์ ๋ถ์ ์์์ด๋ ์คํ์๊ฐ, ๋ฉ๋ชจ๋ฆฌ, ์ ์ฅ์ฅ์น, ํต์ ๋ฑ์ ๋งํ๋ ๊ฒ ์ธ๋ฐ ๊ทธ ์ค์์ ์คํ์๊ฐ์ ๋ํด์ ํํ ๋ฉ๋ชจ๋ฆฌ : ๊ฐ๊ฒฉ๋๋น ๋ฉ๋ชจ๋ฆฌ ์ฉ๋์ด ํฌ๊ฒ ์ฆ๊ฐํ์ฌ ์๋์ ์ธ ์ค์์ฑ์ด ๊ฐ์๋์๋ค. ์คํ์๊ฐ์ ํ๋์จ์ด, ์ด์์ฒด์ , ์ธ์ด, ์ปดํ์ผ๋ฌ ๋ฑ์ ๋ฐ๋ผ์ ๋ฌ๋ผ์ง๊ฒ ๋๋ฏ๋ก ์คํ์๊ฐ์ ์ธก์ ํ๋ ๋์ ์ฐ์ฐ์ ์คํ ํ์๋ฅผ ์ธก์ ํด์ผ ํ๋ค. ์ฐ์ฐ์ ์คํ ํ์ ์
๋ ฅ ๋ฐ์ดํฐ์ ํฌ๊ธฐ(n)์ ๊ดํ ํจ์๋ก ํํํ๊ฒ ๋๋ค. ๋ฐ์ดํฐ์ ํฌ๊ธฐ๊ฐ ๊ฐ๋๋ผ๋ ์ค์ ๋ฐ์ดํฐ์ ๋ฐ๋ผ์ ๋ฌ๋ผ์ง๋ค. (n๊ฐ์ ๋ฐ์ดํฐ์์ ๊ฒ์์ ํ ๋, ์ด์ด ์ข์ผ๋ฉด ๋ฐ๋ก ์ฐพ์ ์๋ ์๊ณ , ์ด์ด ๋์๋ฉด n๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ ๊ฒ์ํด์ ์ฐพ์์ผ ํ ์๋ ์๋ค.) ์ต์
์ ๊ฒฝ์ฐ ์๊ฐ๋ณต์ก๋ ํ๊ท ์๊ฐ๋ณต์ก๋ (ํ๊ท ์๊ฐ๋ณต์ก๋ ๋ถ์์ด..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
๋ฏธ๋ก์ฐพ๊ธฐ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด wall ๊ณผ pathway๋ก ๊ตฌ์ฑ๋ ๋ฏธ๋ก๋ฅผ ํ์ถํ๋ ์ฝ๋๋ฅผ recursion์ผ๋ก ๊ตฌํํ ์ ์๋ค. recursiveํ๊ฒ ์๊ฐ์ ํด์ผํ๋ค. ํ์ฌ ์์น์์ ์ถ๊ตฌ๊น์ง ๊ฐ๋ ๊ฒฝ๋ก๊ฐ ์์ผ๋ ค๋ฉด ํ์ฌ ์์น๊ฐ ์ถ๊ตฌ๊ฑฐ๋ ์ด์ํ ์
๋ค ์ค ํ๋์์ ์ถ๊ตฌ๊น์ง ๊ฐ๋ ๊ฒฝ๋ก๊ฐ ์๊ฑฐ๋ ๊ฐ๋จํ๊ฒ ์๊ฐํด๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํํ ์ ์๋ค. boolean findPath(x,y) if (x,y) is the exit return true; else for each neighbouring cell (x',y') of (x,y) do if (x',y') is a pathway cell if findPath(x',y') return true return false; (x,y)์์ ์ถ๊ตฌ๊น์ง ๊ฒฝ๋ก๊ฐ ์์ผ๋ฉด true, ์์ผ๋ฉด f..
๐ฅ์ฝ๋ฉํ
์คํธ:Algorithm
์ํ์ ์ํํจ์ ๊ณ์ฐ์๋ง ์ ์ฉํ๊ฐ? ํฉํ ๋ฆฌ์ผ, ํผ๋ณด๋์น ์์ด, ์ต๋๊ณต์ฝ์์ ๊ฐ์ ์ํํจ์ ๋ฟ๋ง ์๋๋ผ, ๋ค๋ฅธ ๋ง์ ๋ฌธ์ ๋ค์ recursion์ผ๋ก ํด๊ฒฐํ ์ ์๋ค. ๋ฌธ์์ด ๋ค์ง๊ธฐ def f(s): if len(s)==0: return else: f(s[1:]) print(s[0],end='') s=input() f(s) abcdef fedcba Base Case : ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ 0์ด๋ฉด ์ถ๋ ฅ์ ํ์ง ์๊ณ return ์ฌ๊ท์ ์ผ๋ก ์ดํด๋ฅผ ํด์ผํ๋ค. ์ฒซ ๋ฒ์งธ ๋ฌธ์๋ฅผ ์ ์ธํ ๋ฌธ์์ด์ ๋ค์ง์ด์ ์ถ๋ ฅํ๊ณ , ๊ทธ ๋ค์ ์ ์ธํ ์ฒซ ๋ฒ์งธ ๋ฌธ์๋ฅผ ์ถ๋ ฅํ๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ฌธ์์ด์ด ๋ค์ง์ด์ ์ถ๋ ฅ๋๋ค. 2์ง์๋ก ๋ณํํ์ฌ ์ถ๋ ฅํ๊ธฐ def fun(n): if nend: return False elif lst[begin]==targe..