https://swexpertacademy.com/main/solvingProblem/solvingProblem.do

 

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import java.util.Scanner;
 
public class Solution {
    // 왼쪽 대각선 아래, 아래, 오른쪽 대각선 아래, 오른쪽 방향
    static int[][] drc = { { 1, -1 }, { 1, 0 }, { 1, 1 }, { 0, 1 } };
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        int tc = sc.nextInt();
        for (int t = 1; t <= tc; t++) {
            // 배열 입력 받기
            int N = sc.nextInt();
            char[][] arr = new char[N][N];
            for (int i = 0; i < N; i++) {
                char[] tempArr = sc.next().toCharArray();
                for (int j = 0; j < N; j++) {
                    arr[i][j] = tempArr[j];
                }
            }
            // 현재 위치에 돌이 있다면, 방향별 앞의 4칸에 돌이 있는지 확인한다.
            // boolean 변수를 이용해서 출력한다.
            boolean flag = false;
            outer: for (int r = 0; r < N; r++) {
                for (int c = 0; c < N; c++) {
                    if (arr[r][c] == 'o') {
                        flag = check(arr, r, c, N);
                        if (flag) {
                            break outer;
                        }
                    }
                }
            }
            if (flag) {
                System.out.println("#" + t + " " + "YES");
            } else {
                System.out.println("#" + t + " " + "NO");
            }
        }
    }
    static boolean check(char[][] arr, int r, int c, int size) {
        // 4방향을 델타 탐색(s로 인덱스 번호를 줘서 방향을 달리한다)
        for (int s = 0; s < 4; s++) {
            // 방향별 앞의 4개의 돌을 1개씩 체크한다.
            for (int k = 1; k <= 4; k++) {
                int nr = r + drc[s][0] * k;
                int nc = c + drc[s][1] * k;
                if (nr >= 0 && nr < size && nc >= 0 && nc < size && arr[nr][nc] == 'o') {
                    if (k == 4) {
                        return true;
                    }
                } else {
                    break;
                }
            } // end for: 방향별 앞의 4개의 돌 체크
 
        } // end for: 4개의 방향 체크
        return false; // 4개의 방향 체크 다 했지만 조건 만족하는 경우 없다.
    }
 
}
 
 cs

'알고리즘 및 코테 > SWEA' 카테고리의 다른 글

SWEA 2805. 농작물 수확하기(Java)  (0) 2023.01.12
SWEA 1954. 달팽이 숫자(Java)  (0) 2023.01.12
SWEA 1204. [S/W 문제해결 기본] 1일차 - 최빈수 구하기 - Java  (0) 2023.01.10
SWEA 1984. 중간 평균값 구하기(Java)  (2) 2023.01.10
SWEA 1966. 숫자를 정렬하자(Java)  (2) 2023.01.10

https://swexpertacademy.com/main/solvingProblem/solvingProblem.do

 

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

이 문제는 2가지 방법으로 풀 수 있다.

1. 별 찍기하듯이

2. 델타 탐색

 

먼저, 문제에서 농작물을 수확할 수 있는 정사각형 마름모 형태의 별을 찍어보면,

N = 7일 때

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++) {
        if(i < N/2) {    
            if(j >= N/2 - i && j <= N/2 +i) {
                System.out.print("*");
            }
            else {
                System.out.print(" ");
            }
        }
        else { 
            if(j >= N/2 - (N-1) + i && j <= N/2 + (N-1) - i ) {
                System.out.print("*");
            }
            else {
                System.out.print(" ");
            }
        }
    }
    System.out.println();
}
 cs

 

이를 이용해 문제를 풀어보자. 농작물 수확해서 얻는 이익을 profit이라는 변수라고 하였다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.util.Scanner;
 
public class List_Sequantial {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        int T = sc.nextInt();
        for (int tc = 0; tc < T; tc++) {
 
            int N = sc.nextInt();
            int[][] farm = new int[N][N];
 
            // 한 줄씩 입력 받아서 char로 하나씩 쪼갠다.
            // sc.nextInt()로 String 14054을 입력받고,
            // toCharArra()로 char 1, char 4...char 4의 배열로 바꿔준다.
            // 즉, ['1', '4', '0', '5', '4']가 되는 것이다.
            for (int i = 0; i < N; i++) {
                char[] tempArr = sc.next().toCharArray();
                for (int j = 0; j < N; j++) {
                    farm[i][j] = tempArr[j] - '0';
                }
            }
            int profit = 0; 
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    if (i < N / 2) {
                        if (j >= N / 2 - i && j <= N / 2 + i) {
                            profit = profit + farm[i][j];
                        }
                    } else {
                        if (j >= N / 2 - (N - 1) + i && j <= N / 2 + (N - 1) - i) {
                            profit = profit + farm[i][j];
                        }
                    }
                }
            }
            System.out.println("#" + (tc+1) + " " + profit);
        }
    }
}
 
 cs

 

