SWEA 1983. 조교의 성적 매기기

SW Expert Academy

SW Expert Academy

 

1. 내가 푼 코드 

import java.util.*;

public class Solution {
    public static void main(String[] args)  {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();

        for (int i = 1; i <= T; i++) {
            //입력 값 받기 N: 총원 K: 조회하고자 하는 학생의 index
            int N = sc.nextInt();
            int K = sc.nextInt();
            
            // hashMap -> key = 학생의 번호, value -> 총점
            // ArrayList -> index: 시험 순위, value -> 총점
            HashMap<Integer,Double> hashMap = new HashMap<>();
            ArrayList<Double> grade = new ArrayList<>();
            sc.nextLine();
            
            // 총점을 계산해서 각각 hashmap과 list에 집어넣기
            for (int j = 0; j < N; j++) {
                String s = sc.nextLine();
                double Total = 0;
                String [] strings = s.split(" ");
                Total = Integer.parseInt(strings[0])*0.35 + Integer.parseInt(strings[1])*0.45 + Integer.parseInt(strings[2])*0.2;
                hashMap.put(j+1, Total);
                grade.add(j, Total);
            }
            // list 정렬
            Collections.sort(grade, Collections.reverseOrder());
            
            // 시험 순위 추출
            int rank = grade.indexOf(hashMap.get(K));
            
            // 시험 순위에 맞는 학점 반환
            if(rank >= 1 && rank < (N/10)) {
                System.out.printf("#%d A+\n", i);
            }
            else if( rank >= (N/10) && rank < (N/10)*2){
                System.out.printf("#%d A0\n", i);
            }else if( rank >= (N/10)*2 && rank < (N/10)*3){
                System.out.printf("#%d A-\n", i);
            }else if( rank >= (N/10)*3 && rank < (N/10)*4){
                System.out.printf("#%d B+\n", i);
            }else if( rank >= (N/10)*4 && rank < (N/10)*5){
                System.out.printf("#%d B0\n", i);
            }else if( rank >= (N/10)*5 && rank < (N/10)*6){
                System.out.printf("#%d B-\n", i);
            }else if( rank >= (N/10)*6 && rank < (N/10)*7){
                System.out.printf("#%d C+\n", i);
            }else if( rank >= (N/10)*7 && rank < (N/10)*8){
                System.out.printf("#%d C0\n", i);
            }else if( rank >= (N/10)*8 && rank < (N/10)*9){
                System.out.printf("#%d C-\n", i);
            }else if( rank >= (N/10)*9 && rank < (N/10)*10){
                System.out.printf("#%d D0\n", i);
            }



        }
    }
}

내 코드는 하드 코딩이 많고 큰 길을 어렵게 돌아간 것 같다는 생각이 든다. 

다른 사람 코드를 활동점수 차감하고 보도록 하겠다.

 

2. 다른 사람 코드

import java.util.Arrays;
import java.util.Scanner;
import java.util.Comparator;

class Solution
{
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        int T;
        T=sc.nextInt();
        String[] credit = {"A+", "A0", "A-", "B+", "B0", "B-", "C+", "C0", "C-", "D0"};

