이번 장에서는 정렬을 활용하여 문제를 해결해본다.
다룰 정렬 알고리즘은 선택정렬, 버블정렬, 삽입정렬이며 Java의 Arrays.sort()도 추가로 활용한다.
모든 코드는 깃허브 (링크)의 테스트 코드로 정리해두었다.
정렬
N개이 숫자가 입력되면 오름차순으로 정렬하여 출력하는 프로그램을 작성하세요. 정렬하는 방법은 선택정렬입니다.
- 입력설명
첫 번째 줄에 자연수 N(1<=N<=100)이 주어집니다.
두 번째 줄에 N개의 자연수가 공백을 사이에 두고 입력됩니다. 각 자연수는 정수형 범위 안에 있습니다. - 출력설명
오름차순으로 정렬된 수열을 출력합니다. - 입력예제 1
6
13 5 11 7 23 15 - 출력예제 1
5 7 11 13 15 23
public class Sorting {
// 선택 정렬을 통한 해결 방법
public int[] solution1(int[] inputs) {
for (int i = 0; i < inputs.length; i++) {
// 기본 인덱스는 i로 한다.
int index = i;
// i 이후부터 순회하며 i번째보다 작은 수를 찾아간다.
// index 계속 더 작은 값을 찾아가며 가장 작은 값을 가진 값의 인덱스로 결정된다.
for (int j = i + 1; j < inputs.length; j++) {
if (inputs[j] < inputs[index]) {
index = j;
}
}
// i번 인덱스의 값을 복사하고
int temp = inputs[i];
// 위의 로직에서 찾은 가장 작은 값을 i값에 넣는다.
inputs[i] = inputs[index];
// 기존 i번 인덱스의 값을 위의 로직에서 찾은 가장 작은 값이 있던 인덱스에 넣는다.
inputs[index] = temp;
}
return inputs;
}
// 버블 정렬을 통한 해결 방법
public int[] solution2(int[] inputs) {
for (int i = 0; i < inputs.length; i++) {
// 배열의 끝의 직전까지 순회한다.
for (int j = 0; j < inputs.length - i - 1; j++) {
if (inputs[j] > inputs[j + 1]) {
int tmp = inputs[j];
inputs[j] = inputs[j + 1];
inputs[j + 1] = tmp;
}
}
}
return inputs;
}
// 삽입 정렬을 통한 해결 방법
public int[] solution3(int[] inputs) {
for (int i = 1; i < inputs.length; i++) {
int temp = inputs[i];
int j;
for (j = i - 1; j >= 0; j--) {
if (inputs[j] > temp) {
inputs[j + 1] = inputs[j];
} else {
break;
}
}
inputs[j + 1] = temp;
}
return inputs;
}
@Test
@DisplayName("정렬")
public void main() {
int[] inputs = {13, 5, 11, 7, 23, 15};
int[] expectedAnswer = {5, 7, 11, 13, 15, 23};
int[] answer1 = solution1(inputs);
assertArrayEquals(expectedAnswer, answer1);
int[] answer2 = solution2(inputs);
assertArrayEquals(expectedAnswer, answer2);
int[] answer3 = solution3(inputs);
assertArrayEquals(expectedAnswer, answer3);
}
}Least Recently Used (카카오 기출)
캐시메모리는 CPU와 주기억장치(DRAM) 사이의 고속의 임시 메모리로서 CPU가 처리할 작업을 저장해 놓았다가 필요할 바로 사용해서 처리속도를 높이는 장치이다.
워낙 비싸고 용량이 작아 효율적으로 사용해야 한다. 철수의 컴퓨터는 캐시메모리 사용 규칙이 LRU 알고리즘을 따른다.
LRU 알고리즘은 Least Recently Used 의 약자로 직역하자면 가장 최근에 사용되지 않은 것 정도의 의미를 가지고 있습니다.
캐시에서 작업을 제거할 때 가장 오랫동안 사용하지 않은 것을 제거하겠다는 알고리즘입니다.
만약 캐시의 사이즈가 5이고 작업이 2 3 1 6 7 순으로 저장되어 있다면, (맨 앞이 가장 최근에 쓰인 작업이고, 맨 뒤는 가장 오랫동안 쓰이지 않은 작업이다.)
1) Cache Miss : 해야할 작업이 캐시에 없는 상태로 위 상태에서 만약 새로운 작업인 5번 작업을 CPU가 사용한다면 Cache miss가 되고 모든 작업이 뒤로 밀리고
5번 작업은 캐시의 맨 앞에 위치한다. 5 2 3 1 6 (7번 작업은 캐시에서 삭제된다.)
2) Cache Hit : 해야할 작업이 캐시에 있는 상태로 위 상태에서 만약 3번 작업을 CPU가 사용한다면 Cache Hit가 되고,
3번 앞에 있는 5, 2번 작업은 한 칸 뒤로 밀리고, 3번이 맨 앞으로 위치하게 된다. 5 2 3 1 6 ---> 3 5 2 1 6
캐시의 크기가 주어지고, 캐시가 비어있는 상태에서 N개의 작업을 CPU가 차례로 처리한다면 N개의 작업을 처리한 후 캐시메모리의 상태를 가장 최근 사용된 작업부터
차례대로 출력하는 프로그램을 작성하세요.
- 입력설명
첫 번째 줄에 캐시의 크기인 S(3<=S<=10)와 작업의 개수 N(5<=N<=1,000)이 입력된다.
두 번째 줄에 N개의 작업번호가 처리순으로 주어진다. 작업번호는 1 ~ 100 이다. - 출력설명
마지막 작업 후 캐시메모리의 상태를 가장 최근 사용된 작업부터 차례로 출력합니다. - 입력예제 1
59
123262357 - 출력예제 1
75326
public class LeastRecentlyUsed {
public int[] solution1(int size, int[] jobs) {
int[] answer = new int[size];
for (int i = 0; i < jobs.length; i++) {
int tmp = jobs[i];
int position = -1;
for (int j = 0; j < size; j++) {
if (answer[j] == tmp) {
position = j;
}
}
// Cache Miss 인 경우
if (position == -1) {
for (int j = size - 1; j >= 1; j--) {
answer[j] = answer[j - 1];
}
// Cache Hit 인 경우
} else {
for (int j = position; j >= 1; j--) {
answer[j] = answer[j - 1];
}
}
answer[0] = tmp;
}
return answer;
}
@Test
@DisplayName("Least Recently Used")
public void main() {
int[] jobs = {1, 2, 3, 2, 6, 2, 3, 5, 7};
int[] expectedAnswer = {7, 5, 3, 2, 6};
int[] answer1 = solution1(5, jobs);
assertArrayEquals(expectedAnswer, answer1);
}
}중복 확인
현수네 반에는 N명의 학생들이 있습니다.
선생님은 반 학생들에게 1부터 10,000,000까지의 자연수 중에서 각자가 좋아하는 숫자 하나 적어내라고 했습니다.
만약 N명의 학생들이 적어낸 숫자 중 중복된 숫자가 존재하면 D(duplication)를 출력하고,
N 명이 모두 각자 다른 숫자를 적어냈다면 U(unique)를 출력하는 프로그램을 작성하세요.
- 입력설명
첫 번째 줄에 자연수 N(5<=N<=100,000)이 주어진다.
두 번째 줄에 학생들이 적어 낸 N개의 자연수가 입력된다. - 출력설명
첫 번째 줄에 D 또는 U를 출력한다. - 입력예제 1
8
20 25 52 30 39 33 43 33 - 출력예제 1
D
public class DuplicateCheck {
// HashMap을 활용한 방법 O(n)
public String solution1(int[] numbers) {
Map<Integer, Integer> mapOfNumber = new HashMap<>();
for (int number : numbers) {
if (mapOfNumber.containsKey(number)) {
return "D";
} else {
mapOfNumber.put(number, 0);
}
}
return "U";
}
// 선택 정렬 이후 중복을 확인하는 방법 O(nlogn)
public String solution2(int[] numbers) {
for (int i = 0; i < numbers.length; i++) {
int index = i;
for (int j = i + 1; j < numbers.length; j++) {
if (numbers[j] < numbers[index]) {
index = j;
}
}
int temp = numbers[i];
numbers[i] = numbers[index];
numbers[index] = temp;
}
for (int i = 0; i < numbers.length - 1; i++) {
if (numbers[i] == numbers[i + 1]) {
return "D";
}
}
return "U";
}
// 버블 정렬 이후 중복을 확인하는 방법 O(nlogn)
public String solution3(int[] numbers) {
for (int i = 0; i < numbers.length; i++) {
for (int j = 0; j < numbers.length - i - 1; j++) {
if (numbers[j] > numbers[j + 1]) {
int temp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = temp;
}
}
}
for (int i = 0; i < numbers.length - 1; i++) {
if (numbers[i] == numbers[i + 1]) {
return "D";
}
}
return "U";
}
// 삽입 정렬 이후 중복을 확인하는 방법 O(nlogn)
public String solution4(int[] numbers) {
for (int i = 1; i < numbers.length; i++) {
int temp = numbers[i];
int j;
for (j = i - 1; j >= 0; j--) {
if (numbers[j] > temp) {
numbers[j + 1] = numbers[j];
} else {
break;
}
}
numbers[j + 1] = temp;
}
for (int i = 0; i < numbers.length - 1; i++) {
if (numbers[i] == numbers[i + 1]) {
return "D";
}
}
return "U";
}
@Test
@DisplayName("중복 확인")
public void main() {
int[] numbers = {20, 25, 52, 30, 39, 33, 43, 33};
String expectedAnswer = "D";
String answer1 = solution1(numbers);
assertEquals(expectedAnswer, answer1);
String answer2 = solution2(numbers);
assertEquals(expectedAnswer, answer2);
String answer3 = solution3(numbers);
assertEquals(expectedAnswer, answer3);
String answer4 = solution4(numbers);
assertEquals(expectedAnswer, answer4);
}
}장난꾸러기
새 학기가 시작되었습니다. 철수는 새 짝꿍을 만나 너무 신이 났습니다.
철수네 반에는 N명의 학생들이 있습니다.
선생님은 반 학생들에게 반 번호를 정해주기 위해 운동장에 반 학생들을 키가 가장 작은 학 생부터 일렬로 키순으로 세웠습니다.
제일 앞에 가장 작은 학생부터 반 번호를 1번부터 N번까 지 부여합니다. 철수는 짝꿍보다 키가 큽니다. 그런데 철수가 앞 번호를 받고 싶어 짝꿍과 자리를 바꿨습니다.
선생님은 이 사실을 모르고 학생들에게 서있는 순서대로 번호를 부여했습니다.
철수와 짝꿍이 자리를 바꾼 반 학생들의 일렬로 서있는 키 정보가 주어질 때 철수가 받은 번호와 철수 짝꿍이 받은 번호를 차례로 출력하는 프로그램을 작성하세요.
- 입력설명
첫 번째 줄에 자연수 N(5<=N<=100)이 주어진다.
두 번째 줄에 제일 앞에부터 일렬로 서있는 학생들의 키가 주어진다. 키(높이) 값 H는 (120<=H<=180)의 자연수 입니다. - 출력설명
첫 번째 줄에 철수의 반 번호와 짝꿍의 반 번호를 차례로 출력합니다. - 입력예제 1
9
120 125 152 130 135 135 143 127 160 - 출력예제 1
38
출력해설 : 키 정보 152가 철수이고, 127이 철수 짝꿍입니다. - 입력예제 2
6
120 130 150 150 130 150 - 출력예제 2
35
public class MischievousBoy {
// 삽입 정렬을 통한 풀이
public Integer[] solution1(int[] students) {
List<Integer> answer = new ArrayList<>();
int[] originStudents = students.clone();
for (int i = 0; i < students.length; i++) {
int index = i;
for (int j = i + 1; j < students.length; j++) {
if (students[index] > students[j]) {
index = j;
}
}
int temp = students[index];
students[index] = students[i];
students[i] = temp;
}
for (int i = 0; i < originStudents.length; i++) {
if (originStudents[i] != students[i]) {
answer.add(i + 1);
}
}
return answer.toArray(new Integer[0]);
}
// 버블 정렬을 통한 풀이
public Integer[] solution2(int[] students) {
List<Integer> answer = new ArrayList<>();
int[] originStudents = students.clone();
for (int i = 0; i < students.length; i++) {
for (int j = 0; j < students.length - i - 1; j++) {
if (students[j] > students[j + 1]) {
int temp = students[j];
students[j] = students[j + 1];
students[j + 1] = temp;
}
}
}
for (int i = 0; i < students.length; i++) {
if (originStudents[i] != students[i]) {
answer.add(i + 1);
}
}
return answer.toArray(new Integer[0]);
}
// 삽입 정렬을 통한 풀이
public Integer[] solution3(int[] students) {
List<Integer> answer = new ArrayList<>();
int[] originStudents = students.clone();
for (int i = 1; i < students.length; i++) {
int temp = students[i];
int j;
for (j = i - 1; j >= 0; j--) {
if (students[j] > temp) {
students[j + 1] = students[j];
} else {
break;
}
}
students[j + 1] = temp;
}
for (int i = 0; i < students.length; i++) {
if (originStudents[i] != students[i]) {
answer.add(i + 1);
}
}
return answer.toArray(new Integer[0]);
}
// Arrays.sort 를 통한 풀이
public Integer[] solution4(int[] students) {
List<Integer> answer = new ArrayList<>();
int[] originStudents = students.clone();
Arrays.sort(students);
for (int i = 0; i < originStudents.length; i++) {
if (students[i] != originStudents[i]) {
answer.add(i + 1);
}
}
return answer.toArray(new Integer[0]);
}
@Test
@DisplayName("장난꾸러기")
public void main() {
int[] students1_1 = {120, 125, 152, 130, 135, 135, 143, 127, 160};
int[] students1_2 = students1_1.clone();
int[] students1_3 = students1_1.clone();
int[] students1_4 = students1_1.clone();
Integer[] expectedAnswer1 = {3, 8};
Integer[] answer1_1 = solution1(students1_1);
Integer[] answer1_2 = solution2(students1_2);
Integer[] answer1_3 = solution3(students1_3);
Integer[] answer1_4 = solution4(students1_4);
assertArrayEquals(expectedAnswer1, answer1_1);
assertArrayEquals(expectedAnswer1, answer1_2);
assertArrayEquals(expectedAnswer1, answer1_3);
assertArrayEquals(expectedAnswer1, answer1_4);
int[] students2_1 = {120, 130, 150, 150, 130, 150};
int[] students2_2 = students2_1.clone();
int[] students2_3 = students2_1.clone();
int[] students2_4 = students2_1.clone();
Integer[] expectedAnswer2 = {3, 5};
Integer[] answer2_1 = solution1(students2_1);
Integer[] answer2_2 = solution2(students2_2);
Integer[] answer2_3 = solution3(students2_3);
Integer[] answer2_4 = solution4(students2_4);
assertArrayEquals(expectedAnswer2, answer2_1);
assertArrayEquals(expectedAnswer2, answer2_2);
assertArrayEquals(expectedAnswer2, answer2_3);
assertArrayEquals(expectedAnswer2, answer2_4);
}
}좌표 정렬
N개의 평면상의 좌표(x, y)가 주어지면 모든 좌표를 오름차순으로 정렬하는 프로그램을 작성하세요.
정렬기준은 먼저 x값의 의해서 정렬하고, x값이 같을 경우 y값에 의해 정렬합니다.
- 입력설명
첫째 줄에 좌표의 개수인 N(3<=N<=100,000)이 주어집니다.
두 번째 줄부터 N개의 좌표가 x, y 순으로 주어집니다. x, y값은 양수만 입력됩니다. - 출력설명
N개의 좌표를 정렬하여 출력하세요. - 입력예제 1 5
27
13
12
25
36 - 출력예제 1
12
13
25
27
36
public class SortingCoordinate {
@AllArgsConstructor
static class Coordinate implements Comparable<Coordinate> {
int x;
int y;
// compareTo는 사용할 때마다 헷갈리므로 암기하도록 한다.
// 결과값은 무조건 음수가 나오게 맞춘다.
// 결과 정렬은 this, target 순으로 정렬된다고 가정한다.
// 오름차순이라면 this(임의의 수 10), target(임의의 수 20)으로 정렬될 것이다.
// 따라서 음수가 나오게 하려면 this - target이 되어야한다.
// 내림차순이라면 this(임의의 수 20), target(임의의 수 10)으로 정렬될 것이다.
// 따라서 음수가 나오게 하려면 target - this가 되어야한다.
@Override
public int compareTo(Coordinate target) {
if (this.x == target.x) {
return y - target.y;
} else {
return x - target.x;
}
}
}
public int[][] solution1(int[][] coordinates) {
List<Coordinate> listOfCoordinates = new ArrayList<>();
for (int[] c : coordinates) {
listOfCoordinates.add(new Coordinate(c[0], c[1]));
}
Collections.sort(listOfCoordinates);
for (int i = 0; i < coordinates.length; i++) {
coordinates[i][0] = listOfCoordinates.get(i).x;
coordinates[i][1] = listOfCoordinates.get(i).y;
}
return coordinates;
}
@Test
@DisplayName("좌표 정렬")
public void main() {
int[][] coordinates = {
{2, 7}, {1, 3}, {1, 2}, {2, 5}, {3, 6}
};
int[][] expectedAnswer = {
{1, 2}, {1, 3}, {2, 5}, {2, 7}, {3, 6}
};
int[][] answer1 = solution1(coordinates);
assertArrayEquals(expectedAnswer, answer1);
}
}'Algorithm' 카테고리의 다른 글
| [Algorithm] Recursive (0) | 2022.02.27 |
|---|---|
| [Algorithm] Search (0) | 2022.02.25 |
| [Algorithm] Queue (0) | 2022.02.23 |
| [Algorithm] Stack (0) | 2022.02.23 |
| [Algorithm] HashMap (0) | 2022.02.22 |
