https://programmers.co.kr/learn/courses/30/lessons/60058

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

<풀이>

1. 입력받는 괄호 문자열을 올바른 괄호 문자열로 바꾼다.

2. 올바른 괄호 문자열로 바꾸는 방법을 주어진 그대로 구현한다.

3. 올바른 괄호 문자열을 반환한다.

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <iostream>
#include <string>
using namespace std;
 
bool isRight(string u) {
    int cnt = 0;
    for (int i = 0; i < u.length(); i++) {
        if (u[i] == '(') {
            cnt++;
        }
        else {
            cnt--;
        }
 
        if (cnt < 0) {
            return false;
        }
    }
    return true;
}
 
string solution(string s) {
 
    string answer = "";
 
    //1.
    if (s == "") {
        return answer;
    }
 
    //2.
    string u = "", v = "";
    int cnt1 = 0;
    int cnt2 = 0;    
    for (int i = 0; i <= s.length(); i++) {
        if (s[i] == '(') {
            cnt1++;
        }
        else {
            cnt2++;
        }
        if (cnt1 == cnt2) {
            u = s.substr(0, i + 1);
            v = s.substr(i + 1);
            break;
        }
    }
 
    //3.
    if (isRight(u)) {
        //3-1.
        answer = u + solution(v);
        return answer;
    }
    //4.
    else {
        //4-1.
        string tmp = "";
        tmp += '(';
 
        //4-2.
        tmp += solution(v);
 
        //4-3.
        tmp += ')';
 
        //4-4.
        for (int i = 0; i < u.length(); i++) {
 
            if (i == 0 || i == u.length() - 1) {
                continue;
            }
 
            if (u[i] == '(') {
                tmp += ')';
            }
            else {
                tmp += '(';
            }
        }
        answer = tmp;
 
        //4-5.
        return answer;
    }
}
 

 

구현에 대해 알아볼 수 있는 문제였습니다.

https://programmers.co.kr/learn/courses/30/lessons/60057

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

<풀이>

1. 주어진 문자열 맨 앞에서 부터 한 글자, 두 글자씩 잘라보면서 가장 짧게 압축된 문자열의 길이를 출력한다.

<해법>

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <iostream>
#include <string>
using namespace std;
 
int solution(string s) {
 
    int answer = 1;
 
    //주어진 문자열 길이
    int sLength = s.length();
 
    //1칸,2칸 ... 길이의 절반만큼 문자 자르기 반복
    for (int i = 1; i <= sLength / 2; i++) {
 
        //최종 문자열 보관
        string tmp = "";
 
        //처음 비교 문자열, 반복된 갯수
        string cmp = s.substr(0, i);
        int cnt = 1;
 
        //문자열 처음부터 끝까지 시행
        for (int j = i; j <= sLength; j += i) {
 
            //현재 문자열
            string cur = s.substr(j, i);
 
            //현재 문자열과 비교 문자열과 비교
            //현재 문자열과 비교 문자열이 같다면
            if (cmp == cur) {
                cnt++;
            }
            //현재 문자열과 비교 문자열이 다르다면
            else {
                //이전에 반복된 문자열이 있다면 반복된 문자열 출력
                if (cnt > 1) {
                    tmp += (to_string(cnt) + cmp);
                    cnt = 1;
                }
                else {
                    tmp += cmp;
                }
                cmp = cur;
            }
        }
 
        //문자열 뒤에 남은 문자들
        if (sLength / i != 0) {
            tmp += s.substr((sLength / i) * i);
        }
 
        //결과 저장
        if (answer == 1 || tmp.length() < answer) {
            answer = tmp.length();
        }
    }
 
    return answer;
}
 

 

문자열과 구현에 대해 알아볼 수 있는 문제였습니다.

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV5-BEE6AK0DFAVl

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 주어지는 사람들 각각 계단을 선택한다.

2. 선택된 계단들로 나오는데 걸리는 시간을 계산하고, 그 중 가장 최소값을 출력한다.

<해법>

1. 주어지는 사람들 각각 계단 선택 방법.

=> 계단 선택은 재귀 함수를 이용하여, 모든 경우를 계산하고 선택된 계단 정보들을 저장합니다.

 

2. 선택된 계단들로 나오는 시간 계산하는 방법.

=> 저는 deque를 이용하였습니다. 계단은 2개이므로 배열로 선언해주었고, deque에 담기는 내용은 계단의 길이입니다.