        for(int test_case = 1; test_case <= T; test_case++)
        {
            int N = sc.nextInt(), K = sc.nextInt();
            Student[] student = new Student[N];

            // 학생정보 저장
            for (int i=0; i<N; i++) {
                student[i] = new Student();
                student[i].k = i+1; //k = index -> 학생 번호
                student[i].score = (sc.nextInt()*35  + sc.nextInt()*45 + sc.nextInt()*20); //score -> 총점
            }

            // 정렬
            // -> 객체 타입 배열을 정렬할 때는 2 번째 인자에 있는 Comparator(비교 연산자) 인터페이스를 구현하여
            //    우리가 객체를 비교할 기준을 정의 해줘야 한다.

            // sort 함수는 첫번째 인자의 배열을 순회하며 원소들을 비교하는데, 두번째 인자의 값에 따라
            // 비교하는 두 원소의 자리를 바꿀 것인지 아닌지를 결정한다.
            // 2번째 인자가 양수이면 둘의 자리를 바꾼다. 음수이면 바꾸지 않는다.

            // Integer.compare 함수는 두 인자의 차를 반환한다. 따라서 전자가 크면 + 반환, 후자가 크면 음수 반환이다.
            // 이렇게 되면 큰 수는 오른쪽으로 몰리므로 자동으로 오름차순이 된다.
            Arrays.sort(student, new Comparator<Student>() {
                @Override
                public int compare(Student c1, Student c2) {
                    return Integer.compare(c2.score, c1.score);
                }

            });
            // Arrays.sort(student, (c1, c2) -> Integer.compare(c1.score, c2.score()));

            int grade = 0;  // 순위를 담는 그릇
            for (int i=0; i<N; i++) {
                if (student[i].k != K) continue;    // 입력받은 학생번호와 동일한 번호의 학생의 순위를 찾아 grade에 집어넣음
                                                    // k는 학생번호이고, i는 배열이 정렬 되었기에 순위임.
                grade = i;
                break;
            }
            System.out.println("grade = " + grade);
            System.out.println("grade/(N/10) = " + grade/(N/10));
            //grade/(N/10)으로 나누는 것은 해당 학생이 1배수 즉 총원이 10명일 경우 랭크가 어딘지 알아내기 위한 것이다.
            //grade/(N/10) = 0.5 혹은 1이 1등으로 분류 되므로, 20명 중에 15등부터 16등은 8등으로 분류된다.
            System.out.println("#" + test_case + " " + credit[grade/(N/10)]);

        }
    }
}

class Student
{
    int k;
    int score;
}

클래스를 이용하여 2가지 정보를 한번에 담았다. 이때 까지 백준을 풀면서 클래스를 사용할 생각을 해보지 못했는데, 지금부터 해봐야겠다.

 

3. 새롭게 배운 것 

(1) Arrays.sort(배열이름, Comparator 인터페이스 구현)

Arrays.sort(student, new Comparator<Student>() {
    @Override
    public int compare(Student c1, Student c2) {
        return Integer.compare(c2.score, c1.score);
    }

});
// Arrays.sort(student, (c1, c2) -> Integer.compare(c1.score, c2.score()));

Arrays.sort는 원시 타입 배열에 대해서는 default로 오름차순으로 정렬해주는 함수이다. 

만약 내림차순 정렬이 필요하다면 두 번째 인자로 Collections.reverseOrder()를 적어주면 된다. 

 

하지만 Arrays.sort로 객체 배열을 정렬할 때는 문제가 된다. 무엇을 기준으로 정렬해야할지 모르기 때문이다. 

이때는 두 번째 인자로 Comparator 인터페이스를 구현 해주면 된다.

 

Comparator는 추상화 매소드 compare만 구체화 해주면 구현이 끝난다. 

compare 매소드는 인자를 2개 받는다.  

 

사실 sort 함수가 default로 오름차순으로 정리해주는 것도 두 번째인자로 비교되는 두 원소끼리의 차를  default로 받기 때문이다. 전자 - 후자의 값이 들어가고 해당 값이 양수 이면 두 원소의 자리를 바꾸고, 아니면 그대로 놔둔다. 

이게 반복되면 자연스러 큰 값들은 오른쪽으로 몰리게 된다. 

 

우리는 compare 매소드가 어떤 기준을 통해 양수와 음수를 반환하도록 만들어주면 된다. 

 

위의 함수에서는 student 객체의 score 값 차를 기준으로 양수와 음수를 반환해주었다. 

 

return에 쓰인 Integer.Compare는 왼쪽이 크면 +1, 오른쪽이 크면 -1, 같으면 0을 반환한다.