๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ํ์ด๊ณผ์ โ๏ธanswer ๋ฐฐ์ด ํฌ๊ธฐ = (num_list.length / n) x nํ(row): `(num_list.length / n)`์ด(column): `n`โ๏ธnum_list[i]๋ฅผ ์ฝ์
ํ answer ๋ฐฐ์ด์ ์ธ๋ฑ์คํ(row): `i / n`์ด(column): `i % n` ๋ฌธ์ ์ ์
๋ ฅ ์์์ฒ๋ผ [1, 2, 3, 4, 5, 6, 7, 8], n = 2 ์ผ ๋inum_list[i]i / n (ํ ์ธ๋ฑ์ค)i % n (์ด ์ธ๋ฑ์ค) ๋ฐฐ์น ๊ฒฐ๊ณผ0100answer[0][0] = 11201answer[0][1] = 22310answer[1][0] = 33411answer[1][1] = 44520answer[2][0] = 55621answer[2][1] = 66730answer[..

My Tech Blog (์ฝ๋ฉํ ์คํธ)
์ค๋์ ๋ช
์ธ
" ์ฐ๋ฆฌ๋ ์์ ์ ์ค์ค๋ก ์ ์ํ๋ ์ฌ๋๋ค์ด๋ค. "

๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์ ํ์ด๋ฐฉ๋ฒ1. dp[][] ๋ฐฐ์ด ์ ์ธ 2. ์ฒซ ๋ฒ์งธ ์ค ๊ฐ ์ฑ์ฐ๊ธฐ (dp[0][0] = triangle[0][0])2. ์ผ์ชฝ ์ฒซ๋ฒ์งธ ์ด์ธ dp[i][0] ๊ฐ์ ์ด์ ์ค์ ์ฒซ ๋ฒ์งธ ๊ฐ๋ผ๋ฆฌ ๋ํด์ ์
๋ ฅํ๋ค. (dp[i][0] = dp[i-1][0] + triangle[i][0]) 3. ๊ทธ ์ธ์ ๊ฐ๋ค์ ์์ชฝ๊ณผ ์ผ์ชฝ์์ ์ค๋ ๊ฐ์ ๋น๊ตํ์ฌ ์ต๋๊ฐ์ ๋ํ๊ธฐ(dp[i][j] = Math.max(dp[i-1][j-1], dp[i-1][j]) + triangle[i][j]) ์ฆ, ์์ชฝ์์ ์ค๊ฑฐ๋ ์ผ์ชฝ ์์์ ์จ ๊ฐ ์ค ๋ ํฐ ๊ฐ์ ํ์ฌ triangle[i][j] ๊ฐ์ ๋ํ๋ค. dp[][] ๋ฐฐ์ด ์ ์ธ๋์ฒ๋ผ ์ํ์ ์ด๋ ค์ํ๋ ์ฌ๋๋ค์ ์ํด ๋ฐฐ์ด์ ๋์ผ๋ก ๋ณด๊ธฐ ์ฝ๊ฒ ์๊ฐํ ํด ๋ณด์๋ค.์ฝ..

๐ 1. ๋ฌธ์ ์ค๋ช
๊ณ์๋๋ ํญ์ฐ๋ก ์ผ๋ถ ์ง์ญ์ด ๋ฌผ์ ์ ๊ฒผ์ต๋๋ค. ๋ฌผ์ ์ ๊ธฐ์ง ์์ ์ง์ญ์ ํตํด ํ๊ต๋ฅผ ๊ฐ๋ ค๊ณ ํฉ๋๋ค. ์ง์์ ํ๊ต๊น์ง ๊ฐ๋ ๊ธธ์ m x n ํฌ๊ธฐ์ ๊ฒฉ์๋ชจ์์ผ๋ก ๋ํ๋ผ ์ ์์ต๋๋ค. ์๋ ๊ทธ๋ฆผ์ m = 4, n = 3 ์ธ ๊ฒฝ์ฐ์
๋๋ค. ๊ฐ์ฅ ์ผ์ชฝ ์, ์ฆ ์ง์ด ์๋ ๊ณณ์ ์ขํ๋ (1, 1)๋ก ๋ํ๋ด๊ณ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋, ์ฆ ํ๊ต๊ฐ ์๋ ๊ณณ์ ์ขํ๋ (m, n)์ผ๋ก ๋ํ๋
๋๋ค. ๊ฒฉ์์ ํฌ๊ธฐ m, n๊ณผ ๋ฌผ์ด ์ ๊ธด ์ง์ญ์ ์ขํ๋ฅผ ๋ด์ 2์ฐจ์ ๋ฐฐ์ด puddles์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ค๋ฅธ์ชฝ๊ณผ ์๋์ชฝ์ผ๋ก๋ง ์์ง์ฌ ์ง์์ ํ๊ต๊น์ง ๊ฐ ์ ์๋ ์ต๋จ๊ฒฝ๋ก์ ๊ฐ์๋ฅผ 1,000,000,007๋ก ๋๋ ๋๋จธ์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ์ฌํญ๊ฒฉ์์ ํฌ๊ธฐ m, n์ 1 ์ด์ ..

๐ 1. ๊ฐ์๋ฐ์ ๋ณด โญ ์ ๋ต์ฝ๋import java.util.*;class Solution { public String solution(String rsp) { char[] arr = rsp.toCharArray(); StringBuilder sb = new StringBuilder(); for (char c : arr) { if (c=='2') { sb.append('0'); } else if (c=='0') { sb.append('5'); } else if (c=='5') { sb.append('2'); ..
๐ 1. ๋ฌธ์ ์ค๋ช
์
์ถ๋ ฅ ์letterresult".... . .-.. .-.. ---""hello" ".--. -.-- - .... --- -.""python" ๐ก 2. ์ ๊ทผ๋ฐฉ์์ฃผ์ด์ง ๋ชจ์ค๋ถํธ๋ฅผ morse.put() ์ผ๋ก ํ ์ค์ฉ ํด์๋งต์ ์ถ๊ฐ ํด์ผ ํ๋ค๋ ๋ถ๋ถ์ด ๊ท์ฐฎ์ ๋ฌธ์ ์ด๋ค. 1. HashMap์ ์ด์ฉํด ๋ชจ์ค๋ถํธ์ ์ํ๋ฒณ์ ํค,๊ฐ ์์ผ๋ก ์ ์ฅํ๊ธฐ2. split() ๋ฉ์๋๋ก ๋ฌธ์์ด์ ๊ณต๋ฐฑ ๊ธฐ์ค์ผ๋ก ๋๋๊ธฐ3. StringBuilder๋ก ๋ฌธ์์ด์ ์กฐํฉํด์ ๋ฐํโญ 3. ์ ๋ต์ฝ๋import java.util.*; class Solution { public String solution(String letter) { Map morse = new HashMap(); // ..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์๋์ ๊ฑฐ์ค๋ฆ๋ ๋ฌธ์ ์ ์ ์ฌํ๋ค.๊ฐ๋ฏธ ๊ตฐ๋จ ๋ฌธ์ ๋ ์ฃผ์ด์ง ๊ฐ์ ๋ํด ๊ฐ ๊ฐ๋ฏธ ์ข
๋ฅ๋ณ๋ก ๋ชซ์ ์นด์ดํธํ๊ณ ๋๋จธ์ง๋ก ๋ค๋ฅธ ๊ฐ๋ฏธ ์ข
๋ฅ๋ฅผ ์ฑ์ด๋ค.๋๋์ด ๋จ์ด์ง๋ ๋ชซ์ ๋จผ์ ๊ตฌํ๊ณ ๋๋จธ์ง๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ์์ด๋ค. ํด๊ฒฐ ๋ฐฉ๋ฒ ์ฅ๊ตฐ๊ฐ๋ฏธ๋ 5์ ๊ณต๊ฒฉ๋ ฅ์, ๋ณ์ ๊ฐ๋ฏธ๋ 3์ ๊ณต๊ฒฉ๋ ฅ์ ์ผ๊ฐ๋ฏธ๋ 1์ ๊ณต๊ฒฉ๋ ฅ์ ๊ฐ์ง๊ณ ์๋ค.1. ๋จผ์ hp๋ฅผ ์ฅ๊ตฐ๊ฐ๋ฏธ(5 ๊ณต๊ฒฉ๋ ฅ)๋ก ์ต๋ํ ๋๋์ด ๋ชซ ๊ตฌํ๊ธฐ2. ๋จ์ ์ฒด๋ ฅ์ ๋ณ์ ๊ฐ๋ฏธ(3 ๊ณต๊ฒฉ๋ ฅ)๋ก ์ต๋ํ ๋๋์ด ๋ชซ ๊ตฌํ๊ธฐ3. ๋๋จธ์ง ์ฒด๋ ฅ์ ์ผ๊ฐ๋ฏธ(1 ๊ณต๊ฒฉ๋ ฅ)๋ก ์ฒ๋ฆฌํ๊ธฐ๋ชจ๋ ๊ฐ๋ฏธ์ ๋ชซ์ ๋ํ๋ฉด ์ต์ ๊ฐ๋ฏธ์ ์๊ฐ ๋๋ค. โญ 3. ์ ๋ต์ฝ๋class Solution { public int solution(int hp) { int answer = 0; ..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์๋งค์ฐ ์ฌ์ด ๋ฌธ์ ์ด๋ค. ์์์์ n์ด 20 ์ผ๋ ๊ณฑ์ด 20์ธ ์์์์ (1, 20), (2, 10), (4, 5), (5, 4), (10, 2), (20, 1) ์ด๋ฏ๋ก 6์ returnํ๋ค. ์ฆ, n์ ์ฝ์์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค. 1๋ถํฐ n๊น์ง for๋ฌธ์ ๋๋ ค n%i๊ฐ 0์ผ๋ก ๋จ์ด์ง๋ฉด ์นด์ดํธํด์ answer์ ๋์ ํ๋ค. โญ 3. ์ ๋ต์ฝ๋class Solution { public int solution(int n) { int answer = 0; for (int i = 1; i
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์1. emergency ๋ฐฐ์ด์ ๋ณต์ฌํ์ฌ sorted ๋ฐฐ์ด์ ์์ฑํ๊ณ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋ค. ์ด ๋ ๋ณต์ฌ๋ฅผ ํ๋ ์ด์ ๋ ๊ธฐ์กด ๋ฐฐ์ด์ ์์๋ฅผ ์ ์งํ๋ฉด์ ์์๋ฅผ ๋งค๊ฒจ์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.2. ํด์๋งต์ ์ฌ์ฉํ์ฌ ์๊ธ๋์ ์์๋ฅผ ๋งคํํ๋ค.HashMap rankMap์ ์ ์ธํ์ฌ ์๊ธ๋ ๊ฐ โ ์์๋ก ์ ์ฅํ๋ค. sorted๋ ์ค๋ฆ์ฐจ์์ด๋ฏ๋ก, ํฐ ๊ฐ์ผ์๋ก ๋์ ์์๊ฐ ๋๋ค. `rankMap.put(sorted[i], sorted.length - i);` โ ์๊ธ๋๊ฐ ํด์๋ก ๋์ ์์(ํฐ ๊ฐ)๋ก ๋งคํ์ด ๋๋ค. 3. result ๋ฐฐ์ด์ ์์ฑํ์ฌ ์๊ธ๋ ์์๋ฅผ ์ ์ฅํ๋ค. ์ด ๋ ๊ธฐ์กด emergency ๋ฐฐ์ด์ ์ํํ๋ฉด์ rankMap์์ rankMap.get(emergency[i]) ์ผ๋ก ํด๋น ์..