๋ชฉ๋ก๐ ์ฝ๋ฉํ ์คํธ (37)
Coding Planet

โจ ๋ฌธ์ https://school.programmers.co.kr/learn/courses/30/lessons/150370# ๐ป์ฝ๋ import java.util.HashMap; import java.util.Map; import java.util.List; import java.util.ArrayList; class Solution { public int[] solution(String today, String[] terms, String[] privacies) { //1. ์ฝ๊ด์ ์ ํจ๊ธฐ๊ฐ์ ๋งคํํ๋ค. // - termMap : ["A", "6"] Map termMap = new HashMap(); for(String term : terms){ String [] parts = term.split(" ..

โจ ๋ฌธ์ ๐ป์ฝ๋ class Solution { public long solution(long n) { //1. ์ซ์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํ char[] chars = Long.toString(n).toCharArray(); //2&3. ๋ฐฐ์ด์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ java.util.Arrays.sort(chars); StringBuilder sb = new StringBuilder(new String(chars)); //4. ๋ฌธ์์ด์ ๋ค์ ์ ์๋ก ๋ณํ return Long.parseLong(sb.reverse().toString()); } } ๐ฉ๐ป ํ์ด ๋ฐฉ๋ฒ Long.toString(n) : longํ์ ์ ๋ณ์ n์ ๋ฌธ์์ด๋ก ๋ณํํ๋ค. String.valueOf(n)์ ์ธ ์๋ ์๋ค. java.util.Array..
| ๋ฒ๋ธ์ ๋ ฌ(Bubble Sort)์ด๋? ๊ฐ๋จํ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ ์ค์ ํ๋๋ก ์ด๋ฆ์์ ์ ์ ์๋ฏ์ด, ์ด ์๊ณ ๋ฆฌ์ฆ์ ํฐ ๊ฐ์ด ๋ง์น "๋ฒ๋ธ"์ฒ๋ผ ๋ฐฐ์ด์ ๋์ผ๋ก "๋ ์ค๋ฅด๊ฒ"ํ๋ ๋ฐฉ์์ผ๋ก ์๋ํ๋ค. | ๋ฒ๋ธ์ ๋ ฌ(Bubble Sort)์ ์๋์๋ฆฌ 1) ์ฒซ ๋ฒ์งธ ํญ๋ชฉ๋ถํฐ ๋ง์ง๋ง ํญ๋ชฉ๊น์ง ์์ฐจ์ ์ผ๋ก ์ด๋ํ๋ฉด์ ์ธ์ ํ ํญ๋ชฉ์ ๋น๊ตํ๋ค. 2) ์ธ์ ํ ๋ ํญ๋ชฉ์ ๋น๊ตํ๋ฉด์ ์ผ์ชฝ ํญ๋ชฉ์ด ์ค๋ฅธ์ชฝ ํญ๋ชฉ๋ณด๋ค ํฌ๋ฉด ๋ ํญ๋ชฉ์ ์์น๋ฅผ ๋ฐ๊พผ๋ค. 3) ์์ ๊ณผ์ ์ ๋ฐฐ์ด์ ๋ชจ๋ ํญ๋ชฉ์ ๋ํด ๋ฐ๋ณตํ๋ค. 4) ์์ 3๋จ๊ณ๋ฅผ ๋ฐฐ์ด์ ํญ๋ชฉ ์๋งํผ ๋ฐ๋ณตํ๋ฉด ๋ฐฐ์ด์ด ์ ๋ ฌ๋๋ค. ์์) 1 5 3 9 7 ๋ฐฐ์ด์ด ๋ฒ๋ธ ์ ๋ ฌ๋๋ ๊ณผ์ ์ ๋จ๊ณ๋ณ๋ก ์ดํด๋ณด๊ฒ ์ต๋๋ค. ์ด๊ธฐ ๋ฐฐ์ด 1 5 3 9 7 1์ฐจ ๋ฐ๋ณต (i=0) 1๊ณผ 5๋ฅผ ๋น๊ต: ์ ๋ ฌ์ด ํ์ํ์ง ์์ต๋๋ค. ..

