[프로그래머스][JAVA] 겹치는 선분의 길이 (LV.0)

※ 문제 설명

선분 3개가 평행하게 놓여 있습니다. 세 선분의 시작과 끝 좌표가 [[start, end], [start, end], [start, end]] 형태로 들어있는 2차원 배열 lines가 매개변수로 주어질 때, 두 개 이상의 선분이 겹치는 부분의 길이를 return 하도록 solution 함수를 완성해보세요.

lines가 [[0, 2], [-3, -1], [-2, 1]]일 때 그림으로 나타내면 다음과 같습니다.

 

선분이 두 개 이상 겹친 곳은 [-2, -1], [0, 1]로 길이 2만큼 겹쳐있습니다.

 

※ 제한사항

• lines의 길이 = 3
• lines의 원소의 길이 = 2
• 모든 선분은 길이가 1 이상입니다.
• lines의 원소는 [a, b] 형태이며, a, b는 각각 선분의 양 끝점 입니다.     

        - -100 ≤ a < b ≤ 100

 

※ 입출력 예

lines	result
[[0, 1], [2, 5], [3, 9]]	2
[[-1, 1], [1, 3], [3, 9]]	0
[[0, 5], [3, 9], [1, 10]]	8

 

※ 입출력 예 설명

입출력 예 #1

     • 두 번째, 세 번째 선분 [2, 5], [3, 9]가 [3, 5] 구간에 겹쳐있으므로 2를 return 합니다.

입출력 예 #2

     • 겹친 선분이 없으므로 0을 return 합니다.

입출력 예 #3

     • 첫 번째와 두 번째 선분이 [3, 5] 구간에서 겹칩니다.

     • 첫 번째와 세 번째 선분 [1, 5] 구간에서 겹칩니다.

     • 두 번째와 세 번째 선분 [3, 9] 구간에서 겹칩니다.

     • 따라서 [1, 9] 구간에 두 개 이상의 선분이 겹쳐있으므로, 8을 return 합니다.

 

---

나의 풀이

import java.util.*;

class Solution {
    public int solution(int[][] lines) {
        int answer = 0;
        int len0 = lines[0][1] - lines[0][0] + 1;
        int len1 = lines[1][1] - lines[1][0] + 1;
        int len2 = lines[2][1] - lines[2][0] + 1;
        
        int[] line0 = new int[len0];
        int[] line1 = new int[len1];
        int[] line2 = new int[len2];
        
        int idx = 0;
        for(int k=lines[0][0]; k<=lines[0][1]; k++) {
            line0[idx++] = k; 
        }
        
        idx = 0;
        for(int k=lines[1][0]; k<=lines[1][1]; k++) {
            line1[idx++] = k; 
        }
        
        idx = 0;
        for(int k=lines[2][0]; k<=lines[2][1]; k++) {
            line2[idx++] = k; 
        }
        
        ArrayList<Integer> list0 = new ArrayList<>();
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        HashSet<Integer> hash = new HashSet<>();
        
        for(int i=0; i<line0.length; i++) {
            for(int j=0; j<line1.length; j++) {
                if(line0[i] == line1[j]) {
                    list1.add(line1[j]);
                    hash.add(line1[j]);
                }
            }
        }
        
        for(int i=0; i<line1.length; i++) {
            for(int j=0; j<line2.length; j++) {
                if(line1[i] == line2[j]) {
                    list2.add(line2[j]);
                    hash.add(line2[j]);
                }
            }
        }
        
        for(int i=0; i<line2.length; i++) {
            for(int j=0; j<line0.length; j++) {
                if(line2[i] == line0[j]) {
                    list0.add(line0[j]);
                    hash.add(line0[j]);
                }
            }
        }
        
        int q = 0;
        int w = 0;
        int e = 0;
        if(!list1.isEmpty()) {
            q = list1.get(list1.size()-1) - list1.get(0);
        }
        if(!list2.isEmpty()) {
            w = list2.get(list2.size()-1) - list2.get(0);
        }
        if(!list0.isEmpty()) {
            e = list0.get(list0.size()-1) - list0.get(0);
        }
        
        int r = q + w + e;
        int t = 0;
        
        int[] result = hash.stream().mapToInt(Integer::intValue).toArray();
        Arrays.sort(result);
        
        for(int i=0; i<result.length-1; i++) {
            if(result[i] + 1 != result[i+1]) {
                answer = 0;
            } else {
                t = result[result.length-1] - result[0]; 
            }
        }
        
        if(r > t) {
            answer = t;
        } else {
            answer = r;
        }
        
        return answer;
    }
}

 

다른 사람의 풀이

import java.util.HashMap;
import java.util.Map;
class Solution {
    public int solution(int[][] lines) {
        Map<Integer, Integer> map = new HashMap<>();

        for (int i=0; i<lines.length; i++) {
            int min = Math.min(lines[i][0], lines[i][1]);
            int max = Math.max(lines[i][0], lines[i][1]);

            for (int j=min; j<max; j++) {
                map.put(j, map.getOrDefault(j, 0) + 1);
            }
        }

        int answer = 0;

        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            if (entry.getValue() >= 2) {
                answer++;
            }
        }

        return answer;
    }
}