Java - 정렬 (2)

정렬 메소드 sort()

Arrays.sort()

java.util.Arrays에 포함되어있는 메소드로 import 시켜야 한다. 
오름차순 정렬시 그냥 Arrays.sort(배열이름)
내림차순 정렬시

import java.util.Arrays;
import java.util.Collections;
public class Sort{
	public static void main(String[] args){
		String[] str = {"5","4","3","2","1"};
		Arrays.sort(str,Collections.reverseOrder());
	}
}

위에 예시처럼 배열을 정렬한다. 

Collections.sort()

클래스의 객체를 정렬하는 메소드로 배열의 원소를 정렬할 때는 Arrays.sort()메소드를 사용하지만,
ArrayList의 원소를 정렬하기 위해서는 Collections 클래스의 sort()메소드를 이용해서 정렬할 수 있다. 

ArrayList<String> list = new ArrayList<String>();
list.add("5");
list.add("4");
list.add("3");
Collections.sort(list);//오름차순
Collections.reverse(list);//내림차순

Comparable 인터페이스 

다른 기준으로 정렬하고 싶을 때 사용한다. 
Comparable 인터페이스에는 단 하나의 메소드가 존재하는데, 바로 그것은 ! 
compareTo() 메소드이다. 
 
compareTo()메소드란 ? 
정렬 기준을 결정하는 메소드 (정렬을 위해서는 compareTo()메소드가 정의되어 있어야 한다. 직접 오버라이딩해야한다는 뜻)
즉, Comparable 인터페이스를 구현하지 않아 compareTo()메소드를 갖고 있지 않은 클래스의 경우 natural ordering이 존재하지 않아 정렬이 불가능하다. 
compareTo() 메소드를 갖는 Comparable인터페이스를 구현한 클래스 타입으로 객체의 클래스 타입을 변경해주면
compareTo() 메서드 오버라이딩해서 사용하면된다.

• Comparable 인터페이스를 구현하는 클래스는 compareTo(T o) 메소드를 오버라이딩 해야함
• compareTo(T o) 는 파라미터로 객체를 전달받는다.
  • 현재 객체가 파라미터로 받아온 객체보다 우선순위가 높다면 양수반환

class Student {
  private String name;
  private int score;

  public Student(Stinrg name, int score){
    this.name = name;
    this.score = score;
  }
}

사용자 정의 클래스 Student가 위처럼 정의되었다고 가정해보자 
ArrayList를 활용해서 더미데이터를 넣어주고, Collections.sort()를 통해 정렬을 시도하면 에러가 발생한다. 

ArrayList<Student> students = new ArrayList<>();
students.add(new Student("홍길동"), 60);
students.add(new Student("이하온"), 80);
students.add(new Student("김철수"), 40);

students.stream()
		 .sorted()
	     .collect(Collectors.toList())
         .forEach(System.out::println);

에러 발생의 이유 ? 
-> " 정렬기준"을 알 수 없기 때문이다. 
객체를 비교할 수 있도록 Comparator와 Comparable를 인터페이스로 사용하여 직접 사용자 정의 클래스 객체들의 정렬기준을 
compareTo()를 오버라이딩해서 구현해주어야 한다.

public class Student implements Comparable<Student>{
    private String name;
    private int score;

    public Student(String name, int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public int compareTo(Student ohter) {
        return this.score - this.other;
        // return this.other - this.score;
    }

    // ...
}

compareTo()를 오버라이딩하여 정수형 반환값을 리턴하도록했다.
이때 compareTo는 작성자가 원하는 방식으로 구현이 가능하다.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
class Student implements Comparable{
    int score;
    String name;
 
    Student (int score, String name) {
        this.score = score;
        this.name = name;
    }
 
    public int compareTo(Object obj){
        Student s2 = (Student)obj;
 
        return s2.score - this.score;
    }
 