| ์๊ฐ๋ณต์ก๋(Time Complexity)๋? ์๊ฐ ๋ณต์ก๋๋ ์๊ณ ๋ฆฌ์ฆ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๋ํ๋ด๋ ์ฒ๋์ด๋ค. ์๊ณ ๋ฆฌ์ฆ์ ์คํ ์๊ฐ์ ์ ๋ ฅ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๋ ํน์ฑ์ ๋ฐ๋ผ ๋ค๋ฅผ ์ ์๊ธฐ ๋๋ฌธ์, ์๊ฐ ๋ณต์ก๋๋ ์ผ๋ฐ์ ์ผ๋ก ์ต์ ์ ๊ฒฝ์ฐ, ํ๊ท ๊ฒฝ์ฐ, ์ต์ ์ ๊ฒฝ์ฐ๋ก ๋๋์ด ํ๊ฐ๋๋ค. ๋น -์ค ํ๊ธฐ๋ฒ(Big O Notation) : ์๊ฐ ๋ณต์ก๋๋ฅผ ํํํ๋๋ฐ ๊ฐ์ฅ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉ๋๋ ํ๊ธฐ๋ฒ์ด๋ค. ๋น ์ค ํ๊ธฐ๋ฒ์ ์๊ณ ๋ฆฌ์ฆ ์ฑ๋ฅ์ ๊ฐ์ฅ ํฐ ์ํฅ์ ๋ฏธ์น๋ ๋ถ๋ฌธ๋ง์ ๊ณ ๋ คํ์ฌ ๋ํ๋ธ๋ค. ์๋ฅผ ๋ค์ด, ๋์ ์ ๋์ ธ ๋ท๋ฉด์ด ๋์ฌ ํ๋ฅ ์ ์ด์ผ๊ธฐํ ๋ ์ด์ด ์ข์ผ๋ฉด 1๋ฒ์ ๋ท๋ฉด์ด ๋์ค์ง๋ง ์ด์ด ์์ข์ ๊ฒฝ์ฐ n๋ฒ ๋งํผ ๋์ ์ ๋์ ์ผ ํ๋ค. ์ด๋ฐ ํ๋ฅ ์์ ์ต์ ์ ๊ฒฝ์ฐ๋ฅผ ๊ณ์ฐํ๋ ๋ฐฉ์์ ๋น ์ค ํ๊ธฐ๋ฒ์ด๋ผ ํ๋ค. ์์ฃผ ์ฌ์ฉ๋๋ ์..
1. ๋ฌธ์ ์๊ตฌ์ฌํญ ํ์๋ ์ํฌ์๊ฒ ์ํ๋ฒณ ๋๋ฌธ์๋ก ๊ตฌ์ฑ๋ ๋น๋ฐํธ์ง๋ฅผ ๋งค์ผ ์ปดํจํฐ๋ฅผ ์ด์ฉํด ๋ณด๋ ๋๋ค. ๋น๋ฐํธ์ง๋ ํ์์ ์ํฌ๊ฐ ์๋ก ์ฝ์ํ ์ํธ๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. ๋น๋ฐํธ์ง๋ ์ํ๋ฒณ ํ ๋ฌธ์๋ง๋ค # ๋๋ *์ด ์ผ๊ณฑ ๊ฐ๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค. ๋ง์ฝ ํ์๊ฐ “#*****#”์ผ๋ก ๊ตฌ์ฑ๋ ๋ฌธ์๋ฅผ ๋ณด๋๋ค๋ฉด ์ํฌ๋ ํ์์ ์ฝ์ํ ๊ท์น๋๋ก ๋ค์๊ณผ ๊ฐ์ด ํด์ํฉ๋๋ค. 1. “#*****#”๋ฅผ ์ผ๊ณฑ์๋ฆฌ์ ์ด์ง์๋ก ๋ฐ๊ฟ๋๋ค. #์ ์ด์ง์์ 1๋ก, *์ด์ง์์ 0์ผ๋ก ๋ณํํฉ๋๋ค. ๊ฒฐ๊ณผ๋ “1000001”๋ก ๋ณํ๋ฉ๋๋ค. 2. ๋ฐ๋ 2์ง์๋ฅผ 10์ง์ํ ํฉ๋๋ค. “1000001”์ 10์ง์ํ ํ๋ฉด 65๊ฐ ๋ฉ๋๋ค. 3. ์์คํค ๋ฒํธ๊ฐ 65๋ฌธ์๋ก ๋ณํํฉ๋๋ค. ์ฆ ์์คํฌ๋ฒํธ 65๋ ๋๋ฌธ์ 'A'์ ๋๋ค. ์ฐธ๊ณ ๋ก ๋๋ฌธ์๋ค์ ์์คํค ๋ฒํธ๋ '..
1. ๋ฌธ์ ์๊ตฌ์ฌํญ ๋ฌธ์์ ์ซ์๊ฐ ์์ฌ์๋ ๋ฌธ์์ด์ด ์ฃผ์ด์ง๋ฉด ๊ทธ ์ค ์ซ์๋ง ์ถ์ถํ์ฌ ๊ทธ ์์๋๋ก ์์ฐ์๋ฅผ ๋ง๋ญ๋๋ค. ๋ง์ฝ “tge0a1h205er”์์ ์ซ์๋ง ์ถ์ถํ๋ฉด 0, 1, 2, 0, 5์ด๊ณ ์ด๊ฒ์ ์์ฐ์๋ฅผ ๋ง๋ค๋ฉด 1205์ด ๋ฉ๋๋ค. 2. ๋ด ํ์ด - Character.isDigit() ์์ ์ํ๋ฒณ์ ์ฐพ์๋ด๋ ๋ฉ์๋ Character.isAlphabet()์ ์ฌ์ฉํ ์ ์ด ์๋ค. ์ด๋ฒ์๋ ํ๋ผ๋ฏธํฐ๋ก ์ฃผ์ด์ง๋ ๋ฌธ์๊ฐ ์ซ์์ธ์ง ํ๋ ํ๋ ๋ฉ์๋ Character.isDigit()๋ฅผ ์ฌ์ฉํ๋ค. ์ด ๋ str ๋ฌธ์์ด์ ๋๋ฉด์ charAt()์ผ๋ก ํด๋น ๋ฌธ์๊ฐ ์ซ์์ธ์ง ํ๋ ํ๊ฒ๋๋ค. ๋ฌธ์ ์์ "์์ฐ์"๋ฅผ ๋ฐํํ๋ผ๊ณ ํ์ผ๋ฏ๋ก 0์ผ๋ก ์์ํ ๊ฒฝ์ฐ 0์ ์์ ์ผํ๋ค. ๋ฐ๋ผ์ ๋ฌธ์์ด๋ก ๋ง๋ค๊ณ intํ์ผ๋ก ๋ฐ๊ฟ์ ๊ฐ์ฅ ์์..

