문제

https://school.programmers.co.kr/learn/courses/30/lessons/147354

풀이

2차원 배열인 data 테이블과, 정렬 기준인 열 col이 주어진다.

1. 테이블을 정렬하는데 먼저 col번째 열 기준으로 오름차순 정렬을 하고, 만약 그 값이 같다면 첫 번째 행의 값을 기준으로 내림차순 정렬을 한다.

void dataSort(int[][] data, int col){
        for(int i = 0; i <N ;i++){
            for(int j = i + 1; j < N;j++){
                if(data[i][col] > data[j][col]){
                    int[] temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                }
                else if(data[i][col] == data[j][col]){
                    if(data[i][0] < data[j][0]){
                        int[] temp = data[i];
                        data[i] = data[j];
                        data[j] = temp;
                    }
                }
            }
        }
    }

처음에 람다식 사용법을 잘 몰라 2중 for문으로 조건에 맞게 테이블 정렬을 하였다.
이후 람다식을 이용한 풀이를 학습한 후 다시 작성한 코드는 다음과 같다.

람다식을 이용해 작성한 코드

Arrays.sort(data, (o1, o2)->{
            if(o1[col - 1] == o2[col - 1]){
                return Integer.compare(o2[0],o1[0]); //내림차순 정렬
            }
            return o1[col - 1] - o2[col - 1];
        });

col번째 열이 같다면 첫 번째 원소 기준으로 내림차순, 다르다면 col번째 열 기준으로 오름차순하는 코드이다.

2. 정렬이 끝났다면 i번째 행의 테이블에 대해 각 컬럼의 값을 i로 나눈 나머지들의 합을 구한다.

ArrayList<Integer> storge = new ArrayList<>();
        for(int i = row_begin - 1; i<= row_end - 1;i++){
            int sum = 0;
            for(int j = 0 ; j < M;j++){
                sum += data[i][j] % (i + 1);
            }
            storge.add(sum);
        }

3. row_begin ≤ i ≤ row_end 인 모든 S_i를 누적하여 bitwise XOR 한 값을 해시 값으로서 반환하면 된다.

2번과 3번을 람다식으로 작성한 코드

 ArrayList<Integer> storge = new ArrayList<>();
        int result = 0;
        for(int i = row_begin - 1; i<= row_end - 1;i++){
            int finalI = i + 1;
            int dataTotal = Arrays.stream(data[i])
                    .map(j -> j % finalI)
                    .sum();
            result ^= dataTotal;
        }

        return result;

2번째와 3번째 코드를 람다식으로 간단하게 작성할 수 있다.

int result = 0;
        for(int i = row_begin - 1; i<= row_end - 1;i++){
            int finalI = i + 1;
            int dataTotal = Arrays.stream(data[i])
                    .map(j -> j % finalI)
                    .sum();
            result ^= dataTotal;
        }

        return result;

비트 연산은 낯설어서 당황했지만 문제에서 나온 그대로 XOR 연산을 해주면 되는 문제였다.
또한 람다식의 사용으로 인해 코드를 반절 이상으로 줄일 수 있어 람다식의 필요성을 깨닫는 문제였다.

코드

public class Main {

    int N;
    int M;

    public int solution(int[][] data, int col, int row_begin, int row_end) {
        N = data.length;
        M = data[0].length;

        Arrays.sort(data, (o1, o2)->{
            if(o1[col - 1] == o2[col - 1]){
                return Integer.compare(o2[0],o1[0]); //내림차순 정렬
            }
            return o1[col - 1] - o2[col - 1];
        });

        int result = 0;
        for(int i = row_begin - 1; i<= row_end - 1;i++){
            int finalI = i + 1;
            int dataTotal = Arrays.stream(data[i])
                    .map(j -> j % finalI)
                    .sum();
            result ^= dataTotal;
        }

        return result;
    }
}