๐ 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. ๋ฌธ์ ์ค๋ช
๐ก 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. ์ ๊ทผ๋ฐฉ์`String.valueOf()` Java์์ ๋ค์ํ ํ์
์ ๊ฐ์ ๋ฌธ์์ด๋ก ๋ณํํ๋ ๋ฉ์๋`๋ฌธ์์ด ๋ณ์๋ช
.toCharArray()`: ๋ฌธ์์ด์ ํ๊ธ์์ฉ ๋ฐฐ์ด๋ก ๋ง๋๋ ๋ฉ์๋`(char)('a' + (digit - '0'))`: ์ซ์๋ฅผ ๋ฌธ์๋ก ๋ณํํ์ฌ ์ํ๋ฒณ์ ์ป๋ ์ฝ๋ (์๋์์ ์์ธํ ์ค๋ช
)โญ 3. ์ ๋ต์ฝ๋class Solution { public String solution(int age) { StringBuilder result = new StringBuilder(); String ageStr = String.valueOf(age); for (char digit : ageStr.toCharArray()) { ..
๐ 1. ํผ์ ๋๋ ๋จน๊ธฐ(1) ์ฒซ ๋ฒ์งธ ์๋ ํ๋ฆผ (์ ํ๋ 80%)ํ
์คํธ ์ผ์ด์ค 5,6์์ ํ๋ฆผ ์ด์ ๋ 7์ ๋ฐฐ์ ์ผ ๋ ๋ถํ์ํ๊ฒ ํ ํ์ด ์ถ๊ฐ๋จn์ 7๋ก ๋๋ ๋๋จธ์ง๊ฐ 0์ผ ๋ (7์ ๋ฐฐ์ ์ผ ๋๋) n/7๋ง ๋ฆฌํดํ๋๋ก ์ฝ๋ ์ถ๊ฐํด ์ฃผ์๋ค. โญ์ ๋ต์ฝ๋class Solution { public int solution(int n) { if (n โญ์ต์ ์ฝ๋ n / 7.0์ ํ๋ฉด ์์์ ์ด ๋์ฌ ๋ ์ฌ๋ฆผํด์ผ ํ์ง๋ง, ์ ์ ์ฐ์ฐ์ ํ์ฉํด ๊ณ์ฐ์ ๋จ์ํํ ์ ์๋ค. (n + 6) / 7์ n์ 7๋ก ๋๋ด์ ๋ ๋จ์ ์กฐ๊ฐ์ด ์์ผ๋ฉด ์๋์ผ๋ก ์ฌ๋ฆผ ํจ๊ณผ๋ฅผ ์ฃผ๊ธฐ ๋๋ฌธ์ด๋ค.์ด๋ ๊ฒ ํ๋ฉด Math.ceil(n / 7.0) ๊ฐ์ ์ค์ ์ฐ์ฐ ์์ด, ์ ์ ์ฐ์ฐ์ผ๋ก ๊ฐ๋จํ๊ฒ ํด๊ฒฐํ ์ ์๋ค.import jav..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์์ด ๋ฌธ์ ๋ ํด์๋งต์ ์ฌ์ฉํด์ ํ์๋ค.๋ฐฐ์ด์ ์ํํ๋ฉด์ ๊ฐ ์ซ์์ ๋ฑ์ฅ ํ์๋ฅผ ์นด์ดํธํด์ ํด์๋งต์ ์ ์ฅํ๋ค. (key: ๋ฑ์ฅํ ์ซ์, value: ์นด์ดํธ)ํด์๋งต์ ์ํํ๋ฉด์ ์ต๋น๊ฐ์ ์ฐพ๋๋ค. โ maxCount๋ณด๋ค ๋ ํฐ count(value ๊ฐ)์ด ์กด์ฌํ๋ฉด maxCount๋ฅผ count๋ก ์
๋ฐ์ดํธ ํ๋ค.์ด ๊ณผ์ ์์ ๋ฑ์ฅ ํ์๊ฐ ๋์ผํ ๊ฐ์ด ์๋์ง๋ ํ์ํ๋ค. ๋ง์ฝ ์ค๋ณต๋ ์ต๋น๊ฐ์ด ์์ผ๋ฉด isDuplicate๋ฅผ true๋ก ๋ฐ๊พผ๋ค. ์ต์ข
์ ์ผ๋ก ์ผํญ์ฐ์ฐ์๋ฅผ ์จ์ ์ค๋ณต์ด ์์ผ๋ฉด -1์ ๋ฐํ, ๊ทธ๋ ์ง ์์ผ๋ฉด ์ต๋น๊ฐ์ ๋ฐํํ๋ค.โญ 3. ์ ๋ต์ฝ๋import java.util.HashMap;import java.util.Map;class Solution { public int ..