이번엔 델타 탐색을 통해 문제를 풀어보도록 한다.

먼저 N=5일때, 수확이 가능한 부분을 색칠해서 나타내면(노란색 부분)

N*N 2차원 배열의 중앙을 기준으로 생각해보자.

중앙을 기준으로 2칸 이동을 한 경우에만 수확이 가능함을 알 수 있다.

즉, 위로 두칸이든 위로 한칸 오른쪽 한칸이든 이동한 횟수 또는 칸수가 2이기만 하면 된다.

이를 이용해서 풀어보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.Scanner;
 
public class Solution {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        int T = sc.nextInt();
        for (int tc = 0; tc < T; tc++) {
 
            int N = sc.nextInt();
            int[][] farm = new int[N][N];
 
            // 한 줄씩 입력 받아서 char로 하나씩 쪼갠다.
            // sc.nextInt()로 String 14054을 입력받고,
            // toCharArra()로 char 1, char 4...char 4의 배열로 바꿔준다.
            // 즉, ['1', '4', '0', '5', '4']가 되는 것이다.
            for (int i = 0; i < N; i++) {
                char[] tempArr = sc.next().toCharArray();
                for (int j = 0; j < N; j++) {
                    farm[i][j] = tempArr[j] - '0';
                }
            }
            int profit = 0;
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    if ((Math.abs(i - N / 2) + Math.abs(j - N / 2)) <= N / 2) {
                        profit = profit + farm[i][j];
                    }
                }
            }
            System.out.println("#" + (tc+1) + " " + profit);
        }
    }
}
 
 cs

 

 

'알고리즘 및 코테 > SWEA' 카테고리의 다른 글

SWEA 11315. 오목 판정(Java)  (0) 2023.01.12
SWEA 1954. 달팽이 숫자(Java)  (0) 2023.01.12
SWEA 1204. [S/W 문제해결 기본] 1일차 - 최빈수 구하기 - Java  (0) 2023.01.10
SWEA 1984. 중간 평균값 구하기(Java)  (2) 2023.01.10
SWEA 1966. 숫자를 정렬하자(Java)  (2) 2023.01.10

https://swexpertacademy.com/main/solvingProblem/solvingProblem.do

 

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

델타 탐색을 이용하여 풀어본다.

숫자가 시계방향으로 이루어져 있으므로,

탐색 방향은 (오른쪽, 아래, 왼쪽, 위) 순서대로 반복될 것이다.

아래 N = 4일 경우, 달팽이의 모습을 보자.

1 2 3 4
12 13 14 5
11 16 15 6
10 9 8 7

N*N의 2차원 배열에서 원소 1이 존재하는 위치를 기준으로 탐색해나가면서 숫자를 입력해줘야 하는데,

중요하게 생각할 포인트는 "언제 방향을 바꾸는가" 이다.

처음 위치부터 생각해보자. 처음 위치(배열의 [0][0] 위치)에 1을 지정하고 시작하도록 한다.

처음위치에서는 아래 화살표 방향과 같이 오른쪽으로 탐색해 나가면서 숫자를 1씩 더해 입력한다.

그런데, 아래와 같이 4까지 입력하고 나면, 5를 입력하기 위해서는 탐색 방향을 오른쪽이 아닌 아래 방향으로 바꾸어야 한다.

일단 어떤 조건을 통해 방향을 바꾸었다고 가정하고, 진행해보면서 어느 지점에서 방향이 바뀌어야 하는지 살펴보면, 

1. 같은 방향으로 탐색시 다음 차례에서 배열의 범위를 벗어날 때,

2. 같은 방향으로 탐색시 다음 차례에 숫자가 존재할 때, (다음 차례에 숫자가 존재한다는 것을 어떻게 처리?)

이제, 각 조건에 대해 어떻게 코드를 작성할지 살펴보자.

