๐ 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..
์ค๋์ ์๋ฐ์ ํ์ฅ์ด(Escape sequence - ์ด์ค์ผ์ดํ ์ํ์ค)์ ๋ฌธ์์ด๊ณผ ๊ด๋ จํด์ ํท๊ฐ๋ฆฌ๋ ๋ถ๋ถ์ ์ ๋ฆฌํด๋ณธ๋ค. ๋ฌธ์์ด(String)์ ์ฝ์์ ์ถ๋ ฅํ๋ ค๊ณ ํ๋ฉด ์ค๋ฐ๊ฟ(๊ฐํ), ๋์ด์ฐ๊ธฐ, ๋ฌธ์ฅ๋ถํธ ์ฌ์ฉ์ด ๋ง์๋๋ก ๋์ง ์์ ๋๊ฐ ์๋ค. ์ด๋ด ๋ ๋ฐ์ํ๋ ์ค๋ฅ์ ํด๊ฒฐ๋ฒ, ๋ฌธ์์ด์ ๋ณ์์ ๋ด์ ์ฌ์ฉ ํ ๋ ์์๋์ด์ผ ํ ํ๋ค์ ์ ๋ฆฌ ํด ๋ณด์๋ค. โ
์์ฃผ ์ฐ์ด๋ ์ด์ค์ผ์ดํ ์ํ์ค ํ๋์ ๋ณด๊ธฐ ์ด์ค์ผ์ดํ ์ํ์ค ์ค๋ช
\n ์ค์ ๋งจ ๋์์ ์ฌ์ฉ. ์ค๋ฐ๊ฟ(๊ฐํ) ๊ธฐ๋ฅ \t ์คํ์ด์ค๋ฐ 4์นธ ๋งํผ ๋์ด์ฐ๊ธฐ \" ์ด๋ฏธ ์๋ฐ์ดํ๋ก ๊ฐ์ธ์ง ๋ฌธ์์ด ์์์ "๋ฅผ ๋ฌธ์ ๊ทธ๋๋ก ์ถ๋ ฅ \' '๋ฅผ ๋ฌธ์ ๊ทธ๋๋ก ์ถ๋ ฅ \\ ์ญ์ฌ๋์(\)๋ฅผ ๋ฌธ์ ๊ทธ๋๋ก ์ถ๋ ฅ \ ์ค ํฉ์ณ์ ํ ์ค๋ก ์ถ๋ ฅ \s ํ ์ค ๊ธ์ ๋ค์ชฝ ๊ณต๋ฐฑ์ ๊ทธ๋๋ก ๋จ๊ฒจ ๋..
โ
๋ฌธ์ ๋ฌธ์์ด ํํ์ 2์ง์๋ฅผ ์
๋ ฅ๋ฐ์ 10์ง์๋ก ๋ฐ๊พธ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. โ
์ฝ๋import java.util.Scanner;public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String str = sc.next(); int base = 1; int result = 0; for (int i = str.length()-1 ; i >= 0; i--) { if(str.charAt(i) == '1'){ result += base; } ..
โ
๋ฌธ์ ์ค๋งํธ๋ฏธ๋์ด์ธ์ฌ๊ฐ๋ฐ์์ ์ธ์ค์ด Java ์ํ๋ฌธ์ ๋ฅผ ์ฑ์ ํ๊ณ ์๋ค.๋ฌธ์ ๋ง๋ค 'o' ๋๋ 'x'๋ก ํ์๊ฐ ๋์ด ์๋๋ฐ ์ ์๋ฅผ ๋งค๊ธฐ๋ ๋ฐฉ์์ด ํน์ดํ๋ค.'o'๋ ์ ์๊ฐ ๋์ ๋๋ ๋ฐฉ์์ผ๋ก ์ฑ์ ๋๋๋ฐ ์ด์ ๋ถํฐ ์์ ์ ํฌํจํ ์ฐ์๋ 'o'์ ๊ฐ์ ๋งํผ์ ์ ์๋ก ์ฑ์ ์ด ๋ฉ๋๋ค.์๋ฅผ ๋ค์ด 'oooxoo'๋ผ๋ ํ์๊ฐ ์๋ค๋ฉด ์์๋๋ก 1+2+3+0+1+2=9 ์ผ๋ก ์ด์ ์ด ๊ณ์ฐ๋ฉ๋๋ค.ํ์์ด ํผ ์ํ์ง์ ์ ๋ต, ์ค๋ต ์ฌ๋ถ๊ฐ ํ์๋์ด ์์ ๋ ์ด์ ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. โ
์ฝ๋import java.util.Scanner;public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String c..