๐์ปดํจํฐ๊ณผํ:CS
1๊ณ์ธต (Physical Layer, ๋ฌผ๋ฆฌ๊ณ์ธต)์ง์ ์ ์ ์ผ๋ก ์ ๊ธฐ์ ์ ํธ๊ฐ ์ ๋ฌ๋๋ ๊ณ์ธต๋ ๋์ ์ปดํจํฐ๊ฐ ํต์ ํ๋ ค๋ฉด?๋ชจ๋ ํ์ผ๊ณผ ํ๋ก๊ทธ๋จ์ 0๊ณผ 1์ ๋์ด์ด๋ค.๊ฒฐ๊ตญ 0๊ณผ 1๋ง ์ฃผ๊ณ ๋ง์ ์ ์์ผ๋ฉด ๋๋ค.0๊ณผ 1์ ๋์ด์ ์๋ ๋ก๊ทธ ์ ํธ๋ก ๋ฐ๊พธ์ด ์ ์ ์ผ๋ก ํ๋ ค ๋ณด๋ด๊ณ (encoding), ์๋ ๋ก๊ทธ ์ ํธ๊ฐ ๋ค์ด์ค๋ฉด 0๊ณผ 1์ ๋์ด๋ก ํด์ํ์ฌ(decoding) ๋ฌผ๋ฆฌ์ ์ผ๋ก ์ฐ๊ฒฐ๋ ๋ ๋์ ์ปดํจํฐ๊ฐ 0๊ณผ 1์ ๋์ด์ ์ฃผ๊ณ ๋ฐ์ ์ ์๊ฒ ํด์ฃผ๋ ๋ชจ๋(module)1๊ณ์ธต ๋ชจ๋์ ํ๋์จ์ด์ ์ผ๋ก ๊ตฌํ๋์ด ์์2๊ณ์ธต (DataLink Layer, ๋ฐ์ดํฐ๋งํฌ๊ณ์ธต)๋คํธ์ํฌ ๊ธฐ๊ธฐ๋ค ๊ฐ ์ด๋ป๊ฒ ํต์ ํ๋์ง ๋ง์ถฐ์ฃผ๋ ๊ณ์ธต1๊ณ์ธต์ ๊ธฐ์ ๋ง์ผ๋ก๋ ์ฌ๋ฌ๋์ ์ปดํจํฐ๊ฐ ํต์ ํ์ง ๋ชปํจ์ค์์น, ๋ผ์ฐํฐ ๋ฅผ ํตํด์ ์ฌ๋ฌ๋์ ์ปดํจํฐ๊ฐ ํต์ ์ ํ ์ ์์๊ฐ์ ..
๐์ฝ๋ฉํ
์คํธ:CodingTest
https://www.codetree.ai/training-field/frequent-problems/problems/royal-knight-duel/description?page=1&pageSize=20 ๊ตฌํ + bfsํ์ด๊ณผ์ 0. ๋ชจ๋ํ๋ ํจ์๋ฅผ ๋ค ํธ์ถํ๋ solveํจ์.static void solve(int n,int d) { if(knights[n].isOut) return; // 1. ํด๋น ๋ฐฉํฅ์ผ๋ก ์ด๋์ด ๊ฐ๋ฅํ์ง ํ์ธํ๊ธฐ if(!movable(n,d)) return; // 2. ์ด๋์ํค๊ธฐ moved = new boolean[N+1]; move(n, d); moved[n] = false; // ๋ช
๋ น๋ฐ์ n๋ฒ ๊ธฐ์ฌ๋ ์์ง์์์ ์ ์ธ // 3. ๋ฐ๋ฏธ์ง ๊ณ์ฐํ๊ธฐ (๋ช
๋ น์ ๋ฐ์..
๐์ฝ๋ฉํ
์คํธ:CodingTest
https://www.codetree.ai/training-field/frequent-problems/problems/rudolph-rebellion/description?page=1&pageSize=20 ์ฝ๋ํธ๋ฆฌ | ์ฝ๋ฉํ
์คํธ ์ค๋น๋ฅผ ์ํ ์๊ณ ๋ฆฌ์ฆ ์ ์ ๊ตญ๊ฐ๋ํ๊ฐ ๋ง๋ ์ฝ๋ฉ ๊ณต๋ถ์ ๊ฐ์ด๋๋ถ ์ฝ๋ฉ ์์ด๋ณด๋ถํฐ ๊ฟ์ ์ง์ฅ ์ฝํ
ํฉ๊ฒฉ๊น์ง, ๊ตญ๊ฐ๋ํ๊ฐ ์์ ํ ์ปค๋ฆฌํ๋ผ์ผ๋ก ์ค๋นํด๋ณด์ธ์. www.codetree.ai ํ์ด๊ณผ์ ํจ์๋ณ๋ก ๋ชจ๋ํ๋ฅผ ์ ์์ผ์ผํ์ผ๋ฉฐ, ๊ตฌํ๊ณผ์ ์ด ๋ณต์กํ๋ค ๋ณด๋ ์ฒ์ ์์ํ ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ ์ ํด์ ์ฌ์ฉํด์ผ ํ์ต๋๋ค. ์ฌ์ฉํ ํด๋์ค์ ๋ณ์ ์ ์ฒด์ ์ธ ์ฐํ์ ๋ฃจ๋ํ์ ์์น๋ 2์ฐจ์ ๋ฐฐ์ด(int[][] map)์ ์ ์ํ์ผ๋ก ์ ์ฅํ๊ณ , ์ธ๋ถ์ ๋ณด๋ฅผ ์ ์ฅํ๋ ๋ณ์๋ฅผ ๋ง๋ค์ด์ 2์ฐจ์ ๋ฐฐ์ด(int[][] ..
๐์ฝ๋ฉํ
์คํธ:CodingTest
https://www.acmicpc.net/problem/17822 ํ์ด๊ณผ์ 1. ์ํ์ ํ์ ์ํค๋ ํจ์๋ฅผ ๊ตฌํํด์ผ ํฉ๋๋ค. ArrayList ํน์ LinkedList๋ฅผ ์ฌ์ฉํด์ ๊ตฌํํ ์ ์์ต๋๋ค. add, insert ,remove ํจ์๋ฅผ ํ์ฉํ์ฌ ์ํ์ ํ์ ์ ๊ตฌํํ ์ ์์ต๋๋ค. 2. ์ํ์์ ์ธ์ ํ ์ซ์๋ค ๋ผ๋ฆฌ ์ผ์น์ฌ๋ถ๋ฅผ ํ์ธํด์ผ ํฉ๋๋ค. dfs๋ฅผ ํตํด ์ธ์ ์ฌ๋ถ๋ฅผ ๊ตฌํํฉ๋๋ค. ์ธ์ ํ๊ฒ ๋๋ฉด -1๋ก ์์๋ฅผ ๋ณ๊ฒฝํ์ฌ ์ฒดํฌํ์ต๋๋ค. ์ด๋ ๊ฐ์ ์ํ ๋ด์์์ ์ํ(?)๋ฅผ ๊ตฌํํด์ค์ผ ํฉ๋๋ค. ์๋ฅผ๋ค์ด [2,3,4,2] ์ ๊ฐ์ ์ํ์ธ ๊ฒฝ์ฐ ์ ์ผ ์ ์์ 2์ ์ ์ผ ๋ค ์์ 2๋ ์ธ์ ํด ์์ต๋๋ค. ๋ฐ๋ผ์ dfs์ํ ์ค ์ธ๋ฑ์ค๊ฐ -1์ด ๋๋ฉด 3์ผ๋ก, 4๊ฐ ๋๋ฉด 0์ผ๋ก ๋ณด์ ์ ํด์ค์ผ ํฉ๋๋ค. static bo..
๐๋ฐฑ์๋ : BackEnd
์์ ๋ฑ
ํน ์๋น์ค๋ฅผ ์ฃผ์ ๋ก ํ ํ๋ก์ ํธ๋ฅผ ์งํํ์ง๋ง, ๋์์ฑ์ ๋ํ ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์ง ๋ชป ํ ์ ์ ๋ณด์ํ๊ธฐ ์ํด ๊ณต๋ถํ ๋ด์ฉ์ ์ ๋ฆฌํ ๊ธ์
๋๋ค. ๋์์ฑ ์ด์ ํด๊ฒฐ๋ฐฉ๋ฒ synchronized ํ๋์ ํ๋ก์ธ์ค์์๋ง ๋์. ์ฆ ์๋ฒ๊ฐ ์ฌ๋ฌ๋์ด๊ณ ์๋ก ๋ค๋ฅธ ์๋ฒ์์ ๋์์ ์ ๊ทผํ๋ค๋ฉด synchronized ๋ ๊ธฐ๋ฅ์ ๋ฐํํ ์ ์๋ค. @Transactional ์ ์ฌ์ฉํ๋ฉด, ํธ๋์ญ์
์ด ์ปค๋ฐํ ๋ ์ ๊น์ ํ
์ ๋ค๋ฅธ ์ค๋ ๋๊ฐ ์ ๊ทผํ ์ ์์ด์ ๋์์ฑ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค. Lock (DB์์ ์ฌ๊ณตํ๋ ๋ฝ๊ธฐ๋ฅ์ ์ฌ์ฉ) Pessimistic Lock (๋น๊ด์ ๋ฝ) row๋ table ๋จ์๋ก ๋ฝ์ ๊ฒ ์์ ์์ฒญ์ ๋ฐ๋ฅธ ๋์์ฑ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ๊ฒ์ด๋ผ๊ณ ์์ํ๊ณ ๋ฝ์ ๊ฑธ์ด๋ฒ๋ฆฌ๋ ๋น๊ด์ ๋ฝ ๊ณต์ ๋ฝ(Shared Lock)๊ณผ ๋ฒ ํ๋ฝ..
๐์ฝ๋ฉํ
์คํธ:CodingTest
https://www.acmicpc.net/problem/17142 ํ์ด๊ณผ์ 0. ์
๋ ฅ์ ๋ฐ์ ๋ ์ฑ์์ผ ํ ๋น์นธ์ ๊ฐฏ์๋ฅผ ์ ์ฅํฉ๋๋ค. 1. ๋ฐฑํธ๋ํน์ ํ์ฉํด์ ๋ฐ์ด๋ฌ์ค๋ค์ ์กฐํฉ์ ์ ํํฉ๋๋ค. 2. ์ ํ๋ ๋ฐ์ด๋ฌ์ค๋ค์ ๋ํด bfs๋ฅผ ์ํํ์ฌ ํผํธ๋ฆฝ๋๋ค. ๋ฐ์ด๋ฌ์ค๋ฅผ ํผํธ๋ฆด ๋, ๋น์นธ๊ณผ ๋ฐ์ด๋ฌ์ค๊ฐ ์๋ ์นธ์ ๋ํด ๊ตฌ๋ถํด์ ์ฝ๋๋ฅผ ์์ฑํด์ผ ํฉ๋๋ค. ๋น ์นธ์ ๊ฒฝ์ฐ 0๋ฒ ํ์ด๊ณผ์ ์์ ์ ์ฅํ ๋ชฉํ์ ๋น๊ตํ๊ธฐ ์ํด cnt๊ฐ์ ์ฆ๊ฐ์์ผ ์ค๋๋ค. ๋ฐ์ด๋ฌ์ค์ ๊ฒฝ์ฐ cnt ๊ฐ์ ์ฆ๊ฐ์ํค์ง ์๊ณ ๋ฐฉ๋ฌธ์ฒ๋ฆฌ์ bfsํ์ ๋ฃ๋ ๋์๋ง ์ํํฉ๋๋ค. ์ฒ์์๋ swea์ ์ง๋ขฐ๋ฌธ์ ์ ํท๊ฐ๋ ค์ ๋ฐ์ด๋ฌ์ค๋ฅผ ๋ง๋๋ฉด ๊ณ์ ํผ์ง๋๋ก ๊ตฌํํด์ ๊ณ์ ํ๋ ธ์ต๋๋ค ใ
ใ
3. ๋น ์นธ์ ๋ค ์ฑ์ ์ผ๋ฉด ์ด๋ํ ์๊ฐ์ return ํฉ๋๋ค. bfs์์ ์๊ฐ์ ๊ณ์..
๐์ฝ๋ฉํ
์คํธ:CodingTest
N = ํ ๊ธธ์ด M = ์ด ๊ธธ์ด int[][] origin = { {1,2,3}, {4,5,6}, {7,8,9} }; // ์๋ณธ ๋ฐฐ์ด int[][] result; // ํ์ ๋ฐฐ์ด ์๊ณ ๋ฐฉํฅ 90๋ ํ์ : (i,j) = (N-1-j, i) ํน์ (j, N-1-i) = (i,j) for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { rotate_arr[i][j] = arr[N - 1 - j][i]; } } ๋ฐ ์๊ณ ๋ฐฉํฅ 90๋ ํ์ : (i,j) = (j, N-1-i) ํน์ (N-1-j, i) = (i, j) for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { rotate_arr[i][j] = ar..
๐์ฝ๋ฉํ
์คํธ:CodingTest
๊ตฌํ ์ฝ๋๋ง ๊ฐ๋ตํ๊ฒ ์์ฑ..(์ธ์ฐ๊ธฐ ์ํด์ ๐) ๋ฆฌ์คํธ์ ์์ฐจ์ ์ผ๋ก ์ ๊ทผํด์ผ ํ ๋ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํฌ ํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ ๊ธฐ๋ณธ ํฌ๋ฉงint N = 5; // ๋ฐ์ดํฐ์ ๊ฐ์ Nint M = 5; // ์ฐพ๊ณ ์ ํ๋ ๋ถ๋ถ ํฉ Mint[] data = {1,2,3,2,5};int cnt = 0;int interval_sum = 0;int end = 0;for(int start=0;start