시간이 증가할 때마다 deque에 담긴 내용을 1씩 감소시켜주고, 0이 될 경우 pop_front를 해주었습니다.

만약 deque의 크기가 4이상일 경우, 앞의 3개의 index의 내용만 1씩 감소시켜주었습니다.

 

3. res + 1

=> 제 코드는 문제에서 주어진 대로 구현하지 않은 단점이 있습니다. 계단에 도착한 즉시 계단 deque안으로 들어가고 값이 1감소합니다.

예를 들면, time=2 일때 계단에 도착하고 time=3일 때부터 계단을 내려가야 하는데, 제 코드는 time=2일 때부터 계단을 내려갑니다.

따라서, 마지막 결과값에 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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
#include <iostream>
#include <vector>
#include <deque>
#include <cstring>
using namespace std;
 
//구조체 : 사람
struct people {
    //위치
    int x, y;
    //선택된 계단(0 or 1) 
    int stairNum;
    //선택된 계단 과의 거리
    int distance;
};
 
//구조체 : 계단
struct stair {
    //위치
    int x, y;
    //계단 길이
    int stairLength;
};
 
int N;
int map[10][10];
bool visited[10];
vector<people> p;
vector<stair> s;
int res;
 
void go(int index) {
 
    //모든 사람의 계단 선택이 완료되었을 경우 -> 종료조건
    if (index == p.size()) {
        
        //초기화
        int time = 0;
        memset(visited, falsesizeof(visited));
        deque<int> dq[2];
 
        //시간 계산
        while (true) {
            
            bool all_People_In_Stair = true;
            for (int i = 0; i < p.size(); i++) {
                if (!visited[i]) {
                    all_People_In_Stair = false;
                }
            }
 
            //모든 사람이 계단 안에 들어갔고 && 0번 계단에 사람이 없고 && 1번 계단에 사람이 없을 경우 -> 종료
            if (all_People_In_Stair && dq[0].empty() && dq[1].empty()) {
                break;
            }
 
            //각각 사람 탐색
            for (int i = 0; i < p.size(); i++) {
                //계단에 이미 들어간 사람일 경우, continue
                if (visited[i]) {
                    continue;
                }
 
                //계단에 도착하였을 시, 계단 deque에 "계단 길이" 넣어주기
                if (p[i].distance == time) {
                    if (p[i].stairNum == 0) {
                        dq[0].push_back(s[0].stairLength);
                        visited[i] = true;
                    }
                    else {
                        dq[1].push_back(s[1].stairLength);
                        visited[i] = true;
                    }
                }
            }
 
            //2개 계단 모두 탐색
            for (int i = 0; i < 2; i++) {
 
                //계단에 사람이 있다면
                if (!dq[i].empty()) {
 
                    //계단 deque에 사람이 4명 이상일 경우
                    if (dq[i].size() >= 4) {
 
                        //앞의 3명만 움직이기
                        for (int j = 0; j < 3; j++) {
                            dq[i][j]--;
                        }
                    }
                    //계단 deque에 사람이 3명 이하일 경우
                    else {
 
                        //계단에 있는 사람 전부 움직이기
                        for (int j = 0; j < dq[i].size(); j++) {
                            dq[i][j]--;
                        }
                    }
 
                    for (int j = 0; j < dq[i].size(); j++) {
 
                        //계단을 다 내려간 사람이 있을 경우
                        if (dq[i][j] == 0) {
 
                            //계단 deque에서 제거
                            dq[i].pop_front();
 
                            //index 맞춰주기
                            j--;
                        }
                    }
                }
            }
 
            //시간 증가
            time++;
        }
 
        //결과 저장
        if (res == -1 || time < res) {
            res = time;
        }
 
        //종료
        return;
    }
 
    //각 사람마다 0번 계단 또는 1번 계단 선택
    for (int i = 0; i <= 1; i++) {
        //계단 번호 저장
        p[index].stairNum = i;
        //계단 과의 거리 저장
        p[index].distance = abs(p[index].x - s[i].x) + abs(p[index].y - s[i].y);
 
        go(index + 1);
    }
    return;
}
 