1번 조건에 대해서는 다음 탐색 위치(인덱스)가 0이상이고 N-1을 초과하면 안되므로, 인덱스 값이 N보다 작아야 한다는 조건을 이용하도록 한다.

2번 조건에 대해서는 다음 탐색 위치에 숫자가 존재한다는 조건을 달기 위해 그 위치의 값이 0이면 방향을 바꾸어야 한다는 조건을 이용한다.(왜냐하면 int배열을 생성하면 기본적으로 원소들이 0이기 때문이다)

 

아래 코드와 주석을 살펴보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import java.util.Scanner;
 
public class Solution {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        int T = sc.nextInt();
        for (int tc = 1; tc <= T; tc++) {
 
            int N = sc.nextInt();
            int[][] snail = new int[N][N];
            int[] dr = { 0, 1, 0, -1 };
            int[] dc = { 1, 0, -1, 0 }; // 우 하 좌 상
            int n = 0; // dr, dc의 index 역할
 
            int row = 0; // 현재 행 인덱스
            int col = 0; // 현재 열 인덱쇼
 
            snail[0][0] = 1; // 처음 위치 값 1 지정
            int w = 1;
            //총 N-1번 탐색
            while (w < N * N) { 
                int nr = row + dr[n]; //이동 후 행 인덱스
                int nc = col + dc[n]; //이동 후 열 인덱스
                //nr, nc가 0이상 N-1이하여야 인덱스 범위 초과하지 않고,
                //다음 위치에 0이 존재해야 방향을 유지한다.
                if (nr >= 0 && nr < N && nc < N && nc >= 0 && snail[nr][nc] == 0) {
                    snail[nr][nc] = ++w; //이전의 w값보다 하나 증가된 w를 대입하고, w 자신도 1증가
                    row = nr;
                    col = nc;
                } else {
                    n = (n + 1) % 4; //4가지의 방향이 있으므로 4로 나눈 나머지를 이용해 돌린다.
                }
            }
            System.out.println("#" + tc);
            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    System.out.print(snail[i][j] + " ");
                }
                System.out.println();
            }
        }
    }
}
 
 cs

 

 

'알고리즘 및 코테 > SWEA' 카테고리의 다른 글

SWEA 11315. 오목 판정(Java)  (0) 2023.01.12
SWEA 2805. 농작물 수확하기(Java)  (0) 2023.01.12
SWEA 1204. [S/W 문제해결 기본] 1일차 - 최빈수 구하기 - Java  (0) 2023.01.10
SWEA 1984. 중간 평균값 구하기(Java)  (2) 2023.01.10
SWEA 1966. 숫자를 정렬하자(Java)  (2) 2023.01.10

https://swexpertacademy.com/main/solvingProblem/solvingProblem.do

 

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

문제를 푸는 것에 있어서 가장 핵심은 배열의 index의 활용이다.

점수는 0점~100점, 점수들 중에서 최빈값을 구하는 것.

예를들어, 각 점수마다 임의로 빈도수를 나타낸다고 가정해보자.

0점 1점 2점 3점 4점 ...  98점 99점 100점

1번 4번 6번 2번 5번 ...  3번   20번     1번

위 두 줄을 보면 뭐가 떠오르는가? 

"배열의 원소와 각 원소에 대한 인덱스"

즉, 점수마다의 빈도수를 원소로 갖고, 인덱스 번호가 0부터 100까지 존재하는 배열을 이용하면 되지 않을까?라는 생각.

 

이제 작성한 코드를 살펴보자.

 

1. 첫번째 풀이(비효율적인 부분이 있으나 생각의 흐름이 모두 드러나있는 풀이)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.util.Scanner;
 
public class Solution {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
 
        for (int k = 0; k < T; k++) {
            int t = sc.nextInt();
            //1000명의 학생의 점수 입력
            int[] arr = new int[1000];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = sc.nextInt();
            }
            //0점 ~ 100점의 빈도수를 셀 배열 생성
            int[] cnt = new int[101]; // 0점 ~ 100점(배열의 길이: 101)
            for (int i = 0; i < arr.length; i++) {
                for (int j = 0; j < 101; j++) {
                    if (arr[i] == j) {
                        cnt[j]++;
                    }
                }
            }
            //가장 큰 빈도수를 찾아, 그 빈도수에 해당되는 점수(인덱스) 출력하기
            //이때, 가장 큰 빈도수가 여러 개이면 가장 높은 점수를 출력해야하는데,
            // 아래 max, cnt[i] 비교시 <만 입력하게 되면, 더 높은 점수(인덱스)에서 동일한 빈도수를 가지더라도 출력이 안되므로
            // max <= cnt[i]로 처리한다.
            int max = cnt[0];
            int answer = 0;
            for (int i = 0; i < cnt.length; i++) {
                if (max <= cnt[i]) { 
                    max = cnt[i];
                    answer = i;
                } 
            }
            System.out.println("#" + t + " " + answer);
        }
    }
 
}
 
 cs

