๐ฅDAY +5
https://programmers.co.kr/learn/courses/30/lessons/67256?language=java
> ๋ฌธ์ ๋ฅผ ๋ ๋ณด๊ณ ์ถ๋ค๋ฉด ๋๋ณด๊ธฐ ํด๋ฆญ!
๋ฌธ์ ์ค๋ช
์ค๋งํธํฐ ์ ํ ํคํจ๋์ ๊ฐ ์นธ์ ๋ค์๊ณผ ๊ฐ์ด ์ซ์๋ค์ด ์ ํ ์์ต๋๋ค.
์ด ์ ํ ํคํจ๋์์ ์ผ์๊ณผ ์ค๋ฅธ์์ ์์ง์๊ฐ๋ฝ๋ง์ ์ด์ฉํด์ ์ซ์๋ง์ ์
๋ ฅํ๋ ค๊ณ ํฉ๋๋ค.
๋งจ ์ฒ์ ์ผ์ ์์ง์๊ฐ๋ฝ์ * ํคํจ๋์ ์ค๋ฅธ์ ์์ง์๊ฐ๋ฝ์ # ํคํจ๋ ์์น์์ ์์ํ๋ฉฐ, ์์ง์๊ฐ๋ฝ์ ์ฌ์ฉํ๋ ๊ท์น์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ์์ง์๊ฐ๋ฝ์ ์ํ์ข์ฐ 4๊ฐ์ง ๋ฐฉํฅ์ผ๋ก๋ง ์ด๋ํ ์ ์์ผ๋ฉฐ ํคํจ๋ ์ด๋ ํ ์นธ์ ๊ฑฐ๋ฆฌ๋ก 1์ ํด๋นํฉ๋๋ค.
- ์ผ์ชฝ ์ด์ 3๊ฐ์ ์ซ์ 1, 4, 7์ ์ ๋ ฅํ ๋๋ ์ผ์ ์์ง์๊ฐ๋ฝ์ ์ฌ์ฉํฉ๋๋ค.
- ์ค๋ฅธ์ชฝ ์ด์ 3๊ฐ์ ์ซ์ 3, 6, 9๋ฅผ ์ ๋ ฅํ ๋๋ ์ค๋ฅธ์ ์์ง์๊ฐ๋ฝ์ ์ฌ์ฉํฉ๋๋ค.
- ๊ฐ์ด๋ฐ ์ด์ 4๊ฐ์ ์ซ์ 2, 5, 8, 0์ ์
๋ ฅํ ๋๋ ๋ ์์ง์๊ฐ๋ฝ์ ํ์ฌ ํคํจ๋์ ์์น์์ ๋ ๊ฐ๊น์ด ์์ง์๊ฐ๋ฝ์ ์ฌ์ฉํฉ๋๋ค.
4-1. ๋ง์ฝ ๋ ์์ง์๊ฐ๋ฝ์ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ๋ค๋ฉด, ์ค๋ฅธ์์ก์ด๋ ์ค๋ฅธ์ ์์ง์๊ฐ๋ฝ, ์ผ์์ก์ด๋ ์ผ์ ์์ง์๊ฐ๋ฝ์ ์ฌ์ฉํฉ๋๋ค.
์์๋๋ก ๋๋ฅผ ๋ฒํธ๊ฐ ๋ด๊ธด ๋ฐฐ์ด numbers, ์ผ์์ก์ด์ธ์ง ์ค๋ฅธ์์ก์ด์ธ ์ง๋ฅผ ๋ํ๋ด๋ ๋ฌธ์์ด hand๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ๊ฐ ๋ฒํธ๋ฅผ ๋๋ฅธ ์์ง์๊ฐ๋ฝ์ด ์ผ์์ธ ์ง ์ค๋ฅธ์์ธ ์ง๋ฅผ ๋ํ๋ด๋ ์ฐ์๋ ๋ฌธ์์ด ํํ๋ก return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
[์ ํ์ฌํญ]- numbers ๋ฐฐ์ด์ ํฌ๊ธฐ๋ 1 ์ด์ 1,000 ์ดํ์ ๋๋ค.
- numbers ๋ฐฐ์ด ์์์ ๊ฐ์ 0 ์ด์ 9 ์ดํ์ธ ์ ์์ ๋๋ค.
- hand๋ "left" ๋๋ "right" ์
๋๋ค.
- "left"๋ ์ผ์์ก์ด, "right"๋ ์ค๋ฅธ์์ก์ด๋ฅผ ์๋ฏธํฉ๋๋ค.
- ์ผ์ ์์ง์๊ฐ๋ฝ์ ์ฌ์ฉํ ๊ฒฝ์ฐ๋ L, ์ค๋ฅธ์ ์์ง์๊ฐ๋ฝ์ ์ฌ์ฉํ ๊ฒฝ์ฐ๋ R์ ์์๋๋ก ์ด์ด๋ถ์ฌ ๋ฌธ์์ด ํํ๋ก return ํด์ฃผ์ธ์.
์ ์ถ๋ ฅ ์numbershandresult
[1, 3, 4, 5, 8, 2, 1, 4, 5, 9, 5] | "right" | "LRLLLRLLRRL" |
[7, 0, 8, 2, 8, 3, 1, 5, 7, 6, 2] | "left" | "LRLLRRLLLRR" |
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0] | "right" | "LLRLLRLLRL" |
์ ์ถ๋ ฅ ์ #1
์์๋๋ก ๋๋ฌ์ผ ํ ๋ฒํธ๊ฐ [1, 3, 4, 5, 8, 2, 1, 4, 5, 9, 5]์ด๊ณ , ์ค๋ฅธ์์ก์ด์ ๋๋ค.
์ผ์ ์์น์ค๋ฅธ์ ์์น๋๋ฌ์ผ ํ ์ซ์์ฌ์ฉํ ์์ค๋ช* | # | 1 | L | 1์ ์ผ์์ผ๋ก ๋๋ฆ ๋๋ค. |
1 | # | 3 | R | 3์ ์ค๋ฅธ์์ผ๋ก ๋๋ฆ ๋๋ค. |
1 | 3 | 4 | L | 4๋ ์ผ์์ผ๋ก ๋๋ฆ ๋๋ค. |
4 | 3 | 5 | L | ์ผ์ ๊ฑฐ๋ฆฌ๋ 1, ์ค๋ฅธ์ ๊ฑฐ๋ฆฌ๋ 2์ด๋ฏ๋ก ์ผ์์ผ๋ก 5๋ฅผ ๋๋ฆ ๋๋ค. |
5 | 3 | 8 | L | ์ผ์ ๊ฑฐ๋ฆฌ๋ 1, ์ค๋ฅธ์ ๊ฑฐ๋ฆฌ๋ 3์ด๋ฏ๋ก ์ผ์์ผ๋ก 8์ ๋๋ฆ ๋๋ค. |
8 | 3 | 2 | R | ์ผ์ ๊ฑฐ๋ฆฌ๋ 2, ์ค๋ฅธ์ ๊ฑฐ๋ฆฌ๋ 1์ด๋ฏ๋ก ์ค๋ฅธ์์ผ๋ก 2๋ฅผ ๋๋ฆ ๋๋ค. |
8 | 2 | 1 | L | 1์ ์ผ์์ผ๋ก ๋๋ฆ ๋๋ค. |
1 | 2 | 4 | L | 4๋ ์ผ์์ผ๋ก ๋๋ฆ ๋๋ค. |
4 | 2 | 5 | R | ์ผ์ ๊ฑฐ๋ฆฌ์ ์ค๋ฅธ์ ๊ฑฐ๋ฆฌ๊ฐ 1๋ก ๊ฐ์ผ๋ฏ๋ก, ์ค๋ฅธ์์ผ๋ก 5๋ฅผ ๋๋ฆ ๋๋ค. |
4 | 5 | 9 | R | 9๋ ์ค๋ฅธ์์ผ๋ก ๋๋ฆ ๋๋ค. |
4 | 9 | 5 | L | ์ผ์ ๊ฑฐ๋ฆฌ๋ 1, ์ค๋ฅธ์ ๊ฑฐ๋ฆฌ๋ 2์ด๋ฏ๋ก ์ผ์์ผ๋ก 5๋ฅผ ๋๋ฆ ๋๋ค. |
5 | 9 | - | - |
๋ฐ๋ผ์ "LRLLLRLLRRL"๋ฅผ return ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
์ผ์์ก์ด๊ฐ [7, 0, 8, 2, 8, 3, 1, 5, 7, 6, 2]๋ฅผ ์์๋๋ก ๋๋ฅด๋ฉด ์ฌ์ฉํ ์์ "LRLLRRLLLRR"์ด ๋ฉ๋๋ค.
์ ์ถ๋ ฅ ์ #3
์ค๋ฅธ์์ก์ด๊ฐ [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]๋ฅผ ์์๋๋ก ๋๋ฅด๋ฉด ์ฌ์ฉํ ์์ "LLRLLRLLRL"์ด ๋ฉ๋๋ค.
๐ฅ [๋ก์ง]
1.
3,6,9์ด๋ฉด ๋ฌด์กฐ๊ฑด ์ค๋ฅธ์์ผ๋ก, 1,4,7์ด๋ฉด ๋ฌด์กฐ๊ฑด ์ผ์์ผ๋ก ํฐ์นํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ถ๋ฆฌํด์ฃผ๊ธฐ
2.
2,5,8,0์ผ ๊ฒฝ์ฐ์ ๊ฑฐ๋ฆฌ์ ๋ฐ๋ผ ์ค๋ฅธ์, ์ผ์์ ์ ํํด์ผ ํจ.
1์ (0,0) 2๋ (0,1) ... 9๋ (2,2)์ ๊ฐ์ด ๊ฐ์ ํ๊ณผ ์ด๋ก ๋ฐฐ์นํด ๊ทธ ์ฌ์ด์ ๊ธธ์ด๋ฅผ ์ธก์ ํ๋ ๋ฐฉ์์ ์ด์ฉํ์.
(์์น์ *์ (3,0), #์ (3,2)๋ก ์ง์ ํด์ฃผ์์)
3.
์ผ์์์์ ๊ธธ์ด, ์ค๋ฅธ์์์์ ๊ธธ์ด๋ฅผ ๊ฐ๊ฐ ์ธก์ ํ๊ณ ๋ ์งง์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ฐ์ง๋ ์๊ฐ๋ฝ์ ์ ํ.
(๊ฐ์๊ฒฝ์ฐ ์ค๋ฅธ์์ก์ด์ธ์ง, ์ผ์์ก์ด์ธ์ง ํ๋จ)
* ๊ฑฐ๋ฆฌ์ ์ธก์ ๊ธฐ์ค : ํ์ ์ฐจ์ด, ์ด์ ์ฐจ์ด๋ฅผ ๊ฐ๊ฐ ๋ํ ๊ฐ.
๐ฅ [์ต์ข ์ฝ๋]
import java.util.Arrays;
import java.lang.Math;
class Solution {
public String solution(int[] numbers, String hand) {
String answer = "";
int[] right = {3,6,9};
int[] left = {1,4,7};
int[] mid = {2,5,8,0};
int lhand = -1;
int rhand = -1;
int[] lNum = new int[2];
int[] rNum = new int[2];
for(int num : numbers) {
//right,left์ ํด๋นํ๋ ๊ฒฝ์ฐ ๊ทธ ์๊ฐ๋ฝ์ผ๋ก ํด๋ฆญ
if(Arrays.toString(right).contains(Integer.toString(num))) {
answer += "R";
rhand = num;
} else if(Arrays.toString(left).contains(Integer.toString(num))) {
answer += "L";
lhand = num;
} else { //mid์ธ ๊ฒฝ์ฐ ๋ฐฐ์ดํํด์ ๊ธธ์ด ์ธก์ ..
if(lhand == -1) {
lNum[0] = 3;
lNum[1] = 0;
} else if(lhand == 0) {
lNum[0] = 3;
lNum[1] = 1;
} else {
lNum[0] = (lhand-1)/3;
lNum[1] = (lhand-1)%3;
}
if(rhand == -1) {
rNum[0] = 3;
rNum[1] = 2;
} else if(rhand == 0) {
rNum[0] = 3;
rNum[1] = 1;
} else {
rNum[0] = (rhand-1)/3;
rNum[1] = (rhand-1)%3;
}
int[] nums = new int[2];
nums[0] = (num == 0)? 3 : (num-1) / 3;
nums[1] = (num == 0)? 1 : (num-1) % 3;
int lLength = Math.abs(nums[0]-lNum[0]) + Math.abs(nums[1]-lNum[1]);
int rLength = Math.abs(nums[0]-rNum[0]) + Math.abs(nums[1]-rNum[1]);
if(lLength > rLength) {
answer += "R";
rhand = num;
} else if(lLength < rLength) {
answer += "L";
lhand = num;
} else {
if(hand.equals("right")) {
answer += "R";
rhand = num;
} else {
answer += "L";
lhand = num;
}
}
}
}
return answer;
}
}
๐ฅ [์๊ฐ]
๋๋์ผ ์ฝ์ง ์ ๋ฌธ๊ฐ..
๊ฑฐ๋ฆฌ ์ธก์ ๊น์ง๋ ๋น ๋ฅด๊ฒ ์๊ฐ์ ํ๋๋ฐ ์ง์ง ๋๊ฐ์ ์ ๊ธธ์ด๋ฅผ ๊ณ์ฐํ๋ ๋ก์ง์ ์ง๋ฒ๋ฆฌ๋ ๋ฐ๋์ ํ ์คํธ์ฝ๋ 13~20๋ฒ๊น์ง ์ซ ์๋ฌ๊ฐ ๋ด๋ค. ๋ญ๊ฐ ๋ฌธ์ ์ธ์ง ๋ชฐ๋ผ์ ํ์ฐธ ํค๋ฉ๋ค๊ฐ ์ง๋ฌธํ๊ธฐ์์ ์์ธ ์ฌ๋ก๋ฅผ ์๋ ค์ค์ ๊ฒจ์ฐ ๋ฌธ์ ๋ฅผ ์ฐพ์๋๋ฐ
์ ๊ธฐ์กด์ฝ๋์์์ ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ์ค์ ์๊ฒ.
int lLength = ((int)Math.pow(nums[0]-lNum[0],2)) + ((int)Math.pow(nums[1]-lNum[1],2));
int rLength = ((int)Math.pow(nums[0]-rNum[0],2)) + ((int)Math.pow(nums[1]-rNum[1],2));
์ผ์ชฝ์์ด 7์ด๊ณ ์ค๋ฅธ์ชฝ์์ด 0์ ์์นํด์๋ ๊ฒฝ์ฐ ๊ธฐ์กด์ ๋ก์ง๋๋ก๋ผ๋ฉด ๋๊ฐ์ ์ ๊ธธ์ด๋ฅผ ์ธก์ ํ๊ฒ ๋๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ์ผ์์ผ๋ก ํด๋ฆญ์ ํด์ผ ํฉ๋๋ค.
๊ทธ๋ฐ๋ฐ ๋ฌธ์ ์์ ์ ์ํ๋ ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ์ค์ ์ํ์ข์ฐ ํ์นธ์ฉ์ ์ด๋์ 1๋ก ์ธก์ ํ๊ธฐ ๋๋ฌธ์ ์ผ์์ 3, ์ค๋ฅธ์์ 3์ผ๋ก ๊ฐ์ ๊ฑฐ๋ฆฌ๋ก ์ทจ๊ธ์ ํ๊ฑฐ๋ ์! ์ด๊ฒ ์ ๊ฐ ๋์น ํ์ ์ด์์.
๋์ค ๋ฑ ์์ ํด์ฃผ๋๊น ๋ฐ๋ก ๋น ๋ฅด๊ฒ ์ฑ๊ณต์ด ๋์ด๋ฒ๋ ค์.. ํ๋ฌดํ๋ ๋ฌธ์ ์์ต๋๋ค ใ ใ
์์ฆ ๋ค์ด์ ๋๋ผ๋ ์ ์ ์ฝ๋ฉํ ์คํธ์์์ ์๊ฐ 85%๋ ์๋ฒฝํ ๋ก์ง์ง๊ธฐ, 15%๋ ์ฝ๋ฉํ๊ธฐ ์ธ๊ฒ ๊ฐ์์.
์๊ฐ ๋ญ๋น๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํด ๊ฐ๋งํ ์์์ ์๊ฐํ๋ ์๊ฐ์ ๋๋ ค๋ด์ผ๊ฒ ์ด์!
์ฝํ ์ค๋น๋ฅผ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํ์ง ์ผ๋ง ๋์ง ์์ ์ฝ๋์ ๋ฏธํกํ ์ ์ด ๋ง์ ์ ์์ต๋๋ค.
๋ถ์กฑํ ์ ํผ๋๋ฐฑ ์ฃผ์๋ฉด ์์ผ๋ก์ ํฌ์คํ ์ ๋ฐ์ํ๊ฒ ์ต๋๋ค! ๋ด์ฃผ์ ์ ์ ๋ง ๊ฐ์ฌํฉ๋๋ค :)
-zelkova