1. ๋ฌธ์ ์๊ตฌ์ฌํญ ๋ฌธ์์ด์ด ์ ๋ ฅ๋๋ฉด ํด๋น ๋ฌธ์์ด์ด ํฐ๋ฆฐ๋๋กฌ์ด๋ฉด "YES", ์๋๋ฉด “NO"๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ๋จ ํ๋ฌธ์ ๊ฒ์ฌํ ๋ ์ํ๋ฒณ๋ง ๊ฐ์ง๊ณ ํ๋ฌธ์ ๊ฒ์ฌํ๋ฉฐ, ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ์ง ์์ต๋๋ค. 2. ๋ด ํ์ด - replaceAll(), reverse() ์ซ์, ํน์๋ฌธ์ ๋ฑ์ด ์์ธ ๋ฌธ์์ด์์ ์ํ๋ฒณ๋ง ์ถ์ถํ๊ธฐ ์ํด์๋ replaceAll()์ ์ฌ์ฉํ๋ค. ์ด๋ ์ํ๋ฒณ ์ด์ธ์ ๊ฒ๋ค์ " " (๊ณต๋ฐฑ๋ฌธ์)๋ก ๋ฐ๊ฟ์ค๋ค. ํ๋ฌธ ๋น๊ต๋ ์ด์ ํฌ์คํธ์ reverse()๋ฅผ ์ฌ์ฉํ๋ค. import java.util.Scanner; public class PalindromeChecker { public String solution(String str) { //1. ์ ๊ท์์ ์ด์ฉํ์ฌ ์ํ๋ฒณ์ ์ถ์ถํ๊ณ ๋๋ฌธ์..
1. ๋ฌธ์ ์๊ตฌ์ฌํญ ์์์ ์ฝ์ ๋๋ ๋ค์์ ์ฝ์ ๋๋ ๊ฐ์ ๋ฌธ์์ด์ ํ๋ฌธ ๋ฌธ์์ด์ด๋ผ๊ณ ํฉ๋๋ค. ๋ฌธ์์ด์ด ์ ๋ ฅ๋๋ฉด ํด๋น ๋ฌธ์์ด์ด ํ๋ฌธ ๋ฌธ์์ด์ด๋ฉด "YES", ํ๋ฌธ ๋ฌธ์์ด์ด ์๋๋ฉด “NO"๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ๋จ ํ๋ฌธ์ ๊ฒ์ฌํ ๋ ๋์๋ฌธ์๋ฅผ ๊ตฌ๋ถํ์ง ์์ต๋๋ค. 2. ๋ด ํ์ด ์ด์ ๋ฌธ์ ์ธ ๋จ์ด ๋ค์ง๊ธฐ์์ ์ฌ์ฉํ๋ ๋ก์ง์ ๊ทธ๋๋ก ์ฌ์ฉํด์ ํ ์ ์์๋ค. ๋ค๋ง if๋ฌธ์ ๋ง๋ค ๋ '๊ฐ์๊ฒฝ์ฐ'์ '๋ค๋ฅธ ๊ฒฝ์ฐ' ์ด๋ค ๊ฒ์ด ๊ธฐ์ค์ด ๋์ด์ผํ๋๊ฐ ๊ณ ๋ฏผํ๋ฉด์ ํค๋งธ๋ค. ์ฌ์ค ๋ฐ๊พผ๋ค๊ณ ํฌ๊ฒ ๋ค๋ฅธ๊ฑด์๋์ง๋ง ์ด๋ค ๋ณ์๋ฅผ ์ฆ๊ฐ ๋ฐ ๊ฐ์์ํค๋๊ฒ ๋ค๋ก ๊ฐ๋๊ฒ ๊น๋ํ import java.util.Scanner; public class Palindrome { public String solution(String str) {..
1. ๋ฌธ์ ์๊ตฌ์ฌํญ ์๋ฌธ์๋ก ๋ ํ๊ฐ์ ๋ฌธ์์ด์ด ์ ๋ ฅ๋๋ฉด ์ค๋ณต๋ ๋ฌธ์๋ฅผ ์ ๊ฑฐํ๊ณ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์ค๋ณต์ด ์ ๊ฑฐ๋ ๋ฌธ์์ด์ ๊ฐ ๋ฌธ์๋ ์๋ ๋ฌธ์์ด์ ์์๋ฅผ ์ ์งํฉ๋๋ค. 2. ๋ฌธ์ ํ์ด indexOf()๋ ํด๋น ๋ฌธ์๊ฐ ๊ฐ์ฅ ์ฒ์ ๋ฐ๊ฒฌ๋๋ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๋ ๋ฉ์๋์ด๋ค. str.CharAt()์ ํ๋ผ๋ฏธํฐ๋ก ๋ค์ด๊ฐ ์ซ์์ ์ธ๋ฑ์ค์ ํ์ฌ ๋ฌด์จ ๋ฌธ์๊ฐ ์๋์ง ๋ฐํํ๋ ๋ฉ์๋์ด๋ค. ์ค๋ณต๋ฌธ์๋ฅผ ์ ๊ฑฐํ๋ ๊ฐ์ฅ ์ค์ํ ๋ ผ๋ฆฌ๋ ํด๋น ๋ฌธ์๊ฐ ์ฒ์ ๋ฑ์ฅํ๋ ์ธ๋ฑ์ค ๋ฒํธ์ ํ์ฌ ํด๋น ๋ฌธ์๊ฐ ์กด์ฌํ๋ ์ธ๋ฑ์ค๊ฐ ๊ฐ์ผ๋ฉด ๊ทธ ๋ฌธ์๋ ์ค๋ณต๋์ง ์๋ ๋ฌธ์์ธ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด, ๋ฐ๋ณต๋ฌธ์์ good์ด๋ผ๋ ๋ฌธ์๋ฅผ ์ํํ๋ค๋ฉด index[0]์ ๋ฌธ์(str.charAt(i))๋ 'g'์ด๋ค. ๋ํ g์ ๊ฐ ์ฒ์ ๋ฑ์ฅํ๋ ์ธ๋ฑ์ค(str.i..
1. ๋ฌธ์ ์๊ตฌ์ฌํญ ์์ด ์ํ๋ฒณ๊ณผ ํน์๋ฌธ์๋ก ๊ตฌ์ฑ๋ ๋ฌธ์์ด์ด ์ฃผ์ด์ง๋ฉด ์์ด ์ํ๋ฒณ๋ง ๋ค์ง๊ณ , ํน์๋ฌธ์๋ ์๊ธฐ ์๋ฆฌ์ ๊ทธ๋๋ก ์๋ ๋ฌธ์์ด์ ๋ง๋ค์ด ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. 2-1. ๋์ ๋ฌธ์ ํ์ด ์ด ๋ฌธ์ ๋ฅผ ํ๊ธฐ์ํด์๋ ์ฃผ์ด์ง ๋ฌธ์์ด์ ๋ฌธ์๊ฐ ์์ด ์ํ๋ฒณ์ธ์ง ํน์๋ฌธ์์ธ๋ฅผ ๋จผ์ ๊ตฌ๋ถํด์ผ ํ๋ค. ASCII ์ฝ๋๋ฅผ ํตํด ๊ตฌ๋ถํ ์ ์๋ค. package algorithm01; import java.util.ArrayList; import java.util.Scanner; public class SpecificReverse { public String solution(String str) { //ArrayList ์ฌ์ฉํ๋ ์ด์ : ์์์ ์๋ฃํ์ด ๋ฌ๋ผ์ String answer =""; //ASCII ์ฝ๋๋ก ..