[프로그래머스 / 코딩테스트 입문 / 자바(JAVA)] 평행

문제 링크 : https://school.programmers.co.kr/learn/courses/30/lessons/120875

프로그래머스

 

▼ ▼ ▼

정답 풀이로 바로 가기

▲ ▲ ▲

 

내 풀이 1

로직

지금 보니 좀 바보같은.. 로직이다.
점 4개가 있을 때, 아래 표시해둔 선분들의 길이들끼리 같은 길이를 가지고 있으면 평행한 선이 있다고 생각했다.
(파란 삼각형의 밑변, 높이가 서로 같거나, 노란 삼각형의 밑변, 높이가 서로 같거나...)

 

코드

import java.util.*;
class Solution {
    public int solution(int[][] dots) {
        int[] Y = new int[dots.length];
        int[] X = new int[dots.length];

        for(int i=0; i<dots.length; i++) {
            X[i] = dots[i][1];
            Y[i] = dots[i][0];
        }

        Arrays.sort(Y);
        Arrays.sort(X);


        boolean y = (Y[3] - Y[1] == Y[2] - Y[0]);
        boolean x = (X[3] - X[2] == X[1] - X[0]);

        boolean a = x && y;

        y = (Y[1] - Y[0] == Y[3] - Y[2]);
        x = (X[3] - X[1] == X[2] - X[0]);

        boolean b = x && y;

        if(a||b) return 1;

        return 0;
    }
}

 

채점 결과

정확성  테스트
테스트 1 〉    실패 (0.36ms, 72.2MB)
테스트 2 〉    통과 (0.47ms, 73.4MB)
테스트 3 〉    통과 (0.36ms, 65.2MB)
테스트 4 〉    통과 (0.38ms, 74.7MB)
테스트 5 〉    통과 (0.37ms, 74.8MB)
테스트 6 〉    통과 (0.40ms, 73.9MB)
테스트 7 〉    통과 (0.32ms, 69.7MB)
테스트 8 〉    통과 (0.50ms, 82.6MB)
테스트 9 〉    통과 (0.45ms, 71.8MB)
테스트 10 〉    실패 (0.37ms, 80.1MB)
테스트 11 〉    통과 (0.54ms, 75.9MB)
테스트 12 〉    통과 (0.52ms, 74MB)
테스트 13 〉    통과 (0.33ms, 72.2MB)
테스트 14 〉    통과 (0.39ms, 71MB)
테스트 15 〉    통과 (0.40ms, 79MB)
테스트 16 〉    통과 (0.37ms, 71MB)
테스트 17 〉    통과 (0.35ms, 72.1MB)
채점 결과
정확성: 88.2
합계: 88.2 / 100.0

 

 

내 풀이 2

로직

선분을 이었을 때의 직선의 방향을 생각하지 않았다는 것을 깨달았다.
같은 값이라도 음수냐 양수냐에 따라서 방향이 달라진다.
직선의 기울기 공식을 참고해서, 다시 식을 세우자.

직선의 기울기 공식 = y값의 증가량 / x값의 증가량

하지만 틀렸다. 기울기를 직접 구하지 않고 각각 증가량 간의 비교만 했기 때문에... 

 

코드

import java.util.*;
class Solution {
    public int solution(int[][] dots) {
        // 기울기 = y의 증가량 / x의 증가량
        // 1. 점 1-2, 3-4 의 기울기 비교

        // 1-1. 점1 - 점2의 직선 기울기
        int aY = dots[0][0] - dots[1][0]; // y의 증가량
        int aX = dots[0][1] - dots[1][1]; // x의 증가량
        // 1-2. 점3 - 점4의 직선 기울기
        int bY = dots[2][0] - dots[3][0];
        int bX = dots[2][1] - dots[3][1];

        System.out.println(aY + " " + bY);
        System.out.println(aX + " " + bX);

        boolean A = (aY == bY) && (aX == bX);

        // 2. 점 1-4, 2-3 의 기울기 비교
        // 2-1. 점1 - 점4의 직선 기울기
        aY = dots[0][0] - dots[3][0];
        aX = dots[0][1] - dots[3][1];
        // 2-2. 점2 - 점3의 직선 기울기
        bY = dots[1][0] - dots[2][0];
        bX = dots[1][1] - dots[2][1];

        System.out.println(aY + " " + bY);
        System.out.println(aX + " " + bX);

        boolean B = (aY == bY) && (aX == bX);

        // 3. 1-3 2-4의 기울기 비교
        // 3-1. 점1 - 점3의 직선 기울기
        aY = dots[0][0] - dots[2][0];
        aX = dots[0][1] - dots[2][1];
        // 3-2. 점2 - 점4의 직선 기울기
        bY = dots[1][0] - dots[3][0];
        bX = dots[1][1] - dots[3][1];

        System.out.println(aY + " " + bY);
        System.out.println(aX + " " + bX);

        boolean C = (aY == bY) && (aX == bX);

        if(A||B||C) return 1;

        return 0;
    }
}

 

