๐ Algorithm (29) ์ธ๋ค์ผํ ๋ฆฌ์คํธํ [๋ฐฑ์ค] ์์ธํธ์ค ๋ฌธ์ 0 (JAVA) 11866๋ฒ: ์์ธํธ์ค ๋ฌธ์ 0 ๋ฌธ์ ์์ธํธ์ค ๋ฌธ์ ๋ ๋ค์๊ณผ ๊ฐ๋ค. 1๋ฒ๋ถํฐ N๋ฒ๊น์ง N๋ช ์ ์ฌ๋์ด ์์ ์ด๋ฃจ๋ฉด์ ์์์๊ณ , ์์ ์ ์ K(≤ N)๊ฐ ์ฃผ์ด์ง๋ค. ์ด์ ์์๋๋ก K๋ฒ์งธ ์ฌ๋์ ์ ๊ฑฐํ๋ค. ํ ์ฌ๋์ด ์ ๊ฑฐ๋๋ฉด ๋จ์ ์ฌ๋๋ค๋ก ์ด๋ฃจ์ด์ง ์์ ๋ฐ๋ผ ์ด ๊ณผ์ ์ ๊ณ์ํด ๋๊ฐ๋ค. ์ด ๊ณผ์ ์ N๋ช ์ ์ฌ๋์ด ๋ชจ๋ ์ ๊ฑฐ๋ ๋๊น์ง ๊ณ์๋๋ค. ์์์ ์ฌ๋๋ค์ด ์ ๊ฑฐ๋๋ ์์๋ฅผ (N, K)-์์ธํธ์ค ์์ด์ด๋ผ๊ณ ํ๋ค. ์๋ฅผ ๋ค์ด (7, 3)-์์ธํธ์ค ์์ด์ ์ด๋ค. N๊ณผ K๊ฐ ์ฃผ์ด์ง๋ฉด (N, K)-์์ธํธ์ค ์์ด์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ N๊ณผ K๊ฐ ๋น ์นธ์ ์ฌ์ด์ ๋๊ณ ์์๋๋ก ์ฃผ์ด์ง๋ค. (1 ≤ K ≤ N ≤ 1,000) ์ถ๋ ฅ ์์ ์ ๊ฐ์ด ์์ธํธ์ค ์์ด์ ์ถ๋ ฅํ๋ค. ์์ ์ ๋ ฅ 7 3 // 7: N.. [๋ฐฑ์ค] 2828 ์ฌ๊ณผ ๋ด๊ธฐ ๊ฒ์(JAVA) 2828๋ฒ: ์ฌ๊ณผ ๋ด๊ธฐ ๊ฒ์ ๋ฌธ์ ์๊ทผ์ด๋ ์ค๋ฝ์ค์์ ๋ฐ๊ตฌ๋๋ฅผ ์ฎ๊ธฐ๋ ์ค๋๋ ๊ฒ์์ ํ๋ค. ์คํฌ๋ฆฐ์ N์นธ์ผ๋ก ๋๋์ด์ ธ ์๋ค. ์คํฌ๋ฆฐ์ ์๋์ชฝ์๋ M์นธ์ ์ฐจ์งํ๋ ๋ฐ๊ตฌ๋๊ฐ ์๋ค. (M right) { cnt += apple - right; // ์ด๋ ๊ฑฐ๋ฆฌ๋ฅผ ๋ํจ right = apple; // ๋ฐ๊ตฌ๋ ์์น ์ ๋ฐ์ดํธ left = right - M + 1; // ๋ฐ๊ตฌ๋ ๋ฒ์ ์ ๋ฐ์ดํธ } } System.out.println(cnt); } } [๋ฐฑ์ค] 2178 ๋ฏธ๋ก ํ์(JAVA) ๐ก ๋ฌธ์ N×Mํฌ๊ธฐ์ ๋ฐฐ์ด๋ก ํํ๋๋ ๋ฏธ๋ก๊ฐ ์๋ค. ๋ฏธ๋ก์์ 1์ ์ด๋ํ ์ ์๋ ์นธ์ ๋ํ๋ด๊ณ , 0์ ์ด๋ํ ์ ์๋ ์นธ์ ๋ํ๋ธ๋ค. ์ด๋ฌํ ๋ฏธ๋ก๊ฐ ์ฃผ์ด์ก์ ๋, (1, 1)์์ ์ถ๋ฐํ์ฌ (N, M)์ ์์น๋ก ์ด๋ํ ๋ ์ง๋์ผ ํ๋ ์ต์์ ์นธ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ํ ์นธ์์ ๋ค๋ฅธ ์นธ์ผ๋ก ์ด๋ํ ๋, ์๋ก ์ธ์ ํ ์นธ์ผ๋ก๋ง ์ด๋ํ ์ ์๋ค. ์์ ์์์๋ 15์นธ์ ์ง๋์ผ (N, M)์ ์์น๋ก ์ด๋ํ ์ ์๋ค. ์นธ์ ์ ๋์๋ ์์ ์์น์ ๋์ฐฉ ์์น๋ ํฌํจํ๋ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ ๋ ์ ์ N, M(2 ≤ N, M ≤ 100)์ด ์ฃผ์ด์ง๋ค. ๋ค์ N๊ฐ์ ์ค์๋ M๊ฐ์ ์ ์๋ก ๋ฏธ๋ก๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ๊ฐ์ ์๋ค์ ๋ถ์ด์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค. ์ถ๋ ฅ ์ฒซ์งธ ์ค์ ์ง๋์ผ ํ๋ ์ต์์ ์นธ ์๋ฅผ ์ถ๋ ฅํ๋ค. ํญ์ ๋์ฐฉ์.. [๋ฐฑ์ค] 1926 ๊ทธ๋ฆผ(JAVA) BOJ1926 ๊ทธ๋ฆผ 1926๋ฒ: ๊ทธ๋ฆผ ๋ฌธ์ ์ด๋ค ํฐ ๋ํ์ง์ ๊ทธ๋ฆผ์ด ๊ทธ๋ ค์ ธ ์์ ๋, ๊ทธ ๊ทธ๋ฆผ์ ๊ฐ์์, ๊ทธ ๊ทธ๋ฆผ ์ค ๋์ด๊ฐ ๊ฐ์ฅ ๋์ ๊ฒ์ ๋์ด๋ฅผ ์ถ๋ ฅํ์ฌ๋ผ. ๋จ, ๊ทธ๋ฆผ์ด๋ผ๋ ๊ฒ์ 1๋ก ์ฐ๊ฒฐ๋ ๊ฒ์ ํ ๊ทธ๋ฆผ์ด๋ผ๊ณ ์ ์ํ์. ๊ฐ๋ก๋ ์ธ๋ก๋ก ์ฐ๊ฒฐ๋ ๊ฒ์ ์ฐ๊ฒฐ์ด ๋ ๊ฒ์ด๊ณ ๋๊ฐ์ ์ผ๋ก ์ฐ๊ฒฐ์ด ๋ ๊ฒ์ ๋จ์ด์ง ๊ทธ๋ฆผ์ด๋ค. ๊ทธ๋ฆผ์ ๋์ด๋ ๊ทธ๋ฆผ์ ํฌํจ๋ 1์ ๊ฐ์์ด๋ค. ์ ๋ ฅ ์ฒซ์งธ ์ค์ ๋ํ์ง์ ์ธ๋ก ํฌ๊ธฐ n(1 ≤ n ≤ 500)๊ณผ ๊ฐ๋ก ํฌ๊ธฐ m(1 ≤ m ≤ 500)์ด ์ฐจ๋ก๋ก ์ฃผ์ด์ง๋ค. ๋ ๋ฒ์งธ ์ค๋ถํฐ n+1 ์ค ๊น์ง ๊ทธ๋ฆผ์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. (๋จ ๊ทธ๋ฆผ์ ์ ๋ณด๋ 0๊ณผ 1์ด ๊ณต๋ฐฑ์ ๋๊ณ ์ฃผ์ด์ง๋ฉฐ, 0์ ์์น ์ด ์๋ ๋ถ๋ถ, 1์ ์์น ์ด ๋ ๋ถ๋ถ์ ์๋ฏธํ๋ค) ์ถ๋ ฅ ์ฒซ์งธ ์ค์๋ ๊ทธ๋ฆผ์ ๊ฐ์, ๋์งธ ์ค์๋ ๊ทธ ์ค ๊ฐ์ฅ ๋์.. [ํ๋ก๊ทธ๋๋จธ์ค] ํ๊ฒ ๋๋ฒ(JAVA) ๋ณดํธ๋์ด ์๋ ๊ธ์ ๋๋ค. [ํ๋ก๊ทธ๋๋จธ์ค] ์ง์ ํ์ ๊ฐ์ ๐ก ๋ฌธ์ ์ ์๊ฐ ๋ด๊ธด ๋ฆฌ์คํธ num_list๊ฐ ์ฃผ์ด์ง ๋, num_list์ ์์ ์ค ์ง์์ ํ์์ ๊ฐ์๋ฅผ ๋ด์ ๋ฐฐ์ด์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ๐ ๋ด ๋ต์ public int[] solution(int[] num_list) { // ์ง์์ ๊ฐ์ ๊ตฌํ๊ธฐ long even_count = Arrays.stream(num_list) // num_list๋ฅผ ์คํธ๋ฆผ์ผ๋ก ๋ณํ .filter(num -> num % 2 == 0) // ์ง์์ธ ์์๋ง ๊ฑธ๋ฌ๋ด๊ธฐ .count(); // ๊ฑธ๋ฌ๋ธ ์์์ ๊ฐ์ ๊ตฌํ๊ธฐ // ํ์์ ๊ฐ์ ๊ตฌํ๊ธฐ long odd_count = num_list.length - even_count; // ์ ์ฒด ๊ธธ์ด์์ ์ง์์ ๊ฐ์ ๋นผ๊ธฐ // ๊ฒฐ๊ณผ ๋ฐฐ์ด ๋ง๋ค๊ธฐ int[] .. [ํ๋ก๊ทธ๋๋จธ์ค] ๋ฐฐ์ด ๋ค์ง๊ธฐ(JAVA) ๐ก ๋ฌธ์ ์ ์๊ฐ ๋ค์ด ์๋ ๋ฐฐ์ด num_list๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. num_list์ ์์์ ์์๋ฅผ ๊ฑฐ๊พธ๋ก ๋ค์ง์ ๋ฐฐ์ด์ returnํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ์๊ณ ๋ฆฌ์ฆ: . ๐ ๋ด ๋ต์ import java.util.Arrays; import java.util.stream.IntStream; class Solution { public int[] solution(int[] num_list) { int[] reverse = IntStream.rangeClosed(1, num_list.length) .map(i -> num_list[num_list.length-i]) .toArray(); return reverse; } } [ํ๋ก๊ทธ๋๋จธ์ค] ํผ์ ๋๋ ๋จน๊ธฐ (2) (JAVA) ๐ก ๋ฌธ์ ๋จธ์ฑ์ด๋ค ํผ์๊ฐ๊ฒ๋ ํผ์๋ฅผ ์ฌ์ฏ ์กฐ๊ฐ์ผ๋ก ์๋ผ ์ค๋๋ค. ํผ์๋ฅผ ๋๋ ๋จน์ ์ฌ๋์ ์ n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, n๋ช ์ด ์ฃผ๋ฌธํ ํผ์๋ฅผ ๋จ๊ธฐ์ง ์๊ณ ๋ชจ๋ ๊ฐ์ ์์ ํผ์ ์กฐ๊ฐ์ ๋จน์ด์ผ ํ๋ค๋ฉด ์ต์ ๋ช ํ์ ์์ผ์ผ ํ๋์ง๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด๋ณด์ธ์. ์๊ตฌ์ฌํญ: 6๊ฐ๋ก ๋๋ ์ง ์กฐ๊ฐ๋ค์ ์ด์ฉํ์ฌ n๋ช ์ด ๋์ผํ ์์ ์กฐ๊ฐ์ ๋จน์ ๋ ํ์ํ ํผ์๊ฐ ์ด ๋ช ํ์ธ ์ง ๊ตฌํด์ผ ํ๋ค. ์ฆ, ํผ์๋ฅผ ๋ชจ๋ ๋๊ฐ์ ์์ ์กฐ๊ฐ์ผ๋ก ๋ถํ ํด์ ๋๋ ์ค์ผ ํ๋ค๋ ๋ป์ด๋ค. ํด๊ฒฐ ๋ฐฉ๋ฒ: ํผ์ ์กฐ๊ฐ ์๋ฅผ ๋๋ ์ ์๋ ์๋ฅผ ์ฐพ์์ผ ํ๋ค. 6์ผ๋ก ๋๋์ด ๋จ์ด์ง๋ ์๋ค์ ๋ชจ๋ 6๊ฐ์ ์กฐ๊ฐ์ผ๋ก ๋๋ ์ ์๋ ์๋ค์ด๋ค. ๊ทธ๋ฆฌ๊ณ n๋ช ์ด ๋์ผํ ์์ ์กฐ๊ฐ์ ๋จน๋๋ค๋ฉด, ๋ชจ๋ ์กฐ๊ฐ์ด ๋๋ ๋จ์ด์ง๋ ์๊ฐ ๋์ด์ผ ํ๋ค. ๋ฐ.. ์ด์ 1 2 3 4 ๋ค์