    public String toString(){
        return score + "," + name;
    }
}
 
public class ComparableTest {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student(20,"lee"));
        list.add(new Student(15,"choi"));
        list.add(new Student(9,"kim"));
        list.add(new Student(12,"park"));
 
        Collections.sort(list);
 
        for (Student s : list) {
            System.out.println(s.score);
        }
    }
}

하지만 CompareTo 메소드는 이미 정의 되어 있는 클래스를 상속받아서 다시 정의를 해야하는 비효율적인 면이 있다.
만약 Compareble에 의해서 이름으로 정렬기준이 잡혀있다면 sort()메서드는 사전순으로 정렬을 하게 된다.
그런데 이름으로 정렬의 기준을 잡아놓은 것을 나중에라도 사용할 수 있기 때문에 남겨놓고 새로운 정렬기준을 하나 더 쓰고 싶을 경우가 있고 계속 정렬기준을 바꿀 상황이 존재하는데 이럴 때마다 compareTo 메소드를 재정의하기는 번거롭다.
 
이럴 때 사용하는 것이 Comparator 인터페이스이다.

Comparator 인터페이스 

이미 Comparable 인터페이스를 구현한 클래스의 리스트를 다른 기준으로 정렬하고 싶을 때, Comparator를 사용한다.
sort() 메소드를 호출할 때, Comparator 인터페이스를 구현한 클래스를 인자로 넘기고, Comparator 인터페이스에 존재하는 compare() 메소드를 오버라이딩 함으로써 정렬 기준을 정의한다.

public class StudentComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2){
        return s1.getScore() - s2.getScore();
    }
}

Comparator를 구현하는 클래스를 별도로 생성해주면 된다.
Comparable과 마찬가지로 대상의 타입을 제네릭으로 전달하면된다.

List<Student> students = new ArrayList<>();
students.add(new Student("김철수", 60));
students.add(new Student("나영희", 80));
students.add(new Student("다람쥐", 40));

Collections.sort(students, new StudentComparator());

 
Collections.sort()로 정렬시, 두 객체를 정렬해줄 제 3자로 Comparator 구현 클래스 객체를 함께 인자로 넘겨주면 정렬이 수행된다.
Comparator는 Comparable와 달리 다양한 메소드 기능을 여럿 제공한다.
 

1. reversed

정렬 규칙의 반대로 정렬

Collections.sort(students, new StudentComparator().reversed());

 

2.Collections.reverseOrder,Collections.naturalOrder

내림차순/오름차순 정렬

Collections.sort(students, Collections.reverseOrder(new StudentComparator()));
students.sort(new StudentComparator());

 

3. nullsFirst,nullsLast

Null을 맨앞에 정렬/맨 뒤에 정렬

Collections.sort(students, Comparator.nullsFirst(new StudentComparator()));
Collections.sort(students, Comparator.nullsLast(new StudentComparator()));

Comparator와 Comparable의 차이점은 "비교대상"

• Comparator의 경우 두 매개변수 객체를 비교
• Comparable는 자기자신과 매개변수 객체를 비교 

// Comparator, Comparable 실제 구현코드
public interface Comparable<T> {
  public int compareTo(T o);
}

public interface Comparator<T> {
  int compare(T o1, To2);
  // ...
}

문제

백준 2776 : 암기왕

https://www.acmicpc.net/problem/2776
 
연종이는 암기왕 호소인이다. 
처음엔 냅다 풀어본 결과 시간 초과가 낫다. 

public class Main {
    public static int T, N, M;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
////////////////////////////////입력////////////////////////////////
        T = Integer.parseInt(st.nextToken()); // 테스트 케이스의 개수

        for (int t = 0; t < T; t++) {

            st = new StringTokenizer(br.readLine());
            N = Integer.parseInt(st.nextToken()); // 수첩1에 적어놓은 정수 갯수
            int[] arr1 = new int[N]; // 수첩1


            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < N; i++) {
                arr1[i]= Integer.parseInt(st.nextToken());
            }
            st = new StringTokenizer(br.readLine());
            M = Integer.parseInt(st.nextToken()); // 수첩2에 적어놓은 정수 갯수
            int[] arr2 = new int[M]; // 수첩1

            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < M; i++) {
                arr2[i]= Integer.parseInt(st.nextToken());
            }