2. 비효율적인 부분을 줄인 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.util.Scanner;
 
public class Solution {
 
    public static void main(String[] args) {
 
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
 
        for (int k = 0; k < T; k++) {
            int t = sc.nextInt();
            //점수 입력 및 빈도수 배열 생성, 빈도수 나타내기
            int[] cnt = new int[101];
            for (int i = 0; i < 1000; i++) {
                int score = sc.nextInt();
                cnt[score]++;
            } 
            //가장 큰 빈도수 찾아, 점수 출력하기
            int maxScore = 0;
            for(int score=0; score<cnt.length; score++){
                if(cnt[maxScore] <= cnt[score]) {
                    maxScore = score; 
                }
            }
            System.out.println("#" + t + " " + maxScore);
        } 
 
    }
}
 
 cs

 

'알고리즘 및 코테 > SWEA' 카테고리의 다른 글

SWEA 2805. 농작물 수확하기(Java)  (0) 2023.01.12
SWEA 1954. 달팽이 숫자(Java)  (0) 2023.01.12
SWEA 1984. 중간 평균값 구하기(Java)  (2) 2023.01.10
SWEA 1966. 숫자를 정렬하자(Java)  (2) 2023.01.10
SWEA 2068. 최대수 구하기 및 최댓/최솟값 구하기(Java)  (0) 2023.01.09

https://swexpertacademy.com/main/solvingProblem/solvingProblem.do

 

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

풀이를 하면서, 문제를 푸는 것 외에 확장된 생각을 함께 정리한다.

문제를 푸는 흐름은

1. 최댓값, 최솟값을 구한다.

2. 배열의 원소들의 총 합에서 최댓값, 최솟값을 빼준다.

3. 뺀 결과를 8(전체 원소 개수 - 최댓값 1개 - 최솟값 1개)

라고 생각을 했고, 

출력을 위해서

1. int를 double로 형변환하기 위해 8로 나누는 것이 아닌 8.0(8.0은 double, 8.0f는 float이므로)으로 나눠줬다.

2. 소수점 첫째자리에서 반올림 하기 위해, 반올림 하기 위한 변수에 0.5를 더하고 int로 형변환하여 버림을 해줬다.

(예를 들어, 13.4라면 0.5를 더해 13.9가 되고, int형변환을 통해 13이 되지만,

13.5라면 0.5를 더해 14.0이 되고, int형변환을 통해 14가 되기 때문이다.)

 

그 Solution은 다음과 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.util.Scanner;
 
public class Solution {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        int T = sc.nextInt();
        for (int n = 1; n <= T; n++) {
 
            int[] arr = new int[10];
            for (int i = 0; i < 10; i++) {
                arr[i] = sc.nextInt();
            }
            // 최댓값 max 구하기
            int max = arr[0];
            for (int i = 0; i < 10; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            // 최솟값 min 구하기
            int min = arr[0];
            for (int i = 0; i < 10; i++) {
                if (arr[i] < min) {
                    min = arr[i];
                }
            }
            // 배열 원소 전체 합 구하기
            int sum = 0;
            for (int i = 0; i < 10; i++) {
                sum = sum + arr[i];
            }
            int sum1 = sum - max - min;
            double ave = sum1 / 8.0; //int를 double로 형변환
            // 소수 첫째자리에서 반올림을 하기 위해 0.5를 더하고 int로 형변환
            System.out.println("#" + n + " " + (int) (ave + 0.5));
        }
    }
 
}
 
 cs

하지만, 

위의 생각에서 좀 더 자세히 파고들면,

최댓값과 최솟값을 각각 1개씩만 가지는 배열만 input 데이터에 포함되어 있다는 확신이 있는가? 라는 생각이 들게 된다.

즉, 어떤 배열이 {1,2,3,4,5,6}여서 최댓값이 6, 최솟값이 1이라고 했을 때, 위와 같은 Solution대로 결과를 출력할 수 있지만, 