채점결과

정확성  테스트
테스트 1 〉    실패 (8.30ms, 74.9MB)
테스트 2 〉    통과 (9.69ms, 79.1MB)
테스트 3 〉    통과 (11.61ms, 75.8MB)
테스트 4 〉    통과 (9.98ms, 79.3MB)
테스트 5 〉    실패 (8.97ms, 78.3MB)
테스트 6 〉    통과 (9.27ms, 85.4MB)
테스트 7 〉    통과 (14.51ms, 88.8MB)
테스트 8 〉    통과 (10.76ms, 74.2MB)
테스트 9 〉    통과 (10.83ms, 79.8MB)
테스트 10 〉    실패 (8.69ms, 79MB)
테스트 11 〉    통과 (8.42ms, 73.4MB)
테스트 12 〉    통과 (8.13ms, 78.1MB)
테스트 13 〉    통과 (10.79ms, 78.9MB)
테스트 14 〉    통과 (10.22ms, 73.5MB)
테스트 15 〉    통과 (8.14ms, 77.6MB)
테스트 16 〉    통과 (8.12ms, 73.1MB)
테스트 17 〉    통과 (8.12ms, 78.2MB)
채점 결과
정확성: 82.4
합계: 82.4 / 100.0

 

 

 

내 풀이 3

로직

아래와 같은 경우, y값의 증가량과 x값의 증가량이 서로 달라도
기울기가 같기 때문에 1을 return 해야한다.
하지만 내 풀이2의 코드로는 증가량만을 서로 비교하기 때문에 1을 return할 수 없다.

 

증가량이 아닌, 기울기를 직접 비교해야한다.

직선의 기울기 공식 = y값의 증가량 / x값의 증가량

코드

import java.util.*;
class Solution {
    public int solution(int[][] dots) {
        // 기울기 = y의 증가량 / x의 증가량
        // 1. 점 1-2, 3-4 의 기울기 비교

        // 1-1. 점1 - 점2의 직선 기울기
        double aY = dots[0][0] - dots[1][0]; // y의 증가량
        double aX = dots[0][1] - dots[1][1]; // x의 증가량
        // 1-2. 점3 - 점4의 직선 기울기
        double bY = dots[2][0] - dots[3][0];
        double bX = dots[2][1] - dots[3][1];

        boolean A = (aY/aX == bY/bX);

        // 2. 점 1-4, 2-3 의 기울기 비교
        // 2-1. 점1 - 점4의 직선 기울기
        aY = dots[0][0] - dots[3][0];
        aX = dots[0][1] - dots[3][1];
        // 2-2. 점2 - 점3의 직선 기울기
        bY = dots[1][0] - dots[2][0];
        bX = dots[1][1] - dots[2][1];

        boolean B = (aY/aX == bY/bX);

        // 3. 1-3 2-4의 기울기 비교
        // 3-1. 점1 - 점3의 직선 기울기
        aY = dots[0][0] - dots[2][0];
        aX = dots[0][1] - dots[2][1];
        // 3-2. 점2 - 점4의 직선 기울기
        bY = dots[1][0] - dots[3][0];
        bX = dots[1][1] - dots[3][1];

        boolean C = (aY/aX == bY/bX);

        if(A||B||C) return 1;

        return 0;
    }
}

채점 결과

정확성  테스트
테스트 1 〉    통과 (0.03ms, 74.4MB)
테스트 2 〉    통과 (0.02ms, 73.8MB)
테스트 3 〉    통과 (0.02ms, 71.8MB)
테스트 4 〉    통과 (0.03ms, 75.6MB)
테스트 5 〉    통과 (0.02ms, 66.6MB)
테스트 6 〉    통과 (0.02ms, 72.9MB)
테스트 7 〉    통과 (0.03ms, 75MB)
테스트 8 〉    통과 (0.02ms, 80.4MB)
테스트 9 〉    통과 (0.03ms, 77.8MB)
테스트 10 〉    통과 (0.02ms, 75.2MB)
테스트 11 〉    통과 (0.03ms, 77.9MB)
테스트 12 〉    통과 (0.02ms, 74.2MB)
테스트 13 〉    통과 (0.02ms, 71.6MB)
테스트 14 〉    통과 (0.03ms, 75.8MB)
테스트 15 〉    통과 (0.02ms, 77.2MB)
테스트 16 〉    통과 (0.01ms, 73.8MB)
테스트 17 〉    통과 (0.03ms, 76.1MB)
채점 결과
정확성: 100.0
합계: 100.0 / 100.0