////////////////////////////////풀이////////////////////////////////

            int index = 0; //수첩1의 인덱스
            int i = 0; //수첩2의 인덱스
            while (i<M){
                if(arr2[i]==arr1[index]){
                    System.out.println(1);
                    i++;
                }
                index++;
                if(index>=N){
                    System.out.println(0);
                    index = 0; //인덱스 초기화
                    i++;
                }
            }
        }
    }
}

테스트 케이스 갯수를 입력받아서 for 문 돌리고 수첩1 배열을 만들어준다음 포인터로 그냥 다 비교해버리는 아주 직관적인 ^^ 코드다. 
여기서부터 생각이란걸 했던 것같다. 
수첩1과 수첩2가 같은 숫자가 있다면 1을 출력이 되어야 하니까,,, 
중복이 되냐 아니냐 를 물어보고 있으니까 HashSet을 이용해야겠다고 생각했다. 
 

public class Main {
    public static int T, N, M;
    public static HashSet<Integer> answer = new HashSet<Integer>();
    public static StringBuilder sb = new StringBuilder();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
////////////////////////////////입력////////////////////////////////
        T = Integer.parseInt(st.nextToken()); // 테스트 케이스의 개수

        for (int t = 0; t < T; t++) {

            st = new StringTokenizer(br.readLine());
            N = Integer.parseInt(st.nextToken()); // 수첩1에 적어놓은 정수 갯수
            int[] arr1 = new int[N]; // 수첩1


            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < N; i++) {
                answer.add(Integer.parseInt(st.nextToken()));
            }
            st = new StringTokenizer(br.readLine());
            M = Integer.parseInt(st.nextToken()); // 수첩2에 적어놓은 정수 갯수
////////////////////////////////풀이////////////////////////////////
            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < M; i++) {
                sb.append(answer.contains(Integer.parseInt(st.nextToken()))?1:0).append("\n");
            }//삼항연산자로 answer set에 있는지 확인 있으면 1 엇으면 0 append
////////////////////////////////정답////////////////////////////////
            System.out.println(sb);

        }
    }
}

 
처음 수첩1의 정수들을 answer HashSet에 넣어주고, 수첩2의 정수를 입력받으면 answer에 값이 있는지 확인 후 
값이 있으면 1을 없으면 0을 append 해주는 삼항연산자를 for문안에 넣었다. 
그리고 마지막 for문에서 append 받은 배열을 출력시켰는데 틀렸다고 나왔다.,., 
아 장난 그만해 ~ 맞잖아 다 나와~~ 다 들켯어 너네 
 

public class Main {
    public static int T, N, M;
    public static HashSet<Integer> answer = new HashSet<Integer>();
    public static StringBuilder sb = new StringBuilder();

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");
////////////////////////////////입력////////////////////////////////
        T = Integer.parseInt(st.nextToken()); // 테스트 케이스의 개수

        for (int t = 0; t < T; t++) {
            sb = new StringBuilder();
            st = new StringTokenizer(br.readLine());
            N = Integer.parseInt(st.nextToken()); // 수첩1에 적어놓은 정수 갯수

            answer = new HashSet<>();
            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < N; i++) {
                answer.add(Integer.parseInt(st.nextToken()));
            }
            st = new StringTokenizer(br.readLine());
            M = Integer.parseInt(st.nextToken()); // 수첩2에 적어놓은 정수 갯수
////////////////////////////////풀이////////////////////////////////
            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < M; i++) {
                sb.append(answer.contains(Integer.parseInt(st.nextToken()))?1:0).append("\n");
            }//삼항연산자로 answer set에 있는지 확인 있으면 1 엇으면 0 append

            ////////////////////////////////정답////////////////////////////////
            System.out.print(sb);
        }
    }
}

