[ํ๋ก๊ทธ๋๋จธ์ค] [1์ฐจ] ์บ์ (LV.2) ๋ฌธ์ ๋งํฌ https://school.programmers.co.kr/learn/courses/30/lessons/17680 ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์
๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์
๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์. programmers.co.kr ํ์ด ๊ณผ์ 1. ์ฐ์ ์บ์ ์ฌ์ด์ฆ๊ฐ 0์ด๋ฉด, cache hit์ด ์กด์ฌํ์ง ์์ผ๋ฏ๋ก, ๋ฐฐ์ด๊ธธ์ด * 5๋ฅผ ํด์ ๋ฐ๋ก return ํด์ค๋ค. 2. ์บ์ ์ฌ์ด์ฆ์ ๋ง๊ฒ ๋ฌธ์์ด์ ๋ด์ ๋ฐฐ์ด cache๊ณผ ํด๋น ๋ฌธ์์ด์ด ์บ์์ ๋ช ํด๋์ ๋ด๊ณ ์์๋์ง ์นด์ดํธํ ์ ์ ๋ฐฐ์ด cnt์ ๋ง๋ค์ด์ฃผ์๋ค. 3. ๋จผ์ ์
๋ ฅ๋ฐ์ ๋์์ด๋ฆ ๋ฐฐ์ด cities๋ฅผ for๋ฌธ์ผ๋ก ๋๋ฉฐ ..
๐ป ๊ฐ๋ฐ/๐ ์๊ณ ๋ฆฌ์ฆ
[ํ๋ก๊ทธ๋๋จธ์ค] JadenCase ๋ฌธ์์ด ๋ง๋ค๊ธฐ (LV.2) ๋ฌธ์ ๋งํฌ https://school.programmers.co.kr/learn/courses/30/lessons/12951 ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์
๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์
๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์. programmers.co.kr ํ์ด ๊ณผ์ 1. JadenCase๋ ์
๋ ฅ๋ฐ์ ๊ฐ์ ๋ชจ๋ ๋จ์ด ์ฒซ ๋ฌธ์๊ฐ ๋๋ฌธ์์ด๊ณ , ๊ทธ ์ธ๋ ์๋ฌธ์์ด์ด์ผ ํ๋ค. ๊ฐ์ ๊ณต๋ฐฑ๋ฌธ์(" ")๋ก splitํ์ฌ String ๋ฐฐ์ด๋ก ๋ฐ๊ฟ์ฃผ์๋ค. ์ฌ๊ธฐ์ ์ฃผ์ํ ์ ์, '๊ณต๋ฐฑ๋ฌธ์๊ฐ ์ฐ์ํด์ ๋์ฌ ์ ์์ต๋๋ค.' ๋ผ๋ ์ ํ ์กฐ๊ฑด์ด ์กด์ฌํ๋ค. split() ๋ฉ์๋๋ ๋ฌธ์์ด์ ์์๊ณผ ๋์ ์๋ ๊ณต..
์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ด์ฉํ ์ต๋๊ณต์ฝ์, ์ต์๊ณต๋ฐฐ์ ์๊ณ ๋ฆฌ์ฆ์ ํ์ด์ฌ ์คํฌ๋ฆฝํธ๋ก ์์๋ณด์. ์ต๋๊ณต์ฝ์(GCD)๋? - ๋ ์์ฐ์์ ๊ณตํต๋ ์ฝ์ ์ค ๊ฐ์ฅ ํฐ ์ ์ต์๊ณต๋ฐฐ์(LCM)๋? - ๋ ์์ฐ์์ ๊ณตํต๋ ๋ฐฐ์ ์ค ๊ฐ์ฅ ์์ ์ ์ต์๊ณต๋ฐฐ์ = ๋ ์์ฐ์์ ๊ณฑ / ์ต๋๊ณต์ฝ์์ผ๋ก ๊ตฌํ ์ ์๋ค. ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ(Euclidean algorithm) ๋ ๊ฐ์ ์์ฐ์์ ์ต๋๊ณต์ฝ์๋ฅผ ์ฐพ๋ ๋ฐฉ๋ฒ ํฐ ์์์ ์์ ์๋ฅผ ๋นผ๋ฉด ์ต๋๊ณต์ฝ์๋ ๋ณํ์ง ์๋๋ค. ๋ฐ๋ผ์ ๋ ์ค ๋ ํฐ ๊ฐ์ ๋ฐ๋ณตํด์ ๋นผ๋ฉด ์ต๋๊ณต์ฝ์๊ฐ ๋๋ค. ( ex. 60, 36 ⇒ 60-36=24, 36-24=12, 24-12=12, 12-12=0. ์ต๋๊ณต์ฝ์ 12) ๋นผ๊ธฐ ๋์ ๋๋จธ์ง๋ฅผ ๊ตฌํ๋ค๊ฐ 0์ด ๋ ๋์ ์์ ๊ฐ์ด ์ต๋๊ณต์ฝ์์ด๋ค. ( ex. 12, 28 ⇒ ..
- ํ๋ก๊ทธ๋๋จธ์ค ๋ ๋ฒจ 1 ๋ฌธ์ import java.util.Arrays; import java.util.HashSet; import java.util.Iterator; class Solution { public int[] solution(int[] numbers) { HashSet set = new HashSet(); for (int i = 0; i < numbers.length; i++) { for (int j = i+1; j < numbers.length; j++) { int e = numbers[i] + numbers[j]; set.add(e); } } Iterator it = set.iterator(); int[] answer = new int[set.size()]; int i = -1; whi..
๋ฐฐ์ด์ ์ด์ฉํ ๊ธฐ์ด์ ์ธ ๋ฌธ์ ์๋ค. ๋ค๋ง ๋คํ๊ณ ๋์ ๋ค๋ฅธ ์ฌ๋๋ค์ ๋ฌธ์ ํ์ด๋ฅผ ๋ณด๋, for๋ฌธ์์ ์ํ๋ ๊ฐ์ ์ฐพ์์ ๋ break๋ฌธ์ ์ฌ์ฉํ๋ฉด ๋ ๋์ง์๊ณ ๋์ฌ ์ ์๋ค๋ ์ฅ์ ์ด ์์๋ค. ์ฌ์ด ๋ฌธ์ ์์๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์กฐ๊ธ์ด๋ผ๋ ๋ ์๋ ์ ์๋ ๋ฐฉ๋ฒ์ ๊ณ ์ฌํ์ฌ ์ฐพ์๋ด์ผ๊ฒ ๋ค. /* ๋ฌธ์ ์ค๋ช
Stringํ ๋ฐฐ์ด seoul์ element์ค Kim์ ์์น x๋ฅผ ์ฐพ์, ๊น์๋ฐฉ์ x์ ์๋ค๋ String์ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํ์ธ์. seoul์ Kim์ ์ค์ง ํ ๋ฒ๋ง ๋ํ๋๋ฉฐ ์๋ชป๋ ๊ฐ์ด ์
๋ ฅ๋๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค. ์ ํ ์ฌํญ seoul์ ๊ธธ์ด 1 ์ด์, 1000 ์ดํ์ธ ๋ฐฐ์ด์
๋๋ค. seoul์ ์์๋ ๊ธธ์ด 1 ์ด์, 20 ์ดํ์ธ ๋ฌธ์์ด์
๋๋ค. Kim์ ๋ฐ๋์ seoul ์์ ํฌํจ๋์ด ์์ต๋๋ค. ..
ํ์์์ ์๋ฐ๊ณผ์ ์ ๋ง์ณ๊ฐ์ ์์ผ๋ก ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ์กฐ๊ธ์ฉ์ด๋ผ๋ ํ์ด๋ณด๋ คํ๋ค. ์ฒ์ ํ์ด๋ณด๋ ๋ฌธ์ ๋ผ ์ฌ์ด ๋์ด๋๋ก ๊ณจ๋๊ณ , ์ฝ๋ฉ๋์ฅ ํํ์ด์ง์์ ์ถ์ ๋ ๋ฌธ์ ๋ฅผ ๊ฐ์ ธ์๋ค. ๋ฌธ์ ์ฃผ์ด์ง ๋ฌธ์์ด(๊ณต๋ฐฑ ์์ด ์ผํ๋ก ๊ตฌ๋ถ๋์ด ์์)์ ๊ฐ์ง๊ณ ์๋ ๋ฌธ์ ์ ๋ํ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์ด์ ๋,์ด์ฌ์,๊ถ์ข
ํ,์ด์ฌ์,๋ฐ๋ฏผํธ,๊ฐ์ํฌ,์ด์ฌ์,๊น์ง์,์ต์นํ,์ด์ฑ์ฐ,๋ฐ์์,๋ฐ๋ฏผํธ,์ ๊ฒฝํ,์ก์ ํ,๊น์ฌ์ฑ,์ด์ ๋,์ ๊ฒฝํ 1.๊น์จ์ ์ด์จ๋ ๊ฐ๊ฐ ๋ช ๋ช
์ธ๊ฐ์? 2."์ด์ฌ์"์ด๋ ์ด๋ฆ์ด ๋ช ๋ฒ ๋ฐ๋ณต๋๋์? 3.์ค๋ณต์ ์ ๊ฑฐํ ์ด๋ฆ์ ์ถ๋ ฅํ์ธ์. 4.์ค๋ณต์ ์ ๊ฑฐํ ์ด๋ฆ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ์ฌ ์ถ๋ ฅํ์ธ์. import java.util.ArrayList; import java.util.Collections; import java.util.H..