๐ 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..
My Tech Blog (๋ฉ์๋)
๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๋ต์ฝ๋๐
๐ปโ๏ธ ์ฒซ ๋ฒ์งธ ์๋ - ํ๋ฆผ โํ๋ก๊ทธ๋๋จธ์ค ์ฝ์์ด ์๋์์ฑ์ด ์ ๋๊ธฐ ๋๋ฌธ์ ์๊ฐ๋๋๋ฐ๋ก ์จ์ ๋ง์ด ํ๋ ธ๋ค.class Solution { public String solution(String str1, String str2) { StringBuilder sb = new StringBuilder(); for(int i = 0; i ์ค๋ต ์ ๋ฆฌโญ str1.length → str1.length() length๋ ๋ฐฐ์ด์์ ์ฌ์ฉ๋๊ณ , ๋ฌธ์์ด์์๋ length() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. โญ sb.add(...) → sb.append(...)StringBuilder๋ add() ๋ฉ์๋๊ฐ ์๊ณ , ๋์ append()๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.โญ st..
๐ 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..
์ ๋ถํฐ ํฌ์คํ
ํด์ผ ๊ฒ ๋ค๊ณ ์๊ฐํ๋๋ฐ ๋ฏธ๋ฃจ๋ค๊ฐ ํ๋ ํฌ์คํ
์๋ฃ์กฐ์ฌ ํ๋ ค๋ฉด ๋๋ฌด ์ค๋๊ฑธ๋ ค์ ๋ค์์ ํ๋ ค๋ค๊ฐ ์ง๊ธ ์งฌ๋ด์ ํ๋ฑ ํด ๋ฒ๋ฆฌ์ 1. Map๊ณผ Set Map๊ณผ Set์ ์๋ฐ์์ ์ปฌ๋ ์
ํ๋ ์์ํฌ(Collection Framework)์ ์ํ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ๋ ๋ค java.utilํจํค์ง์ ํฌํจ๋์ด ์๋ค. ๊ธฐ๋ณธ ์๋ฃํ์ ์๋๊ณ ๊ฐ์ฒด๋ก ๋ค๋ฃจ์ด์ง๋ ์๋ฃ๊ตฌ์กฐ์ธ๋ฐ, Map์ key-value ํํ๋ก ๋น ๋ฅธ ๊ฒ์์ด ํ์ํ ๋๋์ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ๋ ์ ์ฉํ๊ณ , Set์ ์ค๋ณต ์๋ ๋ฐ์ดํฐ ์งํฉ์ด ํ์ํ ๋ ์ฌ์ฉ๋๋ค. 2. Map ์ด๋? ์ฌ๋์ ‘์ด๋ฆ = ์ต๋ค์ธ’, 'ํค = 165' ๋ฑ์ผ๋ก ๊ตฌ๋ถํ ์ ์๋ฏ์ด ๋งต(Map) ์ ๋์ ๊ด๊ณ๋ฅผ ์ฝ๊ฒ ํํํ ์ ์๊ฒ ํด์ฃผ๋ ์๋ฃํ์ด๋ค. ๋งต์ ๊ตฌํ์ฒด ์ค์ ๊ฐ์ฅ ์ ๋ช
ํ ๊ฑด ..
์.... ๊ณต๋ถํ๋ค๊ฐ ๋๋ง ๋ณด๋ ค๊ณ ์ด๋ ๊ฒ ์์ธํ๊ฒ ์ ์ ์๊ฐ ์์๋๋ฐ ํน์๋์ ๋ธ๋ก๊ทธ ๋ค์ด์ค์ค ์๋ ์๋ ๋ถ๋ค์ ์ํด์... ๊ทธ๋ฅ ๋ค ์์ฝํด์ ์ ์ด ๋ด
๋๋ค..ใ
ใ
ใ
ํ์ด์ฌ์ ์๋ฃ ๊ตฌ์กฐ ๋ฆฌ์คํธ [ ]Square BracketSํํ ( )Round Brackets์
{ }Braces๋์
๋ฌ๋ { 'key:value' } 1. ๋ฆฌ์คํธ(List) - ๋ฐฐ์ด์ฒ๋ผ ์ฌ๋ฌ ์์๋ฅผ ๊ฐ๋ ์งํฉ, - ์๋ก์ด ์์ ์ฝ์
, ๊ฐฑ์ , ์ญ์ ๊ฐ๋ฅ - ํ์ด์ฌ ๋ฆฌ์คํธ๋ ๋์ ๋ฐฐ์ด, ์ฆ ์์ ๋กญ๊ฒ ํ์ฅ ๊ฐ๋ฅ - [] ๋๊ดํธ ์ฌ์ฉ - ๊ฐ ์์๋ค์ ์๋ก ๋ค๋ฅธ ํ์
๋ ๊ฐ๋ฅ โ
๋ฆฌ์คํธ ๋ฉ์๋ - # list.index(์์) ๋ฆฌ์คํธ์์ ํน์ ์์ ์์น ๊ฒ์ - ์ฒซ๋ฒ์งธ ์์ํ๋ ์์น ๋ฐํ- # list.count(์์) ๋ฆฌ์คํธ ์์ ์์น๊ฐ ํฌํจ๋..
๐ JavaScript โ
1. screen ๊ฐ์ฒดscreen ๊ฐ์ฒด๋ ์ฌ์ฉ์์ ๋ชจ๋ํฐ ์ ๋ณด(์์ฑ)์ ์ ๊ณตํ๋ ๊ฐ์ฒด์
๋๋ค. ์๋ฅผ ๋ค์ด ๋ชจ๋ํฐ์ ๋๋น๋ ๋์ด ๋๋ ์ปฌ๋ฌ ํํ bit์ ๋ฐํํฉ๋๋ค. 1-1. ๊ธฐ๋ณธํ screen.์์ฑ;screen.width; //๋ชจ๋ํฐ์ ๋๋น๊ฐ ๋ฐํ 1-2. screen ๊ฐ์ฒด ์ ์์ฑ ์ข
๋ฅ์ข
๋ฅ์ค๋ช
screen.widthํ๋ฉด์ ๋๋น๊ฐ ๋ฐํscreen.heightํ๋ฉด์ ๋์ด๊ฐ ๋ฐํscreen.availWidth(์์
ํ์์ค์ ์ ์ธํ) ํ๋ฉด์ ๋๋น๊ฐ ๋ฐํ screen.availHeight (์์
ํ์์ค์ ์ ์ธํ) ํ๋ฉด์ ๋์ด๊ฐ ๋ฐํ screen.colorDepth์ฌ์ฉ์ ๋ชจ๋ํฐ๊ฐ ํํ ๊ฐ๋ฅํ ์ปฌ๋ฌ bit๋ฅผ ๋ฐํ โ
2. location ๊ฐ์ฒดlocation ๊ฐ์ฒด๋ ์ฌ์ฉ์ ๋ธ๋ผ์ฐ์ ์ ๊ด๋ จ..
โ
๋ฌธ์ 2๊ฐ์ ์ ์ base, n์ ์
๋ ฅ ๋ฐ๊ธฐbase์ n์ ๊ณฑ ๋ฐํํ๋ powerN() ๋ฉ์๋ ๋ง๋ค๊ธฐโ
์ฝ๋public class bonus06 { public static void main(String[] args) { System.out.println(powerN(2, 3)); } public static int powerN(int base, int n) { int result = 1; for (int i = 0; i ๋ฉ์๋๋ Main ์์ญ ๋ฐ์์ ๋ง๋ค์ด ์ค๋ค.๋งค๊ฐ๋ณ์ 2 ๊ฐ: base์ nresult ๋ณ์๋ฅผ 1๋ก ์ด๊ธฐํ (๊ฒฐ๊ณผ ์ ์ฅํ ๋ณ์)for ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ฌ base๋ฅผ n๋ฒ ๊ณฑํ๋ค. ๋ฃจํ๊ฐ ํ ๋ฒ ์คํ๋ ๋๋ง๋ค result์ base๋ฅผ ๊ณฑํด..
โ
๋ฌธ์ ๊ณ์ฐ๊ธฐ ๋ง๋ค๊ธฐ โ
์ถ๋ก ๊ณผ์ ๋ ๊ฐ์ ์ ์์ ์ฐ์ฐ์๋ฅผ ์
๋ ฅ ๋ฐ์์ ํด๋น ์ฐ์ฐ์ ์ํํ๋ ๊ฐ๋จํ ๊ณ์ฐ๊ธฐ ๊ตฌํ ์ฝ๋์ด๋ค. ๋งค๊ฐ๋ณ์๊ฐ ์ด 3๊ฐ์ด๊ณ , int ํ์ผ๋ก ๊ฒฐ๊ณผ๋ฅผ return ํด ์ฃผ๋ฉด ๋๋ ์ฌ์ด ๋ฌธ์ ์ด๋ค. ๋ฉ์๋๋ Main ์์ญ ๋ฐ์์ ๋ง๋ค์ด์ฃผ๊ณ ๊ฒฐ๊ณผ ๊ฐ๋ง Main ์์ญ ์์์ ์ถ๋ ฅํด์ฃผ๋ฉด ๋๋ค. โ
์ฝ๋public class bonus03 { public static void main(String[] args) { System.out.println(cal(4, 7, '*')); } public static int cal(int num1, int num2, char op) { if (op == '+') { return n..