숨은 그림찾기 
append할때 줄바꿈해서 넣어놓고 뿌듯해했으면서 출력하면서 println으로 또 줄바꿈해서 하핫 
println -> print로 바꿨다. 
 

백준 1026 : 보물

https://www.acmicpc.net/problem/1026
 
B는 그대로 두고 A만 정렬
B를 재배열 하지 말라고는 했지만
B배열을 내림차순으로 정리하고 A를 오름차순으로 하면 답은 알아서 나오잖어,.,.,?
그래도되나
 

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


        int N = Integer.parseInt(br.readLine());
        int answer = 0;
        int[] arrA = new int[N];
        int[] arrB = new int[N];

        String[] tokens = br.readLine().split(" ");
        for (int i = 0; i < N; i++) {
            arrA[i] = Integer.parseInt(tokens[i]);
        }

        tokens = br.readLine().split(" ");
        for (int i = 0; i < arrB.length; i++) {
            arrB[i] = Integer.parseInt(tokens[i]);
        }

        Arrays.sort(arrA); //기본 -> 오름차순으로 정렬 (작은것부터)
        Arrays.sort(arrB);

        for (int i=0;i<N;i++){
            answer += arrA[i]*arrB[N-(i+1)];
        }


        ////////////////////// 정답 ////////////////////////////////////////////
        System.out.println(answer);
    }
}

 
오잉 정답처리 됐다. 
이러면 근데 안될것같아서 다른 사람들 풀이를 찾아봤다. 
 

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        int answer = 0;
        int[] arrA = new int[N];
        int[] arrB = new int[N];

        String[] tokens = br.readLine().split(" ");
        for (int i = 0; i < N; i++) {
            arrA[i] = Integer.parseInt(tokens[i]);
        }

        tokens = br.readLine().split(" ");
        for (int i = 0; i < arrB.length; i++) {
            arrB[i] = Integer.parseInt(tokens[i]);
        }

        Arrays.sort(arrA); // 기본 -> 오름차순으로 정렬 (작은 것부터)

        // arrB를 내림차순으로 정렬
        Arrays.sort(arrB, Collections.reverseOrder());

        for (int i = 0; i < N; i++) {
            answer += arrA[i] * arrB[i];
        }

        System.out.println(answer);
    }
}

이거나 저거나,,, 
 

백준 11497 : 통나무 건너뛰기 

https://www.acmicpc.net/problem/11497
남규 그라문 안돼
N개의 통나무 , 인접한 통나무의 높이 차가 최소가 되도록
난이도는 두 통나무 간의 높이의 차의 최댓값으로 결정된다.
 
{2,4,5,7,9}
{2,9,7,4,5} → 가장 첫 통나무랑 마지막 통나무도 인접해있음,
난이도는 2-9 = 7이다.
2 5 9 7 4
T : 테스트 케이스 갯수
N : 통나무 갯수
L : 통나무 높이 배열
높이 차의 절댓값의 최댓값이 최소가 되도록
13 10 12 11 10 11 12
10 10 11 11 12 12 13 → 1
10 11 12 13 12 11 10
10 10 11 13 12 12 11 → 2
10 10 12 13 12 11 11
2 9 7 4 5
2 4 5 7 9
2 5 9 7 4
하나씩 띄어서 앞에 두고 (홀수 번째 ) 짝수번째는 거꾸로
 

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int T = Integer.parseInt(br.readLine());
        int answer = 0;
        for (int i=0;i<T;i++){
            int N = Integer.parseInt(br.readLine());

        int[] arrA = new int[N];
        ArrayList<Integer> arrB = new ArrayList<>();

        String[] tokens = br.readLine().split(" ");
        for (int j = 0; j < N; j++) {
            arrA[j] = Integer.parseInt(tokens[j]);
        }


        Arrays.sort(arrA); //기본 -> 오름차순으로 정렬 (작은것부터)

            // 홀수 번째 인덱스에는 arrA의 짝수 번째 원소를, 짝수 번째 인덱스에는 arrA의 홀수 번째 원소를 거꾸로 채운다.
            for (int j = 0; j < N; j += 2) {
                arrB.add(arrA[j]);
            }
            for (int j = N - 1; j >= 1; j -= 2) {
                arrB.add(arrA[j]);
            }

            // 정렬하고 난 이후 난이도 구하기
            int maxNumber = 0;

            for (int j = 1; j < N; j++) {
                maxNumber = Math.max(maxNumber, arrB.get(j) - arrB.get(j - 1));
            }


            ////////////////////// 정답 ////////////////////////////////////////////
        System.out.println(maxNumber);
    }

    }
}