int main() {
    int test_case;
    int T;
 
    cin >> T;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //초기화
        memset(map, 0sizeof(map));
        res = -1;
        p.clear();
        s.clear();
 
        //입력
        cin >> N;
 
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> map[i][j];
 
                //사람일 경우, 사람 벡터에 저장
                if (map[i][j] == 1) {
                    p.push_back({ i,j,0,0 });
                }
                //계단일 경우, 계단 벡터에 저장
                else if (map[i][j] > 1) {
                    s.push_back({ i,j,map[i][j] });
                }
            }
        }
 
        //각 사람마다 0번 계단 또는 1번 계단 선택(재귀함수 이용) 후 시간 계산
        go(0);
 
        //출력
        cout << "#" << test_case << " " << res + 1 <<"\n";
 
        
        /*결과에 '+1'을 해준 이유는 계단에 도착한 사람이 바로 계단에 들어가서 그렇습니다*/
        /*문제에서 주어진 대로 정확히 구현하지 못한 코드입니다. 참고로만 봐주시면 감사하겠습니다 :)*/
    }
 
    return 0;
}
 
 

 

재귀함수와 구현에 대해 알아볼 수 있는 문제였습니다.

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV597vbqAH0DFAVl

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 군집의 이동에 따라 군집의 소멸과 합쳐짐을 관리한다.

2. 해당 시간이 지난 후, 남은 미생물 수를 출력한다.

<해법>

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include <iostream>
#include <vector>
using namespace std;
 
struct grp {
    int x, y;
    int cnt;
    int dir;
};
 
int di[] = { 0,-1,1,0,0 };
int dj[] = { 0,0,0,-1,1 };
 
int N, M, K;
//군집 관리 벡터
vector<grp> v;
//군집 이동 맵
vector<int> map[100][100];
 
int main() {
 
    int test_case;
    int T;
 
    cin >> T;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //사용할 변수 초기화
        int res = 0;
        v.clear();
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                map[i][j].clear();
            }
        }
 
        //입력
        cin >> N >> M >> K;
        for (int i = 0; i < K; i++) {
            int x, y, cnt, dir;
            cin >> x >> y >> cnt >> dir;
            v.push_back({ x,y,cnt,dir });
        }
 
        //M시간 동안 반복
        while (M--) {
 
            //이동 맵 초기화
            for (int i = 0; i < K; i++) {
                if (v[i].cnt > 0) {
                    map[v[i].x][v[i].y].clear();
                }
            }
 
            //군집 이동 => 이동 맵에 저장
            for (int i = 0; i < K; i++) {
                grp tmp = v[i];
 
                if (tmp.cnt == 0) {
                    continue;
                }
                
                tmp.x += di[tmp.dir];
                tmp.y += dj[tmp.dir];
 
                //군집이 약품이 칠해진 셀에 도착할 경우
                if (tmp.x <= 0 || tmp.y <= 0 || tmp.x >= N - 1 || tmp.y >= N - 1) {
                    tmp.cnt /= 2;
                    if (tmp.dir % 2 == 0) {
                        tmp.dir--;
                    }
                    else {
                        tmp.dir++;
                    }
                }
 
                //군집에 미생물이 있을 경우만 이동 맵에 저장
                if (tmp.cnt > 0) {
                    map[tmp.x][tmp.y].push_back(i);
                }
                v[i] = tmp;
            }
 
            //이동 맵 => 군집 관리 벡터 저장
            for (int i = 0; i < K; i++) {
 
                if (v[i].cnt == 0) {
                    continue;
                }
 
                int x = v[i].x; 
                int y = v[i].y;
 
                //한 지점에 2개 이상의 군집이 모여 있을 경우
                if (map[x][y].size() > 1) {
 
                    int sum = 0;
                    int maxGrp = 0;
                    int maxCnt = 0;
 
                    for (int j = 0; j < map[x][y].size(); j++) {
                        //총 미생물 수 구하기
                        sum += v[map[x][y][j]].cnt;
 
                        //미생물 수가 가장 많은 군집의 index를 찾기
                        if (v[map[x][y][j]].cnt > maxCnt) {
                            maxGrp = map[x][y][j];
                            maxCnt = v[map[x][y][j]].cnt;
                        }
                        v[map[x][y][j]].cnt = 0;
                    }
                    v[maxGrp].cnt = sum;
                }
            }
        }
        
        //결과 저장
        for (int i = 0; i < v.size(); i++) {
            if (v[i].cnt > 0) {
                res += v[i].cnt;
            }
        }
 
        //출력
        cout << "#" << test_case << " " << res << "\n";
    }
}
 
 