어떤 배열이 {1,1,2,3,4,5,6,6}이라면 최댓값, 최솟값이 2개씩 존재하게 되므로 단순히 전체 배열 원소의 개수에서 2를 빼준 값을 통해 평균을 구하려고 접근해서는 안된다.

따라서, 아래 Solution은 최댓값, 최솟값이 중복해서 존재하는 경우 그 개수를 고려해준 결과이다.

위, 아래 둘다 동일한 출력 결과가 나타나지만, 이것은 input 데이터가 중복된 최댓값 혹은 최솟값이 존재하지 않았기 때문이었을 뿐이다. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import java.util.Scanner;
 
public class Solution {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        int T = sc.nextInt();
        for (int n = 1; n <= T; n++) {
 
            int[] arr = new int[10];
            for (int i = 0; i < 10; i++) {
                arr[i] = sc.nextInt();
            }
            // 최댓값 max 구하기
            int max = arr[0];
            for (int i = 0; i < 10; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            // 최솟값 min 구하기
            int min = arr[0];
            for (int i = 0; i < 10; i++) {
                if (arr[i] < min) {
                    min = arr[i];
                }
            }
            // 배열 원소 전체 합 구하기
            int sum = 0;
            for (int i = 0; i < 10; i++) {
                sum = sum + arr[i];
            }
            // 최댓값, 최솟값이 몇개씩 들어있는지 확인
            // 각각 1개씩 있다면 전체 원소 10개에서 최댓값, 최솟값 1개씩 뺀 8개에 대해 평균값을 구하면 되지만,
            // 1 1 2 3 4 5 5처럼 최댓값, 최솟값이 1개보다 많다면 그 개수만큼 더 빼줘야 하기 때문이다.
            int maxCount = 0, minCount = 0;
            for (int i = 0; i < arr.length; i++) {
                if (max > arr[i]) {
                    maxCount++;
                }
                if (min < arr[i]) {
                    minCount++;
                }
            }
            // 10 - maxCount는 최댓값의 개수, 10 - minCount는 최솟값의 개수
            int sum1 = sum - max * (10 - maxCount) - min * (10 - minCount);
            int count = 10 - (10 - maxCount) - (10 - minCount);
            double ave = sum1 / (double) count;
            // 소수 첫째자리에서 반올림을 하기 위해 0.5를 더하고 int로 형변환
            System.out.println("#" + n + " " + (int) (ave + 0.5));
        }
    }
 
}
 
 cs

 

'알고리즘 및 코테 > SWEA' 카테고리의 다른 글

SWEA 2805. 농작물 수확하기(Java)  (0) 2023.01.12
SWEA 1954. 달팽이 숫자(Java)  (0) 2023.01.12
SWEA 1204. [S/W 문제해결 기본] 1일차 - 최빈수 구하기 - Java  (0) 2023.01.10
SWEA 1966. 숫자를 정렬하자(Java)  (2) 2023.01.10
SWEA 2068. 최대수 구하기 및 최댓/최솟값 구하기(Java)  (0) 2023.01.09

https://swexpertacademy.com/main/solvingProblem/solvingProblem.do

 

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

오름차순으로 정렬하는 것이므로 두 가지 방식으로 풀어보고자 한다.

1. 버블 정렬

2. 선택 정렬

 

Theme. 버블 정렬 Solution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.util.Scanner;
 
public class Solution {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        int T = sc.nextInt();
        for (int n = 1; n <= T; n++) {
            int tmp;
            int t = sc.nextInt();
            int[] arr = new int[t];
            for (int i = 0; i < t; i++) {
                arr[i] = sc.nextInt();
            }
            for (int i = 0; i < arr.length - 1; i++) {
                for (int j = 0; j < arr.length - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        tmp = arr[j + 1];
                        arr[j + 1] = arr[j];
                        arr[j] = tmp;
                    }
                }
            }
 
            System.out.print("#" + n + " ");
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();
        }
    }
 
}
 
 cs

 

Theme. 선택 정렬 Solution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import java.util.Scanner;
 
public class Solution {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        int T = sc.nextInt();
        for (int n = 1; n <= T; n++) {
            int tmp;
            int t = sc.nextInt();
            int[] arr = new int[t];
            for (int i = 0; i < t; i++) {
                arr[i] = sc.nextInt();
            }
            for (int i = 0; i < arr.length - 1; i++) {
                int minIdx = i;
                for (int j = i+1; j < arr.length; j++) {
                    if (arr[minIdx] > arr[j]) {
                        minIdx = j;
                    }
                }
                tmp = arr[minIdx];
                arr[minIdx] = arr[i];
                arr[i] = tmp;
            }
 
            System.out.print("#" + n + " ");
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();
        }
    }
 
}
 cs

 

 

 