왜 틀려 
아 원형이어서 처음과 끝 차이를 안구해줘서 그런가 하고 
최소 난이도 값을 처음과 끝 차이로 초기화해줬는데 
 

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int T = Integer.parseInt(br.readLine());
        int answer = 0;
        for (int i=0;i<T;i++){
            int N = Integer.parseInt(br.readLine());

        int[] arrA = new int[N];
        ArrayList<Integer> arrB = new ArrayList<>();

        String[] tokens = br.readLine().split(" ");
        for (int j = 0; j < N; j++) {
            arrA[j] = Integer.parseInt(tokens[j]);
        }


        Arrays.sort(arrA); //기본 -> 오름차순으로 정렬 (작은것부터)

            // 홀수 번째 인덱스에는 arrA의 짝수 번째 원소를, 짝수 번째 인덱스에는 arrA의 홀수 번째 원소를 거꾸로 채운다.
            for (int j = 0; j < N; j += 2) {
                arrB.add(arrA[j]);
            }
            for (int j = N - 1; j >= 1; j -= 2) {
                arrB.add(arrA[j]);
            }

            // 정렬하고 난 이후 난이도 구하기
            int maxNumber = arrB.get(N-1)-arrB.get(0);

            for (int j = 1; j < N; j++) {
                maxNumber = Math.max(maxNumber, arrB.get(j) - arrB.get(j - 1));
            }


            ////////////////////// 정답 ////////////////////////////////////////////
        System.out.println(maxNumber);
    }

    }
}

그래도 안됨 우띠!
아 무조건 왜 양수가 나올거라고 생각했지,, 절댓값을 안씌워줘서 그런거였다. 
그리고 다른 풀이도 찾아봤는데 포인터를 사용해서 통과된 케이스도 있었다. 
그래서 내 풀이랑 합쳤다. ㅇ _ < 
 

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int T = Integer.parseInt(br.readLine());
        int answer = 0;
        for (int i=0;i<T;i++){
            int N = Integer.parseInt(br.readLine());

        int[] arrA = new int[N];
        int[] arrB = new int[N];


        String[] tokens = br.readLine().split(" ");
        for (int j = 0; j < N; j++) {
            arrA[j] = Integer.parseInt(tokens[j]);
        }


        Arrays.sort(arrA); //기본 -> 오름차순으로 정렬 (작은것부터)

            // 홀수 번째 인덱스에는 arrA의 짝수 번째 원소를, 짝수 번째 인덱스에는 arrA의 홀수 번째 원소를 거꾸로 채운다.
            int left =0;
            int right = N-1;
            for (int j = 0; j < N; j++) {
                if (j%2==0){
                    //홀수 인덱스라면
                    arrB[left] = arrA[j];
                    left++;
                }else{
                    //짝수 인덱스라면
                    arrB[right] = arrA[j];
                    right--;
                }
            }


            // 정렬하고 난 이후 난이도 구하기
            int maxNumber =  Math.abs(arrB[0]-arrB[N-1]);

            for (int j = 1; j < N; j++) {
                maxNumber = Math.max(maxNumber, Math.abs(arrB[j] - arrB[j - 1]));
            }


            ////////////////////// 정답 ////////////////////////////////////////////
        System.out.println(maxNumber);
    }

    }
}

 
짜란
 

