๐ 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

My Tech Blog (์ ๋ต)
์ค๋์ ๋ช
์ธ
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์1. emergency ๋ฐฐ์ด์ ๋ณต์ฌํ์ฌ sorted ๋ฐฐ์ด์ ์์ฑํ๊ณ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋ค. ์ด ๋ ๋ณต์ฌ๋ฅผ ํ๋ ์ด์ ๋ ๊ธฐ์กด ๋ฐฐ์ด์ ์์๋ฅผ ์ ์งํ๋ฉด์ ์์๋ฅผ ๋งค๊ฒจ์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.2. ํด์๋งต์ ์ฌ์ฉํ์ฌ ์๊ธ๋์ ์์๋ฅผ ๋งคํํ๋ค.HashMap rankMap์ ์ ์ธํ์ฌ ์๊ธ๋ ๊ฐ โ ์์๋ก ์ ์ฅํ๋ค. sorted๋ ์ค๋ฆ์ฐจ์์ด๋ฏ๋ก, ํฐ ๊ฐ์ผ์๋ก ๋์ ์์๊ฐ ๋๋ค. `rankMap.put(sorted[i], sorted.length - i);` โ ์๊ธ๋๊ฐ ํด์๋ก ๋์ ์์(ํฐ ๊ฐ)๋ก ๋งคํ์ด ๋๋ค. 3. result ๋ฐฐ์ด์ ์์ฑํ์ฌ ์๊ธ๋ ์์๋ฅผ ์ ์ฅํ๋ค. ์ด ๋ ๊ธฐ์กด emergency ๋ฐฐ์ด์ ์ํํ๋ฉด์ rankMap์์ rankMap.get(emergency[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. ๋ฐฐ์ด ๋ค์ง๊ธฐ โ๐
๐ปโโ๏ธ ์ฒซ๋ฒ์งธ ์๋ - ํ๋ฆฐ ์ฝ๋import java.util.*;class Solution { public double solution(int[] numbers) { int total = 0; double answer = 0; for (int i = 0; i ํ๋ฆฐ ์ด์ ๋ total์ int ํ์ผ๋ก ์ ์ธํ๊ธฐ ๋๋ฌธ์ด๋ค. total์ด int, numbers.length๋ int์ด๋ฏ๋ก total / numbers.length๋ ์ ์ ๋๋์
์ด ๋์ด ์์์ ์ดํ๊ฐ ๋ฒ๋ ค์ง๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค. total์ double๋ก ๋ฐ๊ฟ์ฃผ๋๊น ํด๊ฒฐ๋์๋ค. ์ฐธ๊ณ int / double ๋๋..
๐ 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. ์ ๊ทผ๋ฐฉ์ โ๏ธ ๋ฌธ์ ์์ฝ - ์ง๋ขฐ์ฐพ๊ธฐ ๊ฒ์board๋ n x n ํฌ๊ธฐ์ 2D ๋ฐฐ์ด์ด๋ค.์ง๋ขฐ๊ฐ ์๋ ์์น๋ 1, ์๋ ์์น๋ 0์ด๋ค.์ง๋ขฐ(1)๊ฐ ์๋ ๊ณณ์ ๊ธฐ์ค์ผ๋ก ์ฃผ๋ณ 8๋ฐฉํฅ + ์๊ธฐ ์์ ๊น์ง ์ํ์ง๋(1)๋ก ํ์ํด์ผ ํ๋ค.์ต์ข
์ ์ผ๋ก ์์ ํ ์ง์ญ(0)์ ๊ฐ์๋ฅผ ๋ฐํํ๋ ๋ฌธ์ ์ด๋ค.โ๏ธ ํ์ด ๋ฐฉ์๋ฐฐ์ด bd[][] ์์ฑ โ ๊ธฐ์กด board[][]์ ์ ๋ณด๋ฅผ ๊ฐ์ ธ์จ๋ค.board[][] ์์ ์ง๋ขฐ(1)๋ฅผ ์ฐพ์ผ๋ฉด ์ฃผ๋ณ 8๋ฐฉํฅ + ์๊ธฐ ์์ ์ 1๋ก ๋ณ๊ฒฝํ๋ค.์ด ๋ ์ค์ํ ๊ฒ์ ๋ฐฐ์ด ๋ฒ์๋ฅผ ๋ฒ์ด๋์ง ์๋๋ก Math.min(), Math.max()๋ฅผ ์ฌ์ฉํด์ ์ธ๋ฑ์ค ์์น๋ฅผ ์กฐ์ ํ๋ค.๋ชจ๋ ์ํ์ง๋๋ฅผ ํ์ํ ํ ๋จ์ 0์ ๊ฐ์๋ฅผ ์ธ์ด ๋ฐํํ๋ค.๊ทธ๋ฆผ์ผ๋ก ํํํด ๋ณด์๋ค. ์ง๋ขฐ๊ฐ ์๋ ์์น ์ฆ, boa..

๐ 1. ๋ฌธ์ ์ค๋ช
Write a function to find the longest common prefix string amongst an array of strings.If there is no common prefix, return an empty string "".Note: All given inputs are in lowercase letters a-z. a-z์ ์๋ฌธ์ ์ํ๋ฒณ์ผ๋ก ๋จ์ด๋ค๋ก ๊ตฌ์ฑ๋ ๋ฐฐ์ด์ด ์ฃผ์ด์ก์ ๋, ๋ชจ๋ ๋ฌธ์์ด์ ๊ณตํต๋๋ ๊ฐ์ฅ ๊ธด ์ ๋์ฌ๋ฅผ ๋ฆฌํดํ๋ผ. ์ ๋์ฌ๊ฐ ์๋ ๊ฒฝ์ฐ์๋ ๋น ๋ฌธ์์ด์ ๋ฆฌํดํ๋ผ. Example 1Input: ["flower","flow","flight"] Output: "fl" Example 2Input: ["dog","racecar","car"] Output..

๐ 1. ๋ฌธ์ ์ค๋ช
ํ๋ก๊ทธ๋๋จธ์คSW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํprogrammers.co.kr๐ก 2. ํ์ด ๊ณผ์ ์ด ๋ฌธ์ ๋ queue ๋ก ํธ๋ ๋ฌธ์ ์ด๋ค (์ด๊ฑธ ์ ์ถํ ์ ์๋ ๋ถ๋ถ)card1๊ณผ card2๋ ๋ฌด์กฐ๊ฑด ์๋ถํฐ ์ฌ์ฉํด์ผ ํจ์์๋ฅผ ๋ค๋ฐ๊ฟ ์ ์์์ด ๋ ๋ฌธ์ฅ์ FIFO ๊ตฌ์กฐ๋ฅผ ๋ํ๋ธ๋ค.๊ทธ๋์ card1, card2, goal ์ ํ๋ฅผ ์ฌ์ฉํด์ ๊ด๋ฆฌ ๊ฐ๋ฅํ๋ค. card1๊ณผ card2, goal์ ํ๋ก ๋ณํํ๋ค.goal์ front์ (card1 ๋๋ card2)์ front์ ๊ฐ์ ๋น๊ตํ๋ค.์ฌ์ฉํ ์ ์๋ ์นด๋๊ฐ ์๋๊ฐ? (๊ฐ์ด ๊ฐ์ผ๋ฉด ์ฌ์ฉ ๊ฐ๋ฅ)Yes์ด๋ฉด ํด๋น ํ์ goal์์ ๊ฐ๊ฐ poll, ๊ทธ๋ ์ง ์์ผ๋ฉด No๋ฅผ ๋ฐํํ๋ค..