๐ Algorithm (29) ์ธ๋ค์ผํ ๋ฆฌ์คํธํ [ํ๋ก๊ทธ๋๋จธ์ค] ํผ์ ๋๋ ๋จน๊ธฐ (1) (JAVA) ๐ก ๋ฌธ์ (๋จธ์ฑ์ด๋ค ํผ์๊ฐ๊ฒ๋ ํผ์๋ฅผ ์ผ๊ณฑ ์กฐ๊ฐ์ผ๋ก ์๋ผ ์ค๋๋ค. ํผ์๋ฅผ ๋๋ ๋จน์ ์ฌ๋์ ์ n์ด ์ฃผ์ด์ง ๋, ๋ชจ๋ ์ฌ๋์ด ํผ์๋ฅผ ํ ์กฐ๊ฐ ์ด์ ๋จน๊ธฐ ์ํด ํ์ํ ํผ์์ ์๋ฅผ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ์๊ตฌ์ฌํญ: ์ฃผ์ด์ง ๋ฌธ์ ์์ ๋ชจ๋ ์ฌ๋์ด ํ ์กฐ๊ฐ ์ด์ ๋จน์ด์ผ ํ๋ค๊ณ ๋ช ์๋์ด ์๊ธฐ ๋๋ฌธ์, ๋ชจ๋ ์ฌ๋์ด ๋จน๋ ์กฐ๊ฐ์ ์๋ ์ ์ด๋ n์กฐ๊ฐ ์ด์์ด์ด์ผ ํ๋ค. (n - 1) / 7 ์ ํตํด ํผ์ ์กฐ๊ฐ ์๋ฅผ ๊ณ์ฐํ๊ณ , +1 ์ ํตํด ์ฌ๋ฆผ ์ฒ๋ฆฌํ๋ค. ์ด์ ๋ n ์กฐ๊ฐ ์ด์์ด ํ์ํ๊ธฐ ๋๋ฌธ์ด๋ค. ์๋ฅผ ๋ค์ด, ๋ง์ฝ n=7 ์ด๋ผ๋ฉด, (7-1)/7 + 1 = 1 ์ด ๋์ด์ผ ํ๋ค. ์ฆ, 1๊ฐ์ ํผ์๊ฐ ํ์ํ๋ค. ๋ค๋ฅธ ์๋ก, n=10 ์ด๋ผ๋ฉด, (10-1)/7 + 1 = 2 ์ด ๋์ด์ผ ํ๋ค. ์ฆ, 2.. [ํ๋ก๊ทธ๋๋จธ์ค] ๋ฐฐ์ด ์๋ฅด๊ธฐ (JAVA) ๐ก ๋ฌธ์ ์ ์ ๋ฐฐ์ด numbers์ ์ ์ num1, num2๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, numbers์ num1๋ฒ ์งธ ์ธ๋ฑ์ค๋ถํฐ num2๋ฒ์งธ ์ธ๋ฑ์ค๊น์ง ์๋ฅธ ์ ์ ๋ฐฐ์ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ํ์ด: Arrays.stream(numbers, num1, num2 + 1) : numbers ๋ฐฐ์ด์ num1๋ฒ์งธ ์ธ๋ฑ์ค๋ถํฐ num2๋ฒ์งธ ์ธ๋ฑ์ค๊น์ง์ ์์๋ค์ ์คํธ๋ฆผ์ผ๋ก ๋ฐํ .toArray() : ๋ฉ์๋๋ฅผ ์ด์ฉํด ๋ฐฐ์ด๋ก ๋ณํํ์ฌ ๋ฐํ num2 + 1์ ํ๋ ์ด์ ? Arrays.stream(numbers, num1, num2 + 1)์์ num2๋ ์๋ฅด๊ณ ์ ํ๋ ๋ฐฐ์ด์ ๋ง์ง๋ง ์ธ๋ฑ์ค๋ฅผ ์๋ฏธํ๋ค. ํ์ง๋ง Arrays.stream(numbers, num1, num2)๋ ์ธ๋ฑ์ค 1๋ถํฐ 2.. [ํ๋ก๊ทธ๋๋จธ์ค] ์ง์๋ ์ซ์ด์ (JAVA) ๐ก ๋ฌธ์ ์ ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, n ์ดํ์ ํ์๊ฐ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ด๊ธด ๋ฐฐ์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ค๋ช : IntStream์ ์ด์ฉํ์ฌ 1๋ถํฐ n๊น์ง์ ์ ์ ์คํธ๋ฆผ ์์ฑ filter ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ํ์๋ง ๊ฑธ๋ฌ๋ toArray ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ int ๋ฐฐ์ด๋ก ๋ณํ ๐ ๋ด ๋ต์ import java.util.stream.IntStream; class Main{ public static int[] solution1(int n) { return IntStream.rangeClosed(1, n) .filter(i -> i % 2 == 1) .toArray(); } } [ํ๋ก๊ทธ๋๋จธ์ค] ์ต๋น๊ฐ ๊ตฌํ๊ธฐ (JAVA) ๐ก ๋ฌธ์ ์ต๋น๊ฐ์ ์ฃผ์ด์ง ๊ฐ ์ค์์ ๊ฐ์ฅ ์์ฃผ ๋์ค๋ ๊ฐ์ ์๋ฏธํฉ๋๋ค. ์ ์ ๋ฐฐ์ด array๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ต๋น๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ๋ฉด -1์ return ํฉ๋๋ค. ์ฌ์ฉ๋ ์๊ณ ๋ฆฌ์ฆ : 1. ์ ๋ ฅ๋ ๋ฐฐ์ด์ ์ํํ๋ฉฐ ๊ฐ ์์์ ๋ฑ์ฅ ํ์(๋น๋์)๋ฅผ Map์ ์ ์ฅํ๋ค. 2. Map์์ ์ต๋น๊ฐ์ ์ฐพ์์ ๋ฐํํ๋ค. ์ด๋, ์ต๋น๊ฐ์ด ์ฌ๋ฌ ๊ฐ์ธ ๊ฒฝ์ฐ์๋ -1์ ๋ฐํํ๋ค. ์นด์ดํธ๋ฅผ ์ํด ์ต๋น๊ฐ์ ์ฐพ์ ๋๋ ๊ฐ key-value ์์ ์ํํ๋ฉด์ ๊ฐ์ฅ ๋ง์ด ๋ฑ์ฅํ ๊ฐ์ ์ฐพ๋๋ค. ๊ฐ ์์๋ฅผ ํค(key)๋ก, ๋ฑ์ฅ ํ์๋ฅผ ๊ฐ(Value)๋ก ์ ์ฅํ์ฌ, ์ํ๊ฐ ๋๋ ํ ๊ฐ์ฅ ๋ง์ด ๋ฑ์ฅํ ์์๋ฅผ ์ฐพ์ ๋ฐํํ๋ค. ์๊ฐ ๋ณต์ก๋: O(n) - ์ ๋ ฅ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ n์ด๋ผ๊ณ .. [ํ๋ก๊ทธ๋๋จธ์ค] ์ค์๊ฐ ๊ตฌํ๊ธฐ (JAVA) ๐ก ๋ฌธ์ ์ค์๊ฐ์ ์ด๋ค ์ฃผ์ด์ง ๊ฐ๋ค์ ํฌ๊ธฐ์ ์์๋๋ก ์ ๋ ฌํ์ ๋ ๊ฐ์ฅ ์ค์์ ์์นํ๋ ๊ฐ์ ์๋ฏธํฉ๋๋ค. ์๋ฅผ ๋ค์ด 1, 2, 7, 10, 11์ ์ค์๊ฐ์ 7์ ๋๋ค. ์ ์ ๋ฐฐ์ด array๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ค์๊ฐ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ์๊ณ ๋ฆฌ์ฆ: Quick Sort ํต ์ ๋ ฌ ์๊ฐ ๋ณต์ก๋: O(n log n) ๐ ๋ด ๋ต์ class Solution { public int solution1(int[] array) { Arrays.sort(array); // ์ ๋ ฌ int median = array.length / 2; int answer = array[median]; // ์ค์๊ฐ ๋ฐํ return answer; } public int solution2(int[] ar.. [ํ๋ก๊ทธ๋๋จธ์ค] ๋ถ์์ ๋ง์ (JAVA) ๐ก ๋ฌธ์ ์ฒซ ๋ฒ์งธ ๋ถ์์ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ๋ปํ๋ numer1, denom1, ๋ ๋ฒ์งธ ๋ถ์์ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ๋ปํ๋ numer2, denom2๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๋ ๋ถ์๋ฅผ ๋ํ ๊ฐ์ ๊ธฐ์ฝ ๋ถ์๋ก ๋ํ๋์ ๋ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ์์๋๋ก ๋ด์ ๋ฐฐ์ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ๋ฌธ์ ์๊ตฌ์ฌํญ ๋ถ์: ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ๋ถ์์ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ๊ตฌํ๋ค. ๊ตฌํ ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ์ฝ ๋ถ์๋ก ๋ํ๋ธ๋ค. ๊ธฐ์ฝ ๋ถ์๋ก ๋ํ๋ธ ๊ฒฐ๊ณผ์ ๋ถ์์ ๋ถ๋ชจ๋ฅผ ์์๋๋ก ๋ฐฐ์ด์ ๋ด์ return ํ๋ค. ํด๊ฒฐ ๋ฐฉ๋ฒ: ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ๋ถ์์ ๋ถ๋ชจ(denominator)์ ์ต์๊ณต๋ฐฐ์(lcm)๋ฅผ ๊ตฌํ๋ค. ์ต์๊ณต๋ฐฐ์(lcm)๋ก ๊ฐ ๋ถ์์ ๋ถ์(numerator)๋ฅผ ๊ณฑํ ๋ค, ๋ํ์ฌ ์๋ก์ด ๋ถ์๋ฅผ ๊ตฌํ๋ค. ์๋ก์ด.. [ํ๋ก๊ทธ๋๋จธ์ค] ๋ฐฐ์ด ์์์ ๊ธธ์ด ๐ก ๋ฌธ์ ๋ฌธ์์ด ๋ฐฐ์ด strlist๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. strlist ๊ฐ ์์์ ๊ธธ์ด๋ฅผ ๋ด์ ๋ฐฐ์ด์ retrunํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๋ฌธ์ ์๊ตฌ์ฌํญ: ๋ฌธ์์ด๋ก ์ด๋ฃจ์ด์ง ๋ฆฌ์คํธ๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๊ตฌํ์ฌ, ์๋ก์ด ๋ฆฌ์คํธ์ ๋ด์ ๋ฐํํ๋ค. ํด๊ฒฐ ๋ฐฉ๋ฒ: ๊ฐ ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ len() ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค. ๋ฌธ์์ด๋ก ์ด๋ฃจ์ด์ง ๋ฆฌ์คํธ๋ฅผ ๋ฐ๋ณต๋ฌธ์ผ๋ก ์ํํ๋ฉด์ ๊ฐ ์์์ ๊ธธ์ด๋ฅผ ๊ตฌํ๊ณ , ๊ทธ ๊ฐ์ ์๋ก์ด ๋ฆฌ์คํธ์ ๋ด์์ ๋ฐํํ๋ฉด ๋๋ค. ๐ ๋ด ๋ต์ public int[] solution(String[] strlist) { // String ๋ฐฐ์ด์ ์ ๋ ฅ์ผ๋ก ๋ฐ๊ณ , int ๋ฐฐ์ด์ ๋ฐํ // ์ ๋ ฅ๊ฐ์ผ๋ก null์ด๋ ๋น ๋ฐฐ์ด์ด ๋ค์ด์ฌ ๋, solution ๋ฉ์๋๊ฐ ์์ธ๋ฅผ .. [ํ๋ก๊ทธ๋๋จธ์ค] Lv.0 ์ง์์ ํฉ (Java) ๐ก ๋ฌธ์ ์ง์์ ํฉ ๊ตฌํ๊ธฐ ๐ ๋ด ๋ต์ class Solution { public int solution(int n) { int answer = 0; for(int i=2; i ์ด์ 1 2 3 4 ๋ค์