๐ 1. ๋ฌธ์ ์ค๋ช
์
์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #112๋ฅผ ์์ธ์๋ถํดํ๋ฉด 2 * 2 * 3 ์
๋๋ค. ๋ฐ๋ผ์ [2, 3]์ returnํฉ๋๋ค.์
์ถ๋ ฅ ์ #217์ ์์์
๋๋ค. ๋ฐ๋ผ์ [17]์ return ํด์ผ ํฉ๋๋ค.์
์ถ๋ ฅ ์ #3420์ ์์ธ์๋ถํดํ๋ฉด 2 * 2 * 3 * 5 * 7 ์
๋๋ค. ๋ฐ๋ผ์ [2, 3, 5, 7]์ returnํฉ๋๋ค. ๐ก 2. ํ์ด๊ณผ์ ์ค๋ณต์ ์ ๊ฑฐํ๋ฉด์ ์์๋ฅผ ์ ์งํ๋ ค๊ณ LinkedHashSet์ ์ฌ์ฉํด์ ํ์๋ค.1. for๋ฌธ์ ๋ฒ์๋ `i * i 2. while (n % i == 0)๋ก ์ค๋ณต๋๋ ์์ธ์๋ฅผ ์ฒ๋ฆฌํ๊ธฐ3. ๋ง์ง๋ง์ ๋จ์ ์๊ฐ n > 1์ธ์ง ํ์ธํด์ ์์๋ฅผ ๊ฒฐ๊ณผ๊ฐ์ ์ถ๊ฐํ๊ธฐ ์์ธ์๋ถํด ๊ณผ์ ์์ ๊ฐ์ ์์๊ฐ ์ฌ๋ฌ ๋ฒ ๋์ฌ ์ ์๋ค. ์๋ฅผ ๋ค์ด, 12 = 2 ร 2 ร ..

My Tech Blog (์ฝ๋)
์ค๋์ ๋ช
์ธ
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ํ์ด๊ณผ์ ๊ทธ๋ฅ my_string ์ char[] ๋ฐฐ์ด๋ก ๋ฐ๊พธ๊ณ ์ซ์์ธ ๊ฒ๋ง answer์ ๋์ ํด์ ๋ํ๋ฉด ๋๊ฒ ์ง ์๊ฐํ๋ค.class Solution { public int solution(String my_string) { int answer = 0; for (char c : my_string.toCharArray()) { if (Character.isDigit(c)) answer += c; } return answer; }} ์ ์ถํ ์คํ๊ฒฐ๊ณผ๋ ๊ธฐ๋๊ฐ ์ฐจ์ด๊ฐ ๋ง์ด ๋๋ ๊ฑธ๋ก ๋ด์ ์์คํค ์ฝ๋ ๊ฐ์ด ๋ํด์ง ๊ฑฐ ๊ฐ๋ค. ๐จโ๐ป 3. ์ ๋ต์ฝ๋class Solution { public int so..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ํ์ด๊ณผ์ ์ฒ์์ ์ ๊ทผํ ๋ฐฉ์1. my_string์ toCharArray()๋ก char ํ์
์ ๋ฐฐ์ด๋ก ๋ณํ2. for ๋ฌธ์ผ๋ก ๋ฐฐ์ด ์์๋ฅผ ์ํํ๋ฉด์ `Character.isDigit(c)` ๋ฉ์๋๋ก ์์๊ฐ ์ซ์์ด๋ฉด count++3. 2์์ ๋์จ count ํฌ๊ธฐ๋งํผ์ int ๋ฐฐ์ด์ ์ ์ธํ๋ค. 4. for each๋ฌธ์ผ๋ก ๋ค์ ํ ๋ฒ ๋ฐฐ์ด์ ์ํํ๋ฉด์ `Integer.parseInt(String.valueOf(c));` ๋ก ์ซ์๋ง int ๋ฐฐ์ด์ ์ถ๊ฐ5. ์ค๋ฆ์ฐจ์ ์ ๋ ฌ โญ`Character.isDigit()`๋ ์ฃผ์ด์ง ๋ฌธ์๊ฐ ์ซ์(0~9)์ธ์ง ํ์ธํ๋ ์๋ฐ ๋ฉ์๋ํน์ ๋ฌธ์๊ฐ ์ซ์์ธ์ง ์๋์ง๋ฅผ ํ๋จํ์ฌ, ์ซ์์ด๋ฉด true๋ฅผ ๋ฐํํ๊ณ , ์ซ์๊ฐ ์๋๋ฉด false๋ฅผ ๋ฐํํ๋ค.โญ `Inte..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ํ์ด๊ณผ์ ๊ทธ๋ฅ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ๋ฌธ์์ด์ toCharArray() ๋ฉ์๋๋ก ๋ฐฐ์ด๋ก ๋ณํํ ๋ค, ๋ฐฐ์ด์ ์ํํ๋ฉฐ ๋ชจ์์ด ์๋ ๋๋ง StringBuilder์ ์ถ๊ฐํด์ฃผ๋ฉด ๋๋ ๊ฐ๋จํ ๋ฌธ์ ์ด๋ค. ๋จ, ์ฒ์์ ํ๋ฆฐ ์ด์ ๋c != 'a' && c != 'e' && c != 'i' && c != 'o' && c != 'u' ๋ผ๋ ์กฐ๊ฑด์ ์ค์ ํ ๋ and์กฐ๊ฑด ๋์ or์ฐ์ฐ์๋ฅผ ์จ์ ํ๋ ธ๋ค. or ์ฐ์ฐ์๋ ํ๋๋ผ๋ true๋ฉด ์ ์ฒด๊ฐ true๊ฐ ๋๊ธฐ ๋๋ฌธ์ด๋ค. ๊ฒฐ๊ตญ, ์ด๋ค ๋ฌธ์๊ฐ ๋ค์ด์ค๋ ํญ์ true๊ฐ ๋ผ์ ๋ชจ์์ ๊ฑธ๋ฌ๋ด์ง ๋ชปํ๊ณ ๋ชจ๋ ๋ฌธ์๋ฅผ ์ถ๊ฐํ๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.false || false || true || false || false โ ๊ฒฐ๊ณผ: **true**๐จโ๐ป 3. ์ ๋ต์ฝ๋..
๐ 1. ์ต๋๊ฐ ๋ง๋ค๊ธฐ ๐ก ํ์ด๊ณผ์ ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ค์ ๊ฐ์ฅ ๋ ๊ฐ 2๊ฐ๋ฅผ ๊ณฑํ ๊ฐ, ์์๊ฐ 2๊ฐ๋ฅผ ๊ณฑํ ๊ฐ ์ค ๋ ํฐ ๊ฐ์ ๋ฐํ์ด๋ ๊ฒ ํ๋ ์ด์ ๋ ์์๊ฐ ์์์ผ ์๋ ์๊ณ ์์์ผ ์๋ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๐จโ๐ป ์ ๋ต์ฝ๋import java.util.*;class Solution { public int solution(int[] numbers) { Arrays.sort(numbers); int n = numbers.length; // ๊ฐ์ฅ ํฐ ๋ ์์ ๊ณฑ vs ๊ฐ์ฅ ์์ ๋ ์์ ๊ณฑ ์ค ์ต๋๊ฐ ๋ฐํ // ์์์ผ ๊ฐ๋ฅ์ฑ ๋๋ฌธ์ return Math.max(numbers[n - 1] * numbers[n - 2..
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ํ์ด๊ณผ์ j = 1๋ถํฐ j = i๊น์ง j๋ฅผ ์ฆ๊ฐ์ํค๋ฉด์ i % j == 0์ด๋ฉด cnt++ ์ฆ๊ฐ์ฆ, i๋ฅผ 1๋ถํฐ i๊น์ง ๋๋๋ฉด์ ๋๋์ด๋จ์ด์ง๋ ๊ฐ์๋ฅผ ์ธ๋ ๋ฐฉ์cnt >= 3์ด๋ฉด answer++; answer ๋ฐํ ๐จโ๐ป 3. ์ ๋ต์ฝ๋class Solution { public int solution(int n) { int answer = 0; for(int i = 4; i = 3) { answer++; } } return answer; }}
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ํ์ด๊ณผ์ ๊ตฌํ๊ณ ์ ํ๋ ๊ฒ์ ์ง์ก๋ฉด์ฒด ์์ ์ ์ก๋ฉด์ฒด ์ฃผ์ฌ์๊ฐ ๋ช ๊ฐ ๋ค์ด๊ฐ๋์ง์ด๋ค.์ง์ก๋ฉด์ฒด์ ๋ถํผ / ์ ์ก๋ฉด์ฒด์ ๋ถํผ๋ฅผ ๊ณ์ฐํด์ ๋ฐํํ๋ฉด ๋๋ค. ์ง์ก๋ฉด์ฒด ๋ถํผ๋ ๋ฐฐ์ด box๋ฅผ 0๋ฒ ์ธ๋ฑ์ค๋ถํฐ ์ํํ๋ฉด์ ๊ฐ๋ก*์ธ๋ก*๋์ด๋ฅผ ํด์ ๊ตฌํ๋ค.// box ๋ฐฐ์ด์ ๋ถํผ ๊ณ์ฐint volume = box[0] * box[1] * box[2]; ์ ์ก๋ฉด์ฒด์ ๋ถํผ๋ n์ ์ธ์ ๊ณฑ์ธ๋ฐ, ๊ทธ๋ฅ n*n*n; ์ด๋ผ๊ณ ์จ๋ ๋์ง๋ง๋ ์ซ์๋ฅผ ์ด์ฉํด์ ๊ฑฐ๋ญ์ ๊ณฑ ๊ตฌํ๋ ์ํ ๋ฉ์๋๋ฅผ ์ด์ฉํด์ ์ฝ๋๋ฅผ ์์ฑํด ์ฃผ์๋ค. `Math.pow(์ฒซ๋ฒ์งธ์ซ์, ๋๋ฒ์งธ์ซ์)`์ฒซ ๋ฒ์งธ ์ซ์๋ฅผ ๋ ๋ฒ์งธ ์ซ์๋งํผ ๊ฑฐ๋ญ์ ๊ณฑํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ๋์ Math.pow๋ doubleํ์์ผ๋ก ๊ฐ์ ๋ฆฌํดํ๊ธฐ ๋๋ฌธ์ int๋ก ์บ์คํ
ํด์ผํ๋ค. ๐จโ๐ป ..
๐ 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")) {..