๋ฌธ์ ์ค๋ช
array์ ๊ฐ element ์ค divisor๋ก ๋๋์ด ๋จ์ด์ง๋ ๊ฐ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ฐฐ์ด์ ๋ฐํํ๋ ํจ์, solution์ ์์ฑํด์ฃผ์ธ์.
divisor๋ก ๋๋์ด ๋จ์ด์ง๋ element๊ฐ ํ๋๋ ์๋ค๋ฉด ๋ฐฐ์ด์ -1์ ๋ด์ ๋ฐํํ์ธ์.
- arr์ ์์ฐ์๋ฅผ ๋ด์ ๋ฐฐ์ด์ ๋๋ค.
- ์ ์ i, j์ ๋ํด i ≠ j ์ด๋ฉด arr[i] ≠ arr[j] ์ ๋๋ค.
- divisor๋ ์์ฐ์์ ๋๋ค.
- array๋ ๊ธธ์ด 1 ์ด์์ธ ๋ฐฐ์ด์ ๋๋ค.
[5, 9, 7, 10] | 5 | [5, 10] |
[2, 36, 1, 3] | 1 | [1, 2, 3, 36] |
[3,2,6] | 10 | [-1] |
์
์ถ๋ ฅ ์#1
arr์ ์์ ์ค 5๋ก ๋๋์ด ๋จ์ด์ง๋ ์์๋ 5์ 10์
๋๋ค. ๋ฐ๋ผ์ [5, 10]์ ๋ฆฌํดํฉ๋๋ค.
์
์ถ๋ ฅ ์#2
arr์ ๋ชจ๋ ์์๋ 1์ผ๋ก ๋๋์ด ๋จ์ด์ง๋๋ค. ์์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํด [1, 2, 3, 36]์ ๋ฆฌํดํฉ๋๋ค.
์
์ถ๋ ฅ ์#3
3, 2, 6์ 10์ผ๋ก ๋๋์ด ๋จ์ด์ง์ง ์์ต๋๋ค. ๋๋์ด ๋จ์ด์ง๋ ์์๊ฐ ์์ผ๋ฏ๋ก [-1]์ ๋ฆฌํดํฉ๋๋ค.
๐ฅ [๋ก์ง]
arr๋ฐฐ์ด์ ํ๋์ฉ ๋๋ฉด์ ๋๋จธ์ง๊ฐ 0์ด ๋๋ ๊ฒฝ์ฐ answer arraylist์ ๋ํด์ค
๋ฌธ์ ์ ์ ๋ต์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌํ๋ผ๊ณ ํ์ผ๋ Collections.sort()๋ฅผ ์ด์ฉํด arraylist์์ ์๋ ๊ฐ์ ์ ๋ ฌํด์ฃผ๊ณ int[]ํ์ผ๋ก ๋ณํ
๐ฅ [์ต์ข ์ฝ๋]
import java.util.*;
class Solution {
public int[] solution(int[] arr, int divisor) {
ArrayList<Integer> answer = new ArrayList<>();
for(int num : arr) {
if(num % divisor == 0) {
answer.add(num);
}
}
if(answer.isEmpty()) {
answer.add(-1);
}
//์ค๋ฆ์ฐจ์ ์ ๋ ฌ
Collections.sort(answer);
return answer.stream().mapToInt(Integer::intValue).toArray();
}
}
๐ฅ [์๊ฐ]
์ด ์ด์ ์์ถํ ์ ์๋ค๊ณ ์๊ฐํ๋๋ฐ... ๋ค๋ฅธ ์ฌ๋์ ์ฝ๋๋ฅผ ๋ณด๋๊น Arraylist์ ๋ฃ๋ ๊ณผ์ ์
int[] answer = Arrays.stream(arr).filter(factor -> factor % divisor == 0).toArray();
์ด๋ ๊ฒ ํ์ค ์์ฝํ ์ ์์๋ค..ใ ใ ์กฐ๊ฑด๋ถํฐ int[]๋ณํ๊น์ง ์๋ฒฝํ๊ฒ ํ์ค๋ก ํํํ ์ ์๋ค๋๊ฒ ์ฐธ ์ ๊ธฐํ๋ค.
์ฝํ ์ค๋น๋ฅผ ๋ณธ๊ฒฉ์ ์ผ๋ก ์์ํ์ง ์ผ๋ง ๋์ง ์์ ์ฝ๋์ ๋ฏธํกํ ์ ์ด ๋ง์ ์ ์์ต๋๋ค.
๋ถ์กฑํ ์ ํผ๋๋ฐฑ ์ฃผ์๋ฉด ์์ผ๋ก์ ํฌ์คํ ์ ๋ฐ์ํ๊ฒ ์ต๋๋ค! ๋ด์ฃผ์ ์ ์ ๋ง ๊ฐ์ฌํฉ๋๋ค :)
-budtree