๋ฌธ์ ์ค๋ช
https://school.programmers.co.kr/learn/courses/30/lessons/17681
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก์ Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
๋ค์ค๋ ํ์ ํ๋ก๋๊ฐ ๋น์๊ธ์ ์จ๊ฒจ๋๋ ์ฅ์๋ฅผ ์๋ ค์ค ๋น๋ฐ์ง๋๋ฅผ ์์ ๋ฃ์๋ค. ๊ทธ๋ฐ๋ฐ ์ด ๋น๋ฐ์ง๋๋ ์ซ์๋ก ์ํธํ๋์ด ์์ด ์์น๋ฅผ ํ์ธํ๊ธฐ ์ํด์๋ ์ํธ๋ฅผ ํด๋ ํด์ผ ํ๋ค. ๋คํํ ์ง๋ ์ํธ๋ฅผ ํด๋ ํ ๋ฐฉ๋ฒ์ ์ ์ด๋์ ๋ฉ๋ชจ๋ ํจ๊ป ๋ฐ๊ฒฌํ๋ค.
- ์ง๋๋ ํ ๋ณ์ ๊ธธ์ด๊ฐ n์ธ ์ ์ฌ๊ฐํ ๋ฐฐ์ด ํํ๋ก, ๊ฐ ์นธ์ "๊ณต๋ฐฑ"(" ") ๋๋ "๋ฒฝ"("#") ๋ ์ข ๋ฅ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
- ์ ์ฒด ์ง๋๋ ๋ ์ฅ์ ์ง๋๋ฅผ ๊ฒน์ณ์ ์ป์ ์ ์๋ค. ๊ฐ๊ฐ "์ง๋ 1"๊ณผ "์ง๋ 2"๋ผ๊ณ ํ์. ์ง๋ 1 ๋๋ ์ง๋ 2 ์ค ์ด๋ ํ๋๋ผ๋ ๋ฒฝ์ธ ๋ถ๋ถ์ ์ ์ฒด ์ง๋์์๋ ๋ฒฝ์ด๋ค. ์ง๋ 1๊ณผ ์ง๋ 2์์ ๋ชจ๋ ๊ณต๋ฐฑ์ธ ๋ถ๋ถ์ ์ ์ฒด ์ง๋์์๋ ๊ณต๋ฐฑ์ด๋ค.
- "์ง๋ 1"๊ณผ "์ง๋ 2"๋ ๊ฐ๊ฐ ์ ์ ๋ฐฐ์ด๋ก ์ํธํ๋์ด ์๋ค.
- ์ํธํ๋ ๋ฐฐ์ด์ ์ง๋์ ๊ฐ ๊ฐ๋ก์ค์์ ๋ฒฝ ๋ถ๋ถ์ 1, ๊ณต๋ฐฑ ๋ถ๋ถ์ 0์ผ๋ก ๋ถํธํํ์ ๋ ์ป์ด์ง๋ ์ด์ง์์ ํด๋นํ๋ ๊ฐ์ ๋ฐฐ์ด์ด๋ค.
๋ค์ค๊ฐ ํ๋ก๋์ ๋น์๊ธ์ ์์ ๋ฃ์ ์ ์๋๋ก, ๋น๋ฐ์ง๋์ ์ํธ๋ฅผ ํด๋ ํ๋ ์์ ์ ๋์์ค ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.
์ ๋ ฅ ํ์
์ ๋ ฅ์ผ๋ก ์ง๋์ ํ ๋ณ ํฌ๊ธฐ n๊ณผ 2๊ฐ์ ์ ์ ๋ฐฐ์ด arr1, arr2๊ฐ ๋ค์ด์จ๋ค.
- 1 โฆ n โฆ 16
- arr1, arr2๋ ๊ธธ์ด n์ธ ์ ์ ๋ฐฐ์ด๋ก ์ฃผ์ด์ง๋ค.
- ์ ์ ๋ฐฐ์ด์ ๊ฐ ์์ x๋ฅผ ์ด์ง์๋ก ๋ณํํ์ ๋์ ๊ธธ์ด๋ n ์ดํ์ด๋ค. ์ฆ, 0 โฆ x โฆ 2n - 1์ ๋ง์กฑํ๋ค.
์ถ๋ ฅ ํ์
์๋์ ๋น๋ฐ์ง๋๋ฅผ ํด๋ ํ์ฌ '#', ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ์ฑ๋ ๋ฌธ์์ด ๋ฐฐ์ด๋ก ์ถ๋ ฅํ๋ผ.
์ ์ถ๋ ฅ ์์
๋งค๊ฐ๋ณ์ | ๊ฐ |
n | 5 |
arr1 | [9, 20, 28, 18, 11] |
arr2 | [30, 1, 21, 17, 28] |
์ถ๋ ฅ | ["#####", "# # #", "### #", "# ##", "#####"] |
๋งค๊ฐ๋ณ์ | ๊ฐ |
n | 6 |
arr1 | [46, 33, 33, 22, 31, 50] |
arr2 | [27, 56, 19, 14, 14, 10] |
์ถ๋ ฅ | ["######", "### #", " #### ", " ####", "### # "] |
๋ด๊ฐ ์์ฑํ ์ฝ๋
class Solution {
public String[] solution(int n, int[] arr1, int[] arr2) {
String[] answer = new String[n]; // ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ ๋ฌธ์์ด ๋ฐฐ์ด ์์ฑ
for (int i = 0; i < n; i++){ // ์ง๋ ํฌ๊ธฐ๋งํผ ๋ฐ๋ณต๋ฌธ ์คํ
String binaryString = Integer.toBinaryString(arr1[i] | arr2[i]); // arr1๊ณผ arr2์ ๊ฐ ์์๋ฅผ OR ์ฐ์ฐํ์ฌ ์ด์ง ๋ฌธ์์ด๋ก ๋ณํ
answer[i] = transform(binaryString, n); // ์ด์ง ๋ฌธ์์ด์ ์ํ๋ ์ง๋ ๋ฌธ์์ด๋ก ๋ณํ
}
return answer; // ์ ๋ต ๋ฐํ
}
// ์ด์ง ๋ฌธ์์ด์ ์ง๋ ๋ฌธ์์ด๋ก ๋ณํํ๋ ํจ์
private String transform(String binaryString, int n){
String result = " ".repeat(n - binaryString.length()) + binaryString; // ์ง๋๋ n์๋ฆฌ์ฌ์ผ ํ๋ฏ๋ก, ๊ธธ์ด๊ฐ ๋ถ์กฑํ๋ฉด ์์ ๊ณต๋ฐฑ์ ์ถ๊ฐ
// '1'์ ๋ฒฝ(#)์ผ๋ก, '0'์ ๊ณต๋ฐฑ( )์ผ๋ก ์นํ
result = result.replaceAll("1", "#");
result = result.replaceAll("0", " ");
return result; // ๊ฒฐ๊ณผ ๋ฐํ
}
}
๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ์๊ฐํ ๋ฐฉํฅ
์ด ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ๋จผ์ ๋ ๊ฐ์ ์ ์ ๋ฐฐ์ด arr1, arr2๋ฅผ ๋นํธ ๋จ์๋ก OR ์ฐ์ฐํ์ฌ ๊ฒน์ณ์ง ์ง๋๋ฅผ ๋ง๋๋ ๋ฐฉ์์ผ๋ก ์ ๊ทผํ๋ค. ๊ฐ ์ง๋๋ ์ด์ง์๋ก ํํ๋๋ฉฐ, ๋ฒฝ์ด ์๋ ๋ถ๋ถ์ 1, ์๋ ๋ถ๋ถ์ 0์ผ๋ก ๋ํ๋๋ค. ๋ ์ง๋๋ฅผ ๊ฒน์ณ ํ๋๋ผ๋ ๋ฒฝ์ด ์๋ ๊ฒฝ์ฐ ํด๋น ์์น๋ ์ต์ข ์ง๋์์ ๋ฒฝ์ผ๋ก ํ์ํด์ผ ํ๊ธฐ ๋๋ฌธ์, ๊ฐ ์์น๋ฅผ OR ์ฐ์ฐ(|)์ผ๋ก ์ฒ๋ฆฌํ๋ฉด ๋๋ค.
OR ์ฐ์ฐ์ ํตํด ๋์จ ๊ฒฐ๊ณผ๋ฅผ Integer.toBinaryString()์ ์ฌ์ฉํด ์ด์ง ๋ฌธ์์ด๋ก ๋ณํํ๋ค. ์ด๋, ๋ณํ๋ ์ด์ง ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ ์ง๋์ ํฌ๊ธฐ n๋ณด๋ค ์งง์ ์ ์๊ธฐ ๋๋ฌธ์, ์์ชฝ์ " ".repeat(n - binaryString.length())๋ฅผ ์ฌ์ฉํด ๊ธธ์ด๋ฅผ ๋ง์ถฐ์ฃผ์๋ค. ๊ทธ ํ replaceAll() ๋ฉ์๋๋ฅผ ์ด์ฉํด ์ด์ง ๋ฌธ์์ด์ 1์ ๋ฒฝ(#)์ผ๋ก, 0์ ๊ณต๋ฐฑ( )์ผ๋ก ๋ฐ๊ฟ์ค์ผ๋ก์จ ์ฌ๋์ด ๋ณผ ์ ์๋ ํํ์ ์ง๋๋ก ๋ณํํ๋ค.
์ด์ง ๋ฌธ์์ด์ ์ฒ๋ฆฌํ๋ ๋ก์ง์ ๋ณ๋์ transform ๋ฉ์๋๋ก ๋ถ๋ฆฌํ์ฌ ์ฝ๋์ ๊ฐ๋ ์ฑ์ ๋์๊ณ , ๊ฐ ๋จ๊ณ๋ฅผ ๋ช ํํ ๋๋์ด ๋ฌธ์ ์๊ตฌ ์ฌํญ์ ์ถฉ์คํ ๊ตฌํํ๋ ค๊ณ ํ๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ๊ฐ ํ๋ง๋ค ์์ฑ๋ ๋ฌธ์์ด์ answer ๋ฐฐ์ด์ ๋ด์ ๋ฐํํ๋๋ก ๊ตฌํํ์๋ค.
'๐งฉ ํ๋ก๊ทธ๋๋จธ์ค > ๐ต ์๊ณ ๋ฆฌ์ฆ ํ์ด(Java)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค/Java] ์ถ์ต ์ ์ (0) | 2025.07.21 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค/Java] ์์ ๋์งํ (2) | 2025.07.17 |
[ํ๋ก๊ทธ๋๋จธ์ค/Java] ์์ด ๋๋ง์๊ธฐ (2) | 2025.07.16 |
[ํ๋ก๊ทธ๋๋จธ์ค/Java] ๋ฉ๋ฆฌ๋ฐ๊ธฐ (1) | 2025.07.15 |
[ํ๋ก๊ทธ๋๋จธ์ค/Java] N๊ฐ์ ์ต์๊ณต๋ฐฐ์ (2) | 2025.07.14 |