๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ํ์ด๊ณผ์ ๊ตฌํ๊ณ ์ ํ๋ ๊ฒ์ ์ง์ก๋ฉด์ฒด ์์ ์ ์ก๋ฉด์ฒด ์ฃผ์ฌ์๊ฐ ๋ช ๊ฐ ๋ค์ด๊ฐ๋์ง์ด๋ค.์ง์ก๋ฉด์ฒด์ ๋ถํผ / ์ ์ก๋ฉด์ฒด์ ๋ถํผ๋ฅผ ๊ณ์ฐํด์ ๋ฐํํ๋ฉด ๋๋ค. ์ง์ก๋ฉด์ฒด ๋ถํผ๋ ๋ฐฐ์ด box๋ฅผ 0๋ฒ ์ธ๋ฑ์ค๋ถํฐ ์ํํ๋ฉด์ ๊ฐ๋ก*์ธ๋ก*๋์ด๋ฅผ ํด์ ๊ตฌํ๋ค.// box ๋ฐฐ์ด์ ๋ถํผ ๊ณ์ฐint volume = box[0] * box[1] * box[2]; ์ ์ก๋ฉด์ฒด์ ๋ถํผ๋ n์ ์ธ์ ๊ณฑ์ธ๋ฐ, ๊ทธ๋ฅ n*n*n; ์ด๋ผ๊ณ ์จ๋ ๋์ง๋ง๋ ์ซ์๋ฅผ ์ด์ฉํด์ ๊ฑฐ๋ญ์ ๊ณฑ ๊ตฌํ๋ ์ํ ๋ฉ์๋๋ฅผ ์ด์ฉํด์ ์ฝ๋๋ฅผ ์์ฑํด ์ฃผ์๋ค. `Math.pow(์ฒซ๋ฒ์งธ์ซ์, ๋๋ฒ์งธ์ซ์)`์ฒซ ๋ฒ์งธ ์ซ์๋ฅผ ๋ ๋ฒ์งธ ์ซ์๋งํผ ๊ฑฐ๋ญ์ ๊ณฑํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ๋์ Math.pow๋ doubleํ์์ผ๋ก ๊ฐ์ ๋ฆฌํดํ๊ธฐ ๋๋ฌธ์ int๋ก ์บ์คํ
ํด์ผํ๋ค. ๐จโ๐ป ..

My Tech Blog (๋ฌธ์ )
์ค๋์ ๋ช
์ธ
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ํ์ด๊ณผ์ ๋ ๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋์ด์ ํด๊ฒฐํ๊ธฐdirection ์ด right์ธ ๊ฒฝ์ฐ์ left์ธ ๊ฒฝ์ฐ๋ก ๊ตฌ๋ถํ๋ค."right" ๋ฐฉํฅ์ผ๋ก ํ์ : ๋ฐฐ์ด์ ๋ง์ง๋ง ์์๋ฅผ ๋งจ ์์ ๋ฃ๊ธฐ + ๋๋จธ์ง ์์๋ค์ ํ ์นธ์ฉ ๋ค๋ก ์ด๋"left" ๋ฐฉํฅ์ผ๋ก ํ์ : ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ๋งจ ๋ค๋ก ๋ณด๋ด๊ธฐ + ๋๋จธ์ง ์์๋ค์ ํ ์นธ์ฉ ์์ชฝ์ผ๋ก ์ด๋๐จโ๐ป 3. ์ ๋ต์ฝ๋๋ด๊ฐ ํผ ์ฝ๋import java.util.*;class Solution { public int[] solution(int[] numbers, String direction) { int[] answer = new int[numbers.length]; if (direction.equals("right")) {..
๐ 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[..
๐ 1. ๋ฌธ์ ์ค๋ช
์
์ถ๋ ฅ ์ballsshareresult3235310 ์
์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1์๋ก ๋ค๋ฅธ ๊ตฌ์ฌ 3๊ฐ ์ค 2๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ 3์
๋๋ค. ์
์ถ๋ ฅ ์ #2์๋ก ๋ค๋ฅธ ๊ตฌ์ฌ 5๊ฐ ์ค 3๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ 10์
๋๋ค.๐ก 2. ์ ๊ทผ๋ฐฉ์์ด ๋ฌธ์ ๋ ์กฐํฉ(combination) ๋ฌธ์ ์ด๋ค. ์กฐํฉ์ ๋ฐฐ์ด ์ง ์ค๋๋์ ๊ฒ์ํ๋ฉด์ ํ์๋ค. ์ฃผ์ด์ง balls๊ฐ์ ๊ตฌ์ฌ ์ค์์ share๊ฐ์ ๊ตฌ์ฌ์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค.์กฐํฉ์ ๊ตฌํ๋ ๊ณต์์ด ๋ฌธ์ ํํธ๋ก ์ฃผ์ด์ ธ ์๋ค.n์ ์ ์ฒด ๊ฐ์ (balls)m๋ ๊ณ ๋ฅผ ๊ฐ์ (share)์ด๊ฒ์ ๋ฌธ์ ์์ ์ฃผ์ด์ง ๋งค๊ฐ๋ณ์๋ก ๋ณํํ๋ฉด ์๋์ ๊ฐ๋ค. ํฉํ ๋ฆฌ์ผ ํจ์๋ฅผ ๋ง๋ค์ด์ ๊ณต์์ ์ฝ๋๋ก ๊ตฌํํ๋ฉด ๋๋ค. ์กฐํฉ ๊ณ์ฐ์ ํ ๋ ํฉํ ๋ฆฌ์ผ ๊ฐ์ด ์ปค์ง๋ฉด ๋งค..

๐ 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. ๋ฌธ์ ์ค๋ช
์
์ถ๋ ฅ ์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; ..