구현에 대해 알아볼 수 있는 문제였습니다.

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV7I5fgqEogDFAXB

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 입력받은 4X4 배열에서 한 칸씩 시작한다.

2. 각 칸에서 갈 수 있는 4방향으로 계속 가면서 7자리의 숫자를 만든다.

3. 모든 칸에서의 탐색을 끝내고 결과를 출력한다.

<해법>

1. 7자리 숫자를 만드는 방법.

=> 이 문제를 처음에 만들어지는 수를 string으로 접근하였는데 시간 초과가 해결되지 않았습니다. 그래서 int로 접근하였습니다.

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
 
struct pos {
    int x, y;
};
 
int di[] = { -1,0,1,0 };
int dj[] = { 0,1,0,-1 };
 
int map[4][4];
bool words[10000000];
int res;
 
bool inner(int x, int y) {
    if (x < 0 || y < 0 || x >= 4 || y >= 4) {
        return false;
    }
    return true;
}
 
void go(pos cur, int word, int moveCnt) {
 
    //숫자 7개 완성 - 종료
    if (moveCnt == 7) {
        words[word] = true;
        return;
    }
 
    //기존 단어에 10을 곱해 한 자릿수 올려주고, 현재 좌표 값 더하기
    word *= 10;
    word += map[cur.x][cur.y];
 
    //4방향 중 갈 수 있는 곳으로 탐색
    for (int i = 0; i < 4; i++) {
        pos nxt = cur;
 
        nxt.x += di[i];
        nxt.y += dj[i];
 
        if (!inner(nxt.x, nxt.y)) {
            continue;
        }
 
        go(nxt, word, moveCnt + 1);
    }
}
 
int main() {
 
    int test_case;
    int T;
 
    cin >> T;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //사용할 변수 초기화
        memset(words, falsesizeof(words));
        res = 0;
 
        //입력
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                cin >> map[i][j];
            }
        }
 
        //각 칸마다 재귀함수
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                pos str = { i,j };
                go(str, 00);
            }
        }
 
        //결과 카운트 및 출력
        int res = 0;
        for (int i = 0; i < 10000000; i++) {
            if (words[i]) {
                res++;
            }
        }
        cout << "#" << test_case << " " << res << "\n";
    }
    return 0;
}
 

 

재귀함수에 대해 알아볼 수 있는 문제였습니다.

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV15FZuqAL4CFAYD

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 암호코드가 포함된 2차원 배열을 입력받는다.

2. 입력받은 배열 중에서 암호코드를 찾는다.

3. 찾은 암호코드를 숫자 암호코드로 변환한다.

4. 숫자암호코드가 정상적인 암호코드인지 판별하고 출력한다.

<해법>

1. 2차원 배열에서 암호코드를 찾는 방법.

=> 2진수로된 암호코드 숫자들은 모두 '1'로 끝납니다. 따라서 주어진 2차원 배열을 뒤에서부터 검사하여 1을 찾은 후, 그 좌표부터 앞 56숫자는 모두 암호코드가 됩니다.

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <iostream>
using namespace std;
 
