1. ๋ฌธ์ ์ค๋ช
๋ฐฐ์ด arr๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ฐฐ์ด arr์ ๊ฐ ์์๋ ์ซ์ 0๋ถํฐ 9๊น์ง๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ์ด๋, ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๋ถ ์ ๊ฑฐํ๋ ค๊ณ ํฉ๋๋ค. ๋จ, ์ ๊ฑฐ๋ ํ ๋จ์ ์๋ค์ ๋ฐํํ ๋๋ ๋ฐฐ์ด arr์ ์์๋ค์ ์์๋ฅผ ์ ์งํด์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค๋ฉด,
- arr = [1, 1, 3, 3, 0, 1, 1] ์ด๋ฉด [1, 3, 0, 1] ์ return ํฉ๋๋ค.
- arr = [4, 4, 4, 3, 3] ์ด๋ฉด [4, 3] ์ return ํฉ๋๋ค.
๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ์ ๊ฑฐํ๊ณ ๋จ์ ์๋ค์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
์ ํ์ฌํญ
- ๋ฐฐ์ด arr์ ํฌ๊ธฐ : 1,000,000 ์ดํ์ ์์ฐ์
- ๋ฐฐ์ด arr์ ์์์ ํฌ๊ธฐ : 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ 9๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์
2. ์ ๊ทผ๋ฐฉ์
2-1. ๋ฌธ์ ๋จ์ํ
์ฃผ์ด์ง ๋ฐฐ์ด์์ ์ธ์ ํ ์์๊ฐ ์ค๋ณต์ผ ๋, ์ค๋ณต๊ฐ์ ์ญ์ ํ ๋ฐฐ์ด์ ๋ฐํ๋ฐ๋ ํ๋ก๊ทธ๋จ์ ๊ตฌํํ๋ ๋ฌธ์ ์ด๋ค. ๋ช
์์ ์ผ๋ก ํ/์คํ ๋ฌธ์ ์ด๊ธฐ ๋๋ฌธ์ ์คํ์ ์ฌ์ฉํ๋ฉด ์ด๋ ต์ง ์๊ฒ ํ ์ ์๋ค.
์คํ์ LIFO ๊ตฌ์กฐ๋ก ํ ๋ง๋๋ก ํ ์ชฝ๋ง ๋ซ๋ ค ์๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ํ ์ชฝ์ผ๋ก๋ง ์ฝ์
๊ณผ ์ถ์ถ์ด ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ๋์ค์ ๋ค์ด์จ ์์๊ฐ ๋จผ์ ๋น ์ง๋ ํน์ง์ด ์๋ค.
ํ์ง๋ง ๋ง์ฝ ์ด ๋ฌธ์ ๊ฐ ์คํ์ธ ๊ฑธ ๋ชฐ๋๋ค๋ฉด?
์ฒ์์๋ '๊ฐ๋จํ๊ฒ ๋ฐฐ์ด์ set์ผ๋ก ๋ฐ๊พธ๋ ๋ฉ์๋๊ฐ ์๋ค๋ฉด set์ผ๋ก ๋ฐ๊พธ๋ฉด ๋์ง ์์๊น?' ์๊ฐํ๋ค. ์๋ํ๋ฉด set์ ์ค๋ณต์ด ํ์ฉ๋์ง ์๋ ์๋ฃํ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
ํ์ง๋ง ์๊ฐํด ๋ณด๋ set์ ์์๋ค์ ์์๋ฅผ ์ ์งํ์ง ์๊ธฐ ๋๋ฌธ์ ๊ฒฐ๊ตญ ๋ฐฐ์ด์ ๊ฐ์ด ์์๋๋ก ๋์ค์ง๋ ์์ ๋ฟ๋๋ฌ ๋ฌธ์ ๋ฅผ ์์ธํ ์ฝ์ด ๋ณด๋ฉด, ๊ฐ์ ๊ฐ์ด๋ผ๋ ์ฐ์์ผ๋ก ๋ถ์ด ์๋ ๊ฒ๋ง ์๋๋ฉด ํด๋น ์์๋ ๋ฆฌํดํ ๊ฐ์ ํฌํจ์ ํด ์ค์ผ ํ๋ค. ์ฌ์ค์ ์ธ์ ํ ๊ฐ๋ง ์๋๋ฉด ๋ฐฐ์ด๋ด ์ค๋ณต๊ฐ์ด ํ์ฉ๋๋ ๊ฒ์ผ๋ก set์ ๋ต์ด ์๋๋ค.
๊ทธ๋์ ์๊ฐํ ๊ฑด ArrayList๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด๋ค. ArrayList๋ฅผ ์ ์ธํ๊ณ , ๋ฆฌ์คํธ์ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ๊ฐ์ ๋ฃ์ด ์ฃผ๊ณ ๊ทธ ์ดํ๋ก๋ ๋ฐฐ์ด์ ์์๊ฐ ๋ฆฌ์คํธ์ ๋ง์ง๋ง ์์๋ ๋ค๋ฅผ ๋๋ง ArrayList์ ์์๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์ด๋ค.
2-2. ํด๊ฒฐ๋ฒ
Loop๋ฅผ ๋๋ฆฌ๋ฉด์ ์กฐ๊ฑด์ ๋ง๋ ๊ฐ(์ ์ ๋ฑ์ฅํ ์ ์๋ ๊ฐ)๋ง ArrayList ๋๋ Stack ์ ์ถ๊ฐ
๊ฒฐ๊ณผ๊ฐ์ int[]๋ก ๋ณํํ์ฌ ๋ฆฌํด
3. ๋ฌธ์ ํ์ด
3-1. ArrayList ๋ฅผ ํ์ฉํ์ฌ ๋ฌธ์ ํ์ด
ArrayList answer ์ ์ธ ํ, ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ answer์ ๋ด์ ์ฃผ๊ณ , ๊ทธ ์ดํ๋ถํฐ๋ arr[i]๊ฐ์ด arr[i-1]๊ณผ ๋ค๋ฅธ ๊ฒฝ์ฐ์๋ง answer์ ํด๋น ์์๋ฅผ ์ถ๊ฐํ๋ ๋ฐฉ๋ฒ์ผ๋ก ์ฝ๋๋ฅผ ์งฐ๋ค. ์ฒ์ ์๋๋ ์คํจํ๋ค. ๊ทธ ์ด์ ๋ return ํ ๋ ArrayList๋ฅผ int ํ์ ์ ๋ฐฐ์ด๋ก ๋ณํํ์ง ์๊ณ ๋ฆฌํดํ๊ธฐ ๋๋ฌธ์ด๋ค.
ArrayList answer๋ฅผ int ํ์
์ ๋ฐฐ์ด result๋ก ๋ณํํ ๋ฆฌํด(์ ๋ต์ฝ๋)
import java.util.*;
public class Solution {
public int[] solution(int []arr) {
// 1. ๋ฐฐ์ด์์ ๊ฐ์ ๋นผ์์ ๋ด์์ค ArrayList answer ์ ์ธ
ArrayList<Integer> answer = new ArrayList<>();
// 2. ๋น ArrayList์ ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ์์ ๋ด๊ธฐ
answer.add(arr[0]);
// 3. ๋ ๋ฒ์งธ ์์๋ถํฐ๋ loop ๋๋ ค๊ฐ๋ฉด์ ์กฐ๊ฑด์ ๋ง๋ ๊ฒ๋ง ๋ด๊ธฐ
// ํ์ฌ ๋ฐฐ์ด ์์๊ฐ ์ด์ ์์์ ๊ฐ์ง ์์ ๋๋ง ๋ด๊ธฐ
for (int i = 1; i < arr.length; i++) {
if(arr[i]!=arr[i-1]) {
answer.add(arr[i]);
}
}
// ArrayList๋ฅผ int[] ๋ก ๋ณํ
int[] result = new int[answer.size()];
for(int i = 0; i < answer.size(); i++) {
result[i] = answer.get(i);
}
return result;
}
}
3-2. Stack(์คํ) ๋ฅผ ํ์ฉํ์ฌ ๋ฌธ์ ํ์ด
ArrayList์ ๋ง์ฐฌ๊ฐ์ง๋ก, Loop๋ฅผ ๋๋ ค ์ฃผ๋ฉด์ stack์ ๋ฐฐ์ด ์์๋ฅผ push
โ
๋ฐฐ์ด ์ฒซ๋ฒ์งธ ์์๋ ๋ฌด์กฐ๊ฑด ์คํ์ ๋ค์ด๊ฐ์ผ ํ๋ฏ๋ก ์คํ์ด ๋น์ด์๋ค๋ฉด ์ฒซ๋ฒ์งธ ์์๋ฅผ push
โ
stack์ ์ต์๋จ์ ๊ฐ(peek)์ด arr[i]์ ๊ฐ๊ณผ ์ผ์นํ๋์ง ํ์ธ -> ์ผ์นํ์ง ์์ ๊ฒฝ์ฐ์๋ง stack์ ํด๋น ๊ฐ push
โ
stack์ ์ฌ์ด์ฆ๋งํผ Loop๋ฅผ ๋๋ ค์ ๊ฐ์ pop ํ๋ค.
โ
stack์์ popํ๊ฐ์ ์ญ์์ผ๋ก ๋ฐฐ์ด์ ๋ด์์ผ ํ๋ฏ๋ก loop์ ๋ฒ์๋ stack size()-1๋ถํฐ 0๊น์ง i--
import java.util.*;
public class Solution {
public int[] solution(int []arr) {
// 1. ๊ฒฐ๊ณผ๊ฐ ๋ด์์ค intํ ๋ฐฐ์ด
int[] answer;
// 2. ์คํ st ์ ์ธ
Stack<Integer> st = new Stack<>();
// 3. ๋ฐฐ์ด ๊ธธ์ด๊ฐ 0๋ณด๋ค ํฌ๋ฉด(์ฆ, ๋ฐฐ์ด์ ์์๊ฐ ํ๋๋ผ๋ ์๋ค๋ฉด)
// ์คํ์ ๋ฐฐ์ด์ ์ฒซ๋ฒ์งธ ๊ฐ ์ถ๊ฐ
if (arr.length > 0) {
st.add(arr[0]);
}
// 4. 2๋ฒ์งธ ์์๋ถํฐ๋ ์คํ์ ์ต์๋จ ์์์ ๊ฐ์ง ์์๋๋ง ์คํ์ ์ถ๊ฐ
for (int i = 1; i < arr.length; i++) {
if (st.peek() != arr[i]) {
st.push(arr[i]);
}
}
// 5. ๊ฒฐ๊ณผ๋ฅผ ๋ด์ ๋ฐฐ์ด answer์ ์ฌ์ด์ฆ๋ stack์ ์ฌ์ด์ฆ์ ๋์ผ
answer = new int[st.size()];
// 6. ์คํ์์ ๋จผ์ ๊บผ๋ด์จ ์์๋ฅผ
// ๋ฐฐ์ด ๋งจ ๋ค๋ถํฐ ์์ผ๋ก ์์ฐจ์ ์ผ๋ก ๋ด๊ธฐ(์ญ์์ผ๋ก ๋ด๊ธฐ)
for (int i = st.size() - 1; i >= 0; i--) {
answer[i] = st.pop();
}
return answer;
}
}
4. ๊ฐ์ ์ ํ ๋ฌธ์ (์คํ/ํ)