백준 17225 : 세훈이의 선물가게 

https://www.acmicpc.net/problem/17225
상민이 A초, 지수 B초
동시에 선물을 가져올때 짬이있는 상민이가 먼저 가져오고 지수가 그 뒤의 선물을 가져온다
상민이가 포장한 선물의 갯수
상미이가 포장한 선물들의 번호를 오름차순으로 공백으로 구분하여 출력
지수가 포장한 선물의 갯수 출력
지수가 포장한 선물들의 번호를 오름차순으로 공백으로 구분하여 출력

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        ArrayList<Integer> arrA = new ArrayList<>();
        ArrayList<Integer> arrB = new ArrayList<>();

        String[] tokens = br.readLine().split(" ");
        int A = Integer.parseInt(tokens[0]); //성민이가 포장시 걸리는 시간
        int B = Integer.parseInt(tokens[1]); //지수가 포장시 걸리는 시간
        int N = Integer.parseInt(tokens[2]); //손님 수
        int tempAtime = 0;
        int tempBtime = 0;
        int allCustomerNumber = 0;
            for (int i = 0; i < N; i++) {
                tokens = br.readLine().split(" ");
                int timing = Integer.parseInt(tokens[0]);
                String color = tokens[1];
                int customer = Integer.parseInt(tokens[2]);
                allCustomerNumber+=customer;

                if (color.equals("B")){
                    //성민
                    if(timing>tempAtime){
                        tempAtime = timing;
                    }
                    for (int j =0;j<customer;j++){
                        arrA.add(tempAtime);
                        tempAtime +=A;
                    }

                }else{
                    //지수
                    if(timing>tempBtime){
                        tempBtime = timing;
                    }
                    for (int j =0;j<customer;j++){
                        arrB.add(tempBtime);
                        tempBtime +=B;
                    }
                }

            }
        ArrayList<Integer> resultA = new ArrayList<>();
        ArrayList<Integer> resultB = new ArrayList<>();
        int aPointer =0;
        int bPointer =0;

        for (int i = 1; i<=allCustomerNumber;i++){

            if(aPointer==arrA.size()){
                resultB.add(i);
                bPointer++;
                continue;
            }
            if(bPointer==arrB.size()){
                resultA.add(i);
                aPointer++;
                continue;
            }
            if(arrA.get(aPointer)<arrB.get(bPointer)){
                resultA.add(i);
                aPointer++;
            }else if (arrA.get(aPointer)>arrB.get(bPointer)){
                resultB.add(i);
                bPointer++;
            } else{
                //같을때
                resultA.add(i);
                i++;
                resultB.add(i);
                aPointer++;
                bPointer++;
            }
        }




            ////////////////////// 정답 ////////////////////////////////////////////
        System.out.println(resultA.size());
        for (int i=0;i<resultA.size();i++){
            System.out.print(resultA.get(i)+" ");
        }
        System.out.println("\n"+resultB.size());
        for (int i=0;i<resultB.size();i++){
            System.out.print(resultB.get(i)+" ");
        }


    }
}

선물 포장 시간을 기준으로 풀었는데 서브 태스크 하나는 통과했으나 서브태스크 2를 못맞췄다.,.,,,,, 
좀 더 이건 생각을 해봐야할 것 같다. 
 

백준 20300 : 서강 근육맨 

