프로그래머스 - 최소직사각형

 

 

내 풀이

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class P_33 {
    
    public int solution(int[][] sizes) {
        // 최소직사각형

        int a = 0; // 가로
        int b = 0; // 세로

        List<Integer> width = new ArrayList<>();
        List<Integer> height = new ArrayList<>();

        for(int i=0; i<sizes.length; i++) {
            for(int j=0; j<sizes[i].length; j++) {
                if(sizes[i][j] >= sizes[i][j+1]) {
                    width.add(sizes[i][j]);
                    height.add(sizes[i][j+1]);
                } else {
                    width.add(sizes[i][j+1]);
                    height.add(sizes[i][j]);
                }
                j++; // 다음 방으로
            }
        }

        a = Collections.max(width);
        b = Collections.max(height);

        return a * b;
    }

    public static void main(String[] args) {
        P_33 p = new P_33();
        int[][] sizes = {{60,50}, {30,70}, {60,30}, {80,40}};

        p.solution(sizes);
        System.out.println(p.solution(sizes));
    }
}

 

문제의 가장 큰 요지는 가로 세로를 바꿨을때 더 최적의 가로 세로 길이가 있냐는 것인데

이걸 단순하게 생각한다면 2차원 배열에서 각 원소에 있는 원소 배열속의 원소 2개의 수 중에서 가장 큰 수를 한쪽 리스트에 담고(가로라고 침) 나머지 작은 수들을 모아서 (세로라고 침) 분리를 해놓고

그 분리해논 값들 중에서 가장 큰 값을 각각 뽑아내면 문제가 요구하는 답을 찾을 수 있다.

 

 

다른 사람 풀이

 

class Solution {
    public int solution(int[][] sizes) {
        int max = 0;
        int min = 0;
        for (int[] size : sizes) {
            int paramMax = Math.max(size[0], size[1]);
            int paramMin = Math.min(size[0], size[1]);

            if (paramMax > max) {
                max = paramMax;
            }

            if (paramMin > min) {
                min = paramMin;
            }
        }
        return max * min;
    }
}

2차원 배열의 향상된 for문 사용법 : 배열 하나를 선언해서 돌린다.

Math의 max(), min() 메소드를 이용해서 쉽게 구할 수 있다.

중요한 점은 2차원 배열 속 1차원 배열들의 원소니까 2차원 배열 크기만큼 반복문을 돌리고 1차원 배열 원소값들의 max값, min값을 구해서 계산하면 됨.

 

 

 

import java.util.*;
class Solution {
    public int solution(int[][] sizes) {
        return Arrays.stream(sizes).reduce((a, b) -> new int[]{
                Math.max(Math.max(a[0], a[1]), Math.max(b[0], b[1])), Math.max(Math.min(a[0], a[1]), Math.min(b[0], b[1]))
        }).map(it -> it[0] * it[1]).get();
    }
}

람다를 이용해서 풀이.

마찬가지로 2차원 배열 sizes를 반복문으로 돌림.

 

stream의 reduce() 메소드 : 스트림의 원소들을 하나씩 소모해가면서 누적 계산을 수행하고 최종적으로 결과 값을 리턴 해줌.

stream의 map() 메소드 : 스트림에서 특정 연산한 결과 전체를 반환 해줌.