'알고리즘 및 코테 > SWEA' 카테고리의 다른 글

SWEA 2805. 농작물 수확하기(Java)  (0) 2023.01.12
SWEA 1954. 달팽이 숫자(Java)  (0) 2023.01.12
SWEA 1204. [S/W 문제해결 기본] 1일차 - 최빈수 구하기 - Java  (0) 2023.01.10
SWEA 1984. 중간 평균값 구하기(Java)  (2) 2023.01.10
SWEA 2068. 최대수 구하기 및 최댓/최솟값 구하기(Java)  (0) 2023.01.09

Theme. 배열의 최댓값/최솟값 구하기

 

1. 최댓값

먼저, 배열 arr = {1, 5, 9, 3, 7, 1, 0}이 있다고 하자.

결론부터 말하면 배열의 첫번째 값을 최댓값이라고 가정하고, 이후 index마다의 값들과의 비교를 통해 더 큰 값이 존재하면 그 값을 최댓값으로 대입해주며 배열의 끝까지 비교해보는 것이다.

이제 자세히 알아보자.

int max = array[0];을 통해 배열의 첫번째 값을 max(최댓값)라고 가정해보자.

이제, 배열의 첫번째 값과 두번째 값을 비교해보자.

그 결과 array[1]인 5가 더 크므로 max의 값에 5를 대입해준다.(최댓값이 5인 상태)

같은 방식으로 한번더 진행한 결과는, 다음과 같다.

array[2]인 9가 5보다 크기 때문에 max의 값에 9를 대입해준다.(최댓값이 9인 상태)

이후 진행상황은, 

배열의 끝까지 비교한 결과 최댓값은 최종적으로 9가 된다.

이제 코드를 작성하여 결과를 확인해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class test {
 
    public static void main(String[] args) {
        int[] array = { 1, 5, 9, 3, 7, 1, 0 }; // 배열 생성
        int max = array[0]; // 배열의 첫번째 값을 최댓값으로 가정
        for (int i = 0; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
        }
        System.out.println(max);
 
    }
 
}
 
 cs

최댓값은 9가 나온다. 

 

2. 최솟값

최댓값을 구하는 방식과 같은 논의이나 단, 부등호의 방향이 바뀌는 것뿐이다. 

최댓값을 구할 때와 동일한 배열을 가지고 최솟값을 구하는 코드를 작성해보면,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class test {
 
    public static void main(String[] args) {
        int[] array = { 1, 5, 9, 3, 7, 1, 0 }; // 배열 생성
        int min = array[0]; // 배열의 첫번째 값을 최솟값으로 가정
        for (int i = 0; i < array.length; i++) {
            if (min > array[i]) {
                min = array[i];
            }
        }
        System.out.println(min);
 
    }
 
}
 
 cs

최솟값은 0이 나온다.

 

Theme. SWEA 2068. 최대수 구하기

https://swexpertacademy.com/main/solvingProblem/solvingProblem.do

 

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

< Solution >

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import java.util.Scanner;
 
public class Solution {
 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
 
        int T = sc.nextInt();
 
        for (int t = 1; t <= T; t++) {
            int[] arr = new int[10];
            for (int i = 0; i < 10; i++) {
                arr[i] = sc.nextInt();
            }
            int max = arr[0];
            for (int i = 0; i < arr.length; i++) {
                if (max < arr[i]) {
                    max = arr[i];
                }
            }
            System.out.println("#" + t + " " + max);
        }
 
    }
 
}
 
 cs

 

 

'알고리즘 및 코테 > SWEA' 카테고리의 다른 글

SWEA 2805. 농작물 수확하기(Java)  (0) 2023.01.12
SWEA 1954. 달팽이 숫자(Java)  (0) 2023.01.12
SWEA 1204. [S/W 문제해결 기본] 1일차 - 최빈수 구하기 - Java  (0) 2023.01.10
SWEA 1984. 중간 평균값 구하기(Java)  (2) 2023.01.10
SWEA 1966. 숫자를 정렬하자(Java)  (2) 2023.01.10

+ Recent posts

티스토리툴바