int code[10][7= {
    {0,0,0,1,1,0,1}, //0
    {0,0,1,1,0,0,1}, //1
    {0,0,1,0,0,1,1}, //2
    {0,1,1,1,1,0,1}, //3
    {0,1,0,0,0,1,1}, //4
    {0,1,1,0,0,0,1}, //5
    {0,1,0,1,1,1,1}, //6
    {0,1,1,1,0,1,1}, //7
    {0,1,1,0,1,1,1}, //8
    {0,0,0,1,0,1,1}  //9
};
 
int N, M;
int arr[50][100];
int codeBit[56];
int codeNum[8];
int res;
 
int main() {
 
    int test_case;
    int T;
 
    cin >> T;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //사용할 변수 초기화
        res = 0;
 
        //입력
        cin >> N >> M;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                scanf_s("%1d"&arr[i][j]);
            }
        }
 
        //비트코드 찾기
        bool codeFind = false;
        for (int i = 0; i < N; i++) {
            for (int j = M - 1; j >= 0; j--) {
                if (arr[i][j] == 1) {
                    codeFind = true;
                    for (int k = 0; k < 56; k++) {
                        codeBit[k] = arr[i][j - 55 + k];
                    }
                    break;
                }
            }
            if (codeFind) {
                break;
            }
        }
 
        //비트코드 숫자코드로 변환
        for (int i = 0; i < 8; i++) {
            for (int k = 0; k < 10; k++) {
                bool isSame = true;
                for (int j = 0; j < 7; j++) {
                    if (codeBit[(i * 7+ j] != code[k][j]) {
                        isSame = false;
                        break;
                    }
                }
                if (isSame) {
                    codeNum[i] = k;
                    break;
                }
            }
        }
 
        //숫자코드 계산
        int sum = (codeNum[0+ codeNum[2+ codeNum[4+ codeNum[6]) * 3 + codeNum[1+ codeNum[3+ codeNum[5+ codeNum[7];
 
        //정상적인 암호코드일 경우, 모든 숫자 더하기
        if (sum % 10 == 0) {
            for (int i = 0; i < 8; i++) {
                res += codeNum[i];
            }
        }
 
        //출력
        cout << "#" << test_case << " " << res << "\n";
    }
}
 

 

구현에 대해 알아볼 수 있는 문제였습니다.

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV5Pq-OKAVYDFAUq

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 초기 배열을 입력받는다.

2. 90도 돌린 배열 = 초기 배열을 90도 돌린다.

3. 180도 돌린 배열 = 90도 돌린 배열을 90도 돌린다.

4. 270도 돌린 배열 = 180도 돌린 배열을 90도 돌린다.

5. 결과를 출력한다.

<해법>

1. 배열을 90도 돌리는 방법을 구하고, 90도 회전을 반복 진행하여 모든 결과를 구합니다.

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
63
64
#include <iostream>
using namespace std;
 
int N;
int tmp[7][7];
 
int res_90[7][7];
int res_180[7][7];
int res_270[7][7];
 
int main() {
 
    int test_case;
    int T;
 
    cin >> T;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //입력
        cin >> N;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cin >> tmp[i][j];
            }
        }
 
        //입력받은 배열 90도 돌리기
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                res_90[j][(N - 1- i] = tmp[i][j];
            }
        }
        //90도 돌린 배열 90도 돌리기
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                res_180[j][(N - 1- i] = res_90[i][j];
            }
        }
        //180도 돌린 배열 90도 돌리기
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                res_270[j][(N - 1- i] = res_180[i][j];
            }
        }
 
        //출력
        cout << "#" << test_case << "\n";
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cout << res_90[i][j];
            }
            cout << " ";
            for (int j = 0; j < N; j++) {
                cout << res_180[i][j];
            }
            cout << " ";
            for (int j = 0; j < N; j++) {
                cout << res_270[i][j];
            }
            cout << "\n";
        }
    }
}
 

 

2차원 배열에 대해 알아볼 수 있는 문제였습니다.

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AV134DPqAA8CFAYh

 

SW Expert Academy

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

swexpertacademy.com

<풀이>

1. 각 빌딩들의 높이를 입력받는다.

2. 각 빌딩마다 조망에 영향을 주는 4개의 빌딩(왼쪽 두 개, 오른쪽 두 개)의 빌딩 중 가장 높은 빌딩 높이를 구한다.

3. 만약 가장 높은 빌딩의 높이보다 현재 빌딩의 높이가 더 높다면, 높이의 차이만큼 조망권이 확보되는 세대가 생긴다.

4. 위의 세대들을 합하여 결과를 출력한다.

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
#include <iostream>
#include <algorithm>
using namespace std;
 
int main() {
 
    int test_case;
    int T;
 
    T = 10;
 
    for (test_case = 1; test_case <= T; test_case++) {
 
        //사용할 변수 초기화
        int N;
        int building[1000];
        int res = 0;
 
        //입력
        cin >> N;
        for (int i = 0; i < N; i++) {
            cin >> building[i];
        }
 
        //각 빌딩마다 탐색
        for (int i = 2; i < N - 2; i++) {
 
            //빌딩에 영향을 주는 4개 빌딩 중 가장 높은 높이
            int maxHeight = max(max(building[i - 2], building[i - 1]), max(building[i + 1], building[i + 2]));
 
            //빌딩이 가장 높은 높이보다 높다면, 결과 저장
            if (maxHeight < building[i]) {
                res += building[i] - maxHeight;
            }
        }
 
        //출력
        cout << "#" << test_case << " " << res << "\n";
    }
}
 

 

구현에 대해 알아볼 수 있는 문제였습니다.

+ Recent posts