๐ 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..

My Tech Blog (๋ฌธ์์ด)
์ค๋์ ๋ช
์ธ
" ์ธ๊ฐ์ ์๋ํจ์ ์์ ์ ์ถ์ ๋ณํ์ํค๋ ๋ฅ๋ ฅ์ ์๋ค. "
๐ 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. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ค๋ต์ ๋ฆฌ (ํ๋ฆฐ์ฝ๋)class Solution { public String solution(String my_string, String letter) { StringBuilder sb = new StringBuilder(); for(char c : my_string.toCharArray()) { if(!c.equals(letter) sb.append(c); } return sb.toString(); }} string ํ์
๋ผ๋ฆฌ ๋น๊ตํ ๋๋ .equals ๋ฅผ ์ด๋ค. ๊ทธ๋์ .equals์ ๋ถ์ ์ธ !c.equals(letter)์ ์ผ๋๋ฐ ์ด ๋ถ๋ถ์ด ํ๋ ธ๋ค. ํ๋ฆฐ ์ด์ ๋ String ์ด๋ char ํ์
..

๐ 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. ๋ฌธ์์ด ์๊ธฐ ๐ก 1-1. ์ ๊ทผ๋ฐฉ์โ ๋จ์ํ ์ฃผ์ด์ง ๋ณ์๋ช
๊ทธ๋๋ก a + b > b + a ์ด๋ ๊ฒ ๋น๊ตํ๋ฉด ๋ ์ซ์๋ ์ ์ ๋ง์
์ด๊ธฐ ๋๋ฌธ์ ํญ์ a + b == b + a๊ฐ ๋๋ค. ๋ฌธ์ ์์ ์๋ํ ๊ฒ์ ์ซ์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ์ฌ ์ฐ๊ฒฐํ ํ, ํฌ๊ธฐ๋ฅผ ๋น๊ตํ๋ ๊ฒ์ด๋ค. ์ฌ๋ฐ๋ฅด๊ฒ ๋น๊ตํ๋ ค๋ฉด String.valueOf(a) + b์ String.valueOf(b) + a ๋ฅผ ๋น๊ตํด์ผ ํ๋ค. โ ๋ ๋๋ ์ฒ์์ sb.toString()์ ์จ์ int๋ก ๋ฐํํ๋ ์ค์๋ฅผ ํ๋๋ฐ, sb.toString()์ ๋ฌธ์์ด์ด๊ธฐ ๋๋ฌธ์, int ํ์
์ ๋ฐํํ๋ solution ๋ฉ์๋์ ํ์
์ด ๋ง์ง ์๋๋ค. ๊ทธ๋์ Integer.parseInt(sb.toString())์ ์ฌ์ฉํ์ฌ ๋ณํํด์ผ ํ๋ค. ํ๋ฆฐ ์ฝ๋clas..
๐ 1. ๋ฌธ์ ์ค๋ช
โญ 2. ์ ๋ต์ฝ๋class Solution { public String solution(String my_string, String overwrite_string, int s) { // ์๋ถ๋ถ๊ณผ ๋ท๋ถ๋ถ์ ์ถ์ถํ ํ overwrite_string์ ์ค๊ฐ์ ์ฝ์
String before = my_string.substring(0, s); String after = my_string.substring(s + overwrite_string.length()); return before + overwrite_string + after; }} โญ String before = my_string.substring(0, s); ์์ substr..

# ํ
ํ๋ฆฟ ๋ฆฌํฐ๋ด(Template Literal)ES6๋ถํฐ ์๋ก ๋์
๋ ๋ฌธ์์ด ํ๊ธฐ๋ฒ๋ฌธ์์ด ์์ฑ์ ๋ฐ์ดํ ๋์ , ๋ฐฑํฑ(`)์ ์ฌ์ฉvar str_01 = `hello world`;//๋ฐฑํฑ ์ฌ์ฉconst x='x';const y='y';const z='z';console.log(`${x}๋ x, ${y}๋ y, ${z}๋ z์ด๋ค. `); //x๋ x, y๋ y, z๋ z์ด๋ค. โถ๏ธ ๋ฐฑํฑ(`)์ ์๋ฐ์คํฌ๋ฆฝํธ JS ES6(ECMAScript 2015)๋ถํฐ ๋์
๋์๋ค.โถ๏ธ ๊ฐํ ๋ฌธ์(\n)๋ฅผ ์ฌ์ฉํ์ง ์์๋ ์๋ ์ค๋ฐ๊ฟ โถ๏ธ ์๊น์๊ฐ ์์๋ฐ์ํ(')์ ๋น์ทํ๋ ํท๊ฐ๋ฆฌ์ง ์๋๋ก ์ฃผ์# ํ
ํ๋ฆฟ ๋ฆฌํฐ๋ด - ๋ฐฑํฑ(`)์ ๊ธฐ๋ฅ ์ค๋ฐ๊ฟ(๊ฐํ: Multi-line strings) โถ๏ธ ๋ฐฑํฑ(`)์ผ๋ก ํ
ํ๋ฆฟ ๋ฆฌํฐ๋ด์ ์ฌ์ฉํ๋ฉด..

โ
๋ฌธ์ ํ๋ก๊ทธ๋๋จธ์ค ๋ฌธ์ ๋ฅผ ์ดํด๋ฆฝ์ค์์ ํ๋ ์ค ๋ฐฐ์ด๋ช
์ ์๋ชป๋ด์ reserve๋ฅผ reverse๋ผ๊ณ ์
๋ ฅํด ๋ฒ๋ฆผ์ดํด๋ฆฝ์ค์์ ๋ฌธ์์ด ์ผ๊ด ํ๋ฒ์ ์นํํ๋ ๋ฒ (์ค์ฝํ ์ค์ํจ)โ
ํด๊ฒฐ๋ฒ1. `Ctrl` + `H`๋ก `Search` ์ฐฝ ๋์ฐ๊ธฐ > `File Search` > `Containing text`์ ์ฐพ์ ๋ฌธ์์ด ์
๋ ฅ > `Scope` (๋ฒ์ ์ค์ ) ์์ ํ์ฌํ์ผ๋ง ๋ณ๊ฒฝํ ๊ฒ์ธ์ง, ์ด๋ฆฐ ํ์ผ ๋ชจ๋ ๋ณ๊ฒฝํ ๊ฒ์ธ์ง, ์ฐ๊ฒฐ๋ ์ ์ฒด ํ์ผ์์ ํด๋น ๋ฌธ์์ด์ ๋ชจ๋ ์นํํ ๊ฒ์ธ์ง ์ ํ ํด ์ค๋ค > `Replace` ์ฌ๊ธฐ์ ์ฃผ์ํ ์ ์ `Scope` ์ค์ ์ ์ ํด์ผ ํ๋ค๋ ๊ฒ!`Workspace`๋ก ์ฒดํฌํ๋ฉด ํ์ฌ ์ดํด๋ฆฝ์ค์ ์ฐ๊ฒฐ๋ ๋ชจ๋ ํ์ผ์์ ๊ฐ์ ๋ฌธ์๋ฅผ ๋ค ์นํํด ๋ฒ๋ฆฐ๋ค. `Files opened in edito..