๐ Algorithm/ํ๋ก๊ทธ๋๋จธ์ค
โฐ๋ฌธ์ ์์ธ์๋ถํด๋ ์ด๋ค ์๋ฅผ ์์๋ค์ ๊ณฑ์ผ๋ก ํํํ๋ ๊ฒ์
๋๋ค. ์๋ฅผ ๋ค์ด 12๋ฅผ ์์ธ์ ๋ถํดํ๋ฉด 2 * 2 * 3 ์ผ๋ก ๋ํ๋ผ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ 12์ ์์ธ์๋ 2์ 3์
๋๋ค. ์์ฐ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋ n์ ์์ธ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ๋ด์ ๋ฐฐ์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ์ฌํญ - 2 ≤ n ≤ 10,000 ์
์ถ๋ ฅ ์ n result 12 [2, 3] 17 [17] 420 [2, 3, 5, 7] ์
์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1 12๋ฅผ ์์ธ์๋ถํดํ๋ฉด 2 * 2 * 3 ์
๋๋ค. ๋ฐ๋ผ์ [2, 3]์ returnํฉ๋๋ค. ์
์ถ๋ ฅ ์ #2 17์ ์์์
๋๋ค. ๋ฐ๋ผ์ [17]์ return ํด์ผ ํฉ๋๋ค. ์
์ถ๋ ฅ ์ #3 420์ ์์ธ์๋ถํดํ๋ฉด 2 * 2 * 3 * 5 * ..
๐ Algorithm/ํ๋ก๊ทธ๋๋จธ์ค
โฐ๋ฌธ์ ์ ์ ๋ฐฐ์ด num_list์ ์ ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. num_list๋ฅผ ๋ค์ ์ค๋ช
๊ณผ ๊ฐ์ด 2์ฐจ์ ๋ฐฐ์ด๋ก ๋ฐ๊ฟ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. num_list๊ฐ [1, 2, 3, 4, 5, 6, 7, 8] ๋ก ๊ธธ์ด๊ฐ 8์ด๊ณ n์ด 2์ด๋ฏ๋ก num_list๋ฅผ 2 * 4 ๋ฐฐ์ด๋ก ๋ค์๊ณผ ๊ฐ์ด ๋ณ๊ฒฝํฉ๋๋ค. 2์ฐจ์์ผ๋ก ๋ฐ๊ฟ ๋์๋ num_list์ ์์๋ค์ ์์์๋ถํฐ n๊ฐ์ฉ ๋๋ 2์ฐจ์ ๋ฐฐ์ด๋ก ๋ณ๊ฒฝํฉ๋๋ค. num_list n result [1, 2, 3, 4, 5, 6, 7, 8] 2 [[1,2], [3,4], [5,6], [7,8]] ์ ํ์ฌํญ num_list์ ๊ธธ์ด๋ n์ ๋ฐฐ ์๊ฐ์
๋๋ค. 0 ≤ num_list์ ๊ธธ์ด ≤ 150 2 ≤ n
๐ Programming/Java
์๋ฐ์์ ๋ฐฐ์ด์ ๋ณต์ฌํ๋ ๋ฐฉ๋ฒ์ ์ฌ๋ฌ๊ฐ์ง๊ฐ ์๋ค. for ๋ while ๊ฐ์ ๋ฐ๋ณต๋ฌธ์ ํ์ฉํ์ฌ ์ง์ ๊ฐ์ ํ๋์ฉ ๋ฃ์ด์ฃผ๋ ๋ฐฉ๋ฒ๋ ์๊ณ , Arrays์ ๋ฉ์๋๋ฅผ ํ์ฉํ๋ ๋ฐฉ๋ฒ๋ ์๋ค. ์ฌ์ฉ๋ฐฉ๋ฒ์ ๋งค์ฐ ๊ฐ๋จํ๋ค. copyOf() copyOf ๋ฉ์๋๋ Arrays.copyOf( ๋ณต์ฌํ ๋ฐฐ์ด, ๋ณต์ฌํ ๋ฐฐ์ด์ ํฌ๊ธฐ ); ๋ก ์ฌ์ฉํ๋ฉด ๋๋ค. ์ดํดํ๊ธฐ ์ฝ๊ฒ ๋ฐ๋ก ์ฝ๋๋ฅผ ๋ณด์. import java.util.Arrays; public class copyOfTest { public static void main(String[] args) { int[] arr1 = {1, 2, 3, 4, 5}; int[] arr2 = Arrays.copyOf(arr1, arr1.length); for(int i=0; i ๋ฃ๊ณ ์ํ๋ ์ด ๋ฒ..
๐ Algorithm/ํ๋ก๊ทธ๋๋จธ์ค
โฐ๋ฌธ์ ์์ด์์ a, e, i, o, u ๋ค์ฏ ๊ฐ์ง ์ํ๋ฒณ์ ๋ชจ์์ผ๋ก ๋ถ๋ฅํฉ๋๋ค. ๋ฌธ์์ด my_string์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋ ๋ชจ์์ ์ ๊ฑฐํ ๋ฌธ์์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์ ํ์ฌํญ - my_string์ ์๋ฌธ์์ ๊ณต๋ฐฑ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. - 1 ≤ my_string์ ๊ธธ์ด ≤ 1,000 ์
์ถ๋ ฅ ์ my_string result "bus" "bs" "nice to meet you" "nc t mt y" ์
์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1 "bus"์์ ๋ชจ์ u๋ฅผ ์ ๊ฑฐํ "bs"๋ฅผ returnํฉ๋๋ค. ์
์ถ๋ ฅ ์ #1 "nice to meet you"์์ ๋ชจ์ i, o, e, u๋ฅผ ๋ชจ๋ ์ ๊ฑฐํ "nc t mt y"๋ฅผ returnํฉ๋๋ค. ๐กํ์ด โญ์ ์ถ ์ฝ๋ class Sol..
๐ Algorithm/ํ๋ก๊ทธ๋๋จธ์ค
โฐ๋ฌธ์ iํฉํ ๋ฆฌ์ผ (i!)์ 1๋ถํฐ i๊น์ง ์ ์์ ๊ณฑ์ ์๋ฏธํฉ๋๋ค. ์๋ฅผ๋ค์ด 5! = 5 * 4 * 3 * 2 * 1 = 120 ์
๋๋ค. ์ ์ n์ด ์ฃผ์ด์ง ๋ ๋ค์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฐ์ฅ ํฐ ์ ์ i๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. → i! ≤ n ์ ํ์ฌํญ - 0
๐ Algorithm/ํ๋ก๊ทธ๋๋จธ์ค
๋ฌธ์ ํผ๋ณด๋์น ์๋ F(0) = 0, F(1) = 1์ผ ๋, 1 ์ด์์ n์ ๋ํ์ฌ F(n) = F(n-1) + F(n-2) ๊ฐ ์ ์ฉ๋๋ ์ ์
๋๋ค. ์๋ฅผ๋ค์ด F(2) = F(0) + F(1) = 0 + 1 = 1 F(3) = F(1) + F(2) = 1 + 1 = 2 F(4) = F(2) + F(3) = 1 + 2 = 3 F(5) = F(3) + F(4) = 2 + 3 = 5 ์ ๊ฐ์ด ์ด์ด์ง๋๋ค. 2 ์ด์์ n์ด ์
๋ ฅ๋์์ ๋, n๋ฒ์งธ ํผ๋ณด๋์น ์๋ฅผ 1234567์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํด ์ฃผ์ธ์. ์ ํ ์ฌํญ - n์ 2 ์ด์ 100,000 ์ดํ์ธ ์์ฐ์์
๋๋ค. ์
์ถ๋ ฅ ์ n return 3 2 5 5 ์
์ถ๋ ฅ ์ ์ค๋ช
ํผ๋ณด๋์น์๋ 0๋ฒ์งธ๋ถํฐ 0, 1, 1, 2, 3, 5..