https://www.acmicpc.net/problem/20300
운동기구를 최대 두 개
𝑀의 최솟값을 구해보자.
운동기구를 두 개 사용해서 PT를 받을 때의 근손실 정도 = 두 운동기구의 근손실 정도의 합이다.
N : 운동기구 갯수
근손실 정도를 나타내는 정수가 주어짐
ex:
5
1 2 3 4 5
sol :
5
N이 홀 수 일때 오름차순으로 정렬하고 마지막 수가 M의 최솟값
N이 짝 수 일때,
6
1 2 3 4 5 6
젤 작은수랑 젤 큰수 합이 M의 최솟값
1 2 3 4 5 5

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


        int N = Integer.parseInt(br.readLine()); //운동기구 갯수
        int[] M = new int[N];

        String[] tokens = br.readLine().split(" ");
        for (int i = 0; i < N; i++) {
            M[i] = Integer.parseInt(tokens[i]);
        }
        Arrays.sort(M); //정렬
        ////////////////////// 정답 ////////////////////////////////////////////
        if(N%2==0){
            //운동기구의 갯수가 짝수일때
            System.out.println(M[0]+M[N-1]);
        }else{
            //운동기구의 갯수가 홀수 일때
            System.out.println(M[N-1]);
        }

    }
}

런타임 에러가 낫다. 음,,? 왜 
했는데 범위때문에 int가 아니라 long 타입으로 해야하는구나,,, 낯선데,,? 하고 고쳐서 런타임 에러는 고쳤으나,, 
 

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


        int N = Integer.parseInt(br.readLine()); //운동기구 갯수
        long[] M = new long[N];

        String[] tokens = br.readLine().split(" ");
        for (int i = 0; i < N; i++) {
            M[i] = Long.parseLong(tokens[i]);
        }
        Arrays.sort(M); //정렬
        ////////////////////// 정답 ////////////////////////////////////////////
        if(N%2==0){
            //운동기구의 갯수가 짝수일때
            System.out.println(M[0]+M[N-1]);
        }else{
            //운동기구의 갯수가 홀수 일때
            System.out.println(M[N-1]);
        }

    }
}

왜 틀렸나면,,,, 1 3 5 7 7 로 나오면 답이 틀리니까,,. 
중복되는 수를 예상못하고 냅다 정렬 ~ 이러고있으니까 틀리지 에이긍,,

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


        int N = Integer.parseInt(br.readLine()); //운동기구 갯수
        long[] M = new long[N];

        String[] tokens = br.readLine().split(" ");
        for (int i = 0; i < N; i++) {
            M[i] = Long.parseLong(tokens[i]);
        }
        Arrays.sort(M); //정렬
        ////////////////////// 정답 ////////////////////////////////////////////
        long max;
        if(N%2==0){
            //운동기구의 갯수가 짝수일때
            max = M[0]+M[N-1];
        }else{
            //운동기구의 갯수가 홀수 일때
            max = M[N-1];
            for(int i=0;i<N/2;i++){
                if(max<M[i]+M[N-1-(i+1)]){
                    max = M[i]+M[N-1-(i+1)];
                }
            }
        }
        System.out.println(max);

    }
}

홀수 경우만 생각해준 결과 
1 2 3 4 5 5 면 틀리잖아 또,,,, 
 

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));


        int N = Integer.parseInt(br.readLine()); //운동기구 갯수
        long[] M = new long[N];

        String[] tokens = br.readLine().split(" ");
        for (int i = 0; i < N; i++) {
            M[i] = Long.parseLong(tokens[i]);
        }
        Arrays.sort(M); //정렬
        ////////////////////// 정답 ////////////////////////////////////////////
        long max;
        if(N%2==0){
            //운동기구의 갯수가 짝수일때
            max = M[0]+M[N-1];
            for(int i=0;i<N/2;i++){
                if(max<M[i]+M[N-1-i]){
                    max = M[i]+M[N-1-i];
                }
            }
        }else{
            //운동기구의 갯수가 홀수 일때
            max = M[N-1];
            for(int i=0;i<N/2;i++){
                if(max<M[i]+M[N-1-(i+1)]){
                    max = M[i]+M[N-1-(i+1)];
                }
            }
        }
        System.out.println(max);

    }
}

짝수의 경우까지 처리해주면 끝!