코드 낙서장

[백준] 17140 이차원 배열과 연산

latter2005 — Tue, 13 Apr 2021 22:32:53 +0900

17140번: 이차원 배열과 연산

첫째 줄에 r, c, k가 주어진다. (1 ≤ r, c, k ≤ 100) 둘째 줄부터 3개의 줄에 배열 A에 들어있는 수가 주어진다. 배열 A에 들어있는 수는 100보다 작거나 같은 자연수이다.

www.acmicpc.net

문제 확인

해시를 이용한 구현 문제입니다.

풀이

문제의 두 연산을 구분하기 위해 행, 열의 최대 길이를 미리 기록 해 둡니다.

R 연산: 배열 A의 모든 행에 대해서 정렬을 수행한다. 행의 개수 ≥ 열의 개수인 경우에 적용된다.
C 연산: 배열 A의 모든 열에 대해서 정렬을 수행한다. 행의 개수 < 열의 개수인 경우에 적용된다.

연산에서 해당 수, 수가 등장한 횟수 모두 알아야 하므로 hash를 사용하여 간단하게 풀 수 있습니다. unordered_map을 사용하여 풀 수 있지만 이를 직접 정렬은 불가능하며 vector로 변환한 후 정렬하여 풀 수 있습니다.

R연산의 경우 각 행에서 등장한 원소들을 등장 횟수와 함께 기록하고 C 연산의 경우 열에서 원소, 등장 횟수를 기록하고 이를 등장 횟수 기준으로 정렬한 후 존재하는 원소만을 기록합니다.

기록하면서 행, 열의 최댓값을 구하고 이를 기록하여 다음 연산에 사용합니다.

코드

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

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef struct pir {
    int idx, cnt;
}pir;
 
int main() {
    int r, c, k;
    scanf("%d%d%d", &r, &c, &k);
    r--, c--;
    int ary[100][100] = { 0 };
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            scanf("%d", &ary[i][j]);
 
    int mx_x = 3, mx_y = 3, t = 0;
 
    pir hsh[100][101];
 
    while (t <= 100 && ary[r][c] != k) {
        memset(hsh, 0, sizeof hsh);
        if (mx_x >= mx_y) {//R연산
            
            for (int i = 0; i < mx_x; i++) {
                for (int j = 0; j < mx_y; j++) {
                    if (ary[i][j]) {//0 제외
                        hsh[i][ary[i][j]].idx = ary[i][j];//등장한 수 기록
                        ++hsh[i][ary[i][j]].cnt;//횟수 기록
                    }
                }
            }
 
            memset(ary, 0, sizeof ary);
            for(int i=0;i<mx_x;i++)
            sort(hsh[i], hsh[i] + 101, [](const pir &a, const pir &b)->bool {
                if (!a.idx) return false;//0의 경우 등장하지 않거나 0 값이므로 고려하지 않음
                if (!b.idx) return true;
                if (a.cnt != b.cnt)return a.cnt < b.cnt;//등장횟수 비교
                return a.idx < b.idx;//횟수가 같은 경우 수를 비교
            });
 
            int ty = 0;
            for (int i = 0; i < mx_x; i++) {
                int cur = 0;
                while (cur < 50 && hsh[i][cur].idx) {//결과를 저장
                    ary[i][cur * 2] = hsh[i][cur].idx;
                    ary[i][cur * 2 | 1] = hsh[i][cur].cnt;
                    cur++;
                }
                ty = ty < cur ? cur : ty;
            }
            mx_y = ty*2;//변경된 열 길이 반영
 
        }
        else {//C연산
            for (int i = 0; i < mx_y; i++) {
                for (int j = 0; j < mx_x; j++) {
                    if (ary[j][i]) {
                        hsh[i][ary[j][i]].idx = ary[j][i];
                        ++hsh[i][ary[j][i]].cnt;
                    }
                }
            }
 
            memset(ary, 0, sizeof ary);
            for (int i = 0; i < mx_y; i++)
                sort(hsh[i], hsh[i] + 101, [](const pir &a, const pir &b)->bool {
                if (!a.idx) return false;
                if (!b.idx) return true;
                if (a.cnt != b.cnt)return a.cnt < b.cnt;
                return a.idx < b.idx;
            });
 
            int tx = 0;
            for (int i = 0; i < mx_y; i++) {
                int cur = 0;
                while (cur < 50 && hsh[i][cur].idx) {
                    ary[cur * 2][i] = hsh[i][cur].idx;
                    ary[cur * 2 | 1][i] = hsh[i][cur].cnt;
                    cur++;
                }
                tx = tx < cur ? cur : tx;
            }
            mx_x = tx*2;
        }
 
        t++;
    }
    printf("%d", t > 100 ? -1 : t);
}
Colored by Color Scripter

cs

[프로그래머스] 셔틀 버스

latter2005 — Sat, 10 Apr 2021 17:30:34 +0900

2018 카카오 채용 코딩 테스트 문제입니다.

코딩테스트 연습 - [1차] 셔틀버스

10 60 45 ["23:59","23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59", "23:59"] "18:00"

programmers.co.kr

문제 확인

구현 문제입니다.

풀이

문제에서 가장 중요한 요소는 마지막 버스에 자리의 여부입니다.

마지막 버스에 자리가 남는 경우 : 마지막 버스의 도착 시간에 탑승하면 됩니다.
마지막 버스에 자리가 없는 경우 : 기다리는 사람들 중 m 번째 사람보다 1분 전에 도착하면 됩니다.

timetable을 읽으면서 마지막 버스 직전까지 기다리는 사람을 구해두고 마지막 버스에서 기다리는 사람에 따라 결과를 내면 됩니다.

코드

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

#include <string>
#include <vector>
#include <algorithm>
using namespace std;
 
int time_to_int(string &t) {
    return (t[0] - '0') * 600 + (t[1] - '0') * 60 + (t[3] - '0') * 10 + (t[4] - '0');
}
string int_to_time(int t) {
    char tmp[6];
    sprintf(tmp, "%02d:%02d", t / 60, t % 60);
    return string(tmp);
}
string solution(int n, int t, int m, vector<string> timetable) {
    string answer = "";
 
    int ary[2000], size = timetable.size();
    for (int i = 0; i < size; i++)
        ary[i] = time_to_int(timetable[i]);
    sort(ary, ary + size);
 
    //현재 시각, 기다리는 사람, ary index
    int cur_time = 9 * 60, wait = 0, i = 0;
 
    for (;n > 1; cur_time += t) {//마지막 버스 이전까지
        for (; i < size && ary[i] <= cur_time; ++wait, ++i);
        
        wait = wait > m ? wait - m : 0;//최대 m명까지 탑승
        n--;
    }
    for (; i < size && ary[i] <= cur_time; ++wait, ++i);//마지막 버스에서 기다리는 사람 계산
 
    if (wait < m)
        return int_to_time(cur_time);//자리가 있으면 버스 도착 시간에 탑승
 
 
    return int_to_time(ary[i - (wait - m) - 1]-1);//자리가 없으면 기다리는 사람 중 (m 번째 사람이 온 시간 - 1)분에 탑승
}
 
int main() {
    vector<string> time = { "09:00","09:00","09:01","09:01" };
    solution(3, 2, 2, time);
}
Colored by Color Scripter

cs

정확성 테스트

테스트 1 〉	통과 (0.02ms, 3.77MB)
테스트 2 〉	통과 (0.02ms, 3.78MB)
테스트 3 〉	통과 (0.02ms, 3.96MB)
테스트 4 〉	통과 (0.02ms, 3.98MB)
테스트 5 〉	통과 (0.02ms, 3.77MB)
테스트 6 〉	통과 (0.02ms, 3.95MB)
테스트 7 〉	통과 (0.04ms, 3.8MB)
테스트 8 〉	통과 (0.02ms, 3.95MB)
테스트 9 〉	통과 (0.02ms, 3.95MB)
테스트 10 〉	통과 (0.02ms, 3.89MB)
테스트 11 〉	통과 (0.02ms, 3.94MB)
테스트 12 〉	통과 (0.03ms, 3.94MB)
테스트 13 〉	통과 (0.03ms, 3.93MB)
테스트 14 〉	통과 (0.02ms, 3.91MB)
테스트 15 〉	통과 (0.02ms, 3.95MB)
테스트 16 〉	통과 (0.02ms, 3.76MB)
테스트 17 〉	통과 (0.04ms, 3.96MB)
테스트 18 〉	통과 (0.03ms, 3.79MB)
테스트 19 〉	통과 (0.03ms, 3.93MB)
테스트 20 〉	통과 (0.03ms, 3.95MB)
테스트 21 〉	통과 (0.03ms, 3.86MB)
테스트 22 〉	통과 (0.12ms, 3.9MB)
테스트 23 〉	통과 (0.11ms, 3.9MB)
테스트 24 〉	통과 (0.04ms, 3.95MB)

채점 결과

정확성: 100.0

합계: 100.0 / 100.0

[프로그래머스] 프렌즈4블록

latter2005 — Sat, 10 Apr 2021 17:18:30 +0900

2018 카카오 채용 코딩 테스트 문제입니다.

코딩테스트 연습 - [1차] 프렌즈4블록

프렌즈4블록 블라인드 공채를 통과한 신입 사원 라이언은 신규 게임 개발 업무를 맡게 되었다. 이번에 출시할 게임 제목은 "프렌즈4블록". 같은 모양의 카카오프렌즈 블록이 2 ×2 형태로 4개가 붙

programmers.co.kr

문제 확인

구현 문제입니다.

풀이

3개의 과정을 정확하게 나누어 구현하여야 합니다.

지울 블록들을 찾습니다. : 조건문
찾은 블록들을 한 번에 지웁니다. : visited 배열 활용
빈 공간들을 블록을 떨어뜨려 채웁니다. : 인덱싱

3번 단계에서 메모리 접근 시간을 빠르게 하기 위해 배열을 전치시켜 떨어뜨릴 때 ary[i][0~j] 한 줄에서 해결할 수 있도록 합니다. 또한 0번 인덱스부터 접근할 수 있도록 전치시킬 때 회전시켜 입력할 수 있도록 합니다.

for (int i = 0; i < m; i++)
	for (int j = 0; j < n; j++)
		ary[j][m - i - 1] = board[i][j];

1번 과정은 간단하게 빈 공간이 아닌 블록이 오른쪽, 아래쪽, 오른쪽 아래 대각선 방향의 블록이 모두 같다면 지울 블록으로 선택합니다. 정사각형 형태의 4개의 블록을 검사하므로 n-1, m-1 이전 범위까지만 탐색하면 됩니다.

for (int i = 0; i < n - 1; i++) {
	for (int j = 0; j < m - 1; j++) {
		if (ary[i][j] && ary[i][j] == ary[i][j + 1] && ary[i][j] == ary[i + 1][j] && ary[i][j] == ary[i + 1][j + 1]) {
			visited[i][j] = visited[i][j + 1] = visited[i + 1][j] = visited[i + 1][j + 1] = 1;
			f = 1;
		}
	}
}

변수 f는 지워야 할 블록이 생기면 3번까지 진행한 후 한번 더 이 과정을 진행해야 하기 위한 변수입니다.

2번 과정은 간단하게 visited가 체크되어 있는 배열을 지워줍니다.

for (int i = 0; i < n; i++)
	for (int j = 0; j < m; j++)
		if (visited[i][j]) {
			ary[i][j] = 0;
			answer++;
		}
memset(visited, 0, sizeof visited);

3번 과정에선 가장 먼저 나오는 빈 공간의 위치를 pos로 둔 후 이후에 나오는 블록들을 pos 위치에 순서대로 채워줍니다.

for (int i = 0; i < n; i++) {
	int pos = 0;
	while (pos < m && ary[i][pos])pos++;
	for (int j = pos + 1; j < m; j++) {
		if (ary[i][j]) {
				ary[i][pos++] = ary[i][j];
			ary[i][j] = 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
47
48
49
50
51
52
53
54
55
56
57
58

#include <iostream>
 
#include <string>
#include <vector>
 
using namespace std;
 
int solution(int m, int n, vector<string> board) {
    int answer = 0;
    char ary[30][30] = { 0 };
 
    for (int i = 0; i < m; i++)
        for (int j = 0; j < n; j++)
            ary[j][m - i - 1] = board[i][j];//블록을 떨어뜨릴 때 매모리 접근성 향상
 
    bool visited[30][30] = { 0 };
    bool f = 1;
    while (f) {//지운 블록이 없을 때까지
        f = 0;
        for (int i = 0; i < n - 1; i++) {//검사
            for (int j = 0; j < m - 1; j++) {
                
                if (ary[i][j] && ary[i][j] == ary[i][j + 1] && ary[i][j] == ary[i + 1][j] && ary[i][j] == ary[i + 1][j + 1]) {
                    visited[i][j] = visited[i][j + 1] = visited[i + 1][j] = visited[i + 1][j + 1] = 1;
                    f = 1;
                }
            }
        }
        if (f) {
            for (int i = 0; i < n; i++)//블록 지우기
                for (int j = 0; j < m; j++)
                    if (visited[i][j]) {
                        ary[i][j] = 0;
                        answer++;
                    }
            memset(visited, 0, sizeof visited);
 
            for (int i = 0; i < n; i++) {//빈공간 떨어뜨리기
                int pos = 0;
                while (pos < m && ary[i][pos])pos++;
                for (int j = pos + 1; j < m; j++) {
                    if (ary[i][j]) {
                        ary[i][pos++] = ary[i][j];
                        ary[i][j] = 0;
                    }    
                }
            }
        }
    }
    
    return answer;
}
 
int main() {
    vector<string> t = { "ttbb", "aacc","aabb", "zzcc","aabb", "aacc" };
    solution(6, 4, t);
 
}
Colored by Color Scripter

cs

정확성 테스트

테스트 1 〉	통과 (0.01ms, 3.93MB)
테스트 2 〉	통과 (0.01ms, 3.72MB)
테스트 3 〉	통과 (0.01ms, 3.95MB)
테스트 4 〉	통과 (0.01ms, 3.95MB)
테스트 5 〉	통과 (0.36ms, 3.94MB)
테스트 6 〉	통과 (0.04ms, 3.96MB)
테스트 7 〉	통과 (0.01ms, 3.97MB)
테스트 8 〉	통과 (0.01ms, 3.96MB)
테스트 9 〉	통과 (0.01ms, 3.93MB)
테스트 10 〉	통과 (0.01ms, 3.96MB)
테스트 11 〉	통과 (0.02ms, 3.94MB)

채점 결과

정확성: 100.0

합계: 100.0 / 100.0

[백준] 14890 경사로

latter2005 — Thu, 8 Apr 2021 03:06:10 +0900

14890번: 경사로

첫째 줄에 N (2 ≤ N ≤ 100)과 L (1 ≤ L ≤ N)이 주어진다. 둘째 줄부터 N개의 줄에 지도가 주어진다. 각 칸의 높이는 10보다 작거나 같은 자연수이다.

www.acmicpc.net

문제 확인

구현 문제입니다.

풀이

세로로 이동하는 경우 입력받은 배열을 전치시켜 계산하여 메모리 접근 상 더 좋은 결과를 얻을 수 있습니다.

ary[i-1] , ary[i]를 비교하여 3가지 경우로 나눌 수 있습니다.

ary[i-1] == ary[i] : 경사로를 놓을 수 있는 공간이 하나 늘어납니다. => count++
ary[i-1] + 1 == ary[i] : 경사로가 ary[i] 왼쪽에 필요하며 이전 경사로를 놓을 수 있는 공간이 L개 이상인 경우 이동이 가능합니다. => if(count >= L) count = 1
ary[i-1] - 1 == ary[i] : 경사로가 ary[i] 오른쪽에 필요하며 다음 경사로가 나오기 전까지 L개의 공간이 더 필요합니다. => if(count >= 0) count = 1 - L

2의 경우에는 이전에 공간이 1번 경우에 의하여 구할 수 있으며 3의 경우에는 경사로를 놓은 후 L개의 추가 공간이 필요하므로 마지막 가능 여부에서 count가 음수일 시 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

#include <cstdio>
 
int main() {
    int n, l, res = 0;
    scanf("%d%d", &n, &l);
 
    int ary[100][100], tary[100][100];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            scanf("%d", &ary[i][j]);
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            tary[j][i] = ary[i][j];
    for (int i = 0; i < n; i++) {
        int cnt = 1, j = 1;
        for (; j < n; j++) {
            if (ary[i][j - 1] == ary[i][j])    ++cnt;
            else if (ary[i][j - 1] + 1 == ary[i][j] && cnt >= l)    
                cnt = 1;
            else if (ary[i][j - 1] - 1 == ary[i][j] && cnt >= 0)    
                cnt = 1-l;
            else    break;
        }
        if (j == n && cnt>=0)
            res++;
    }
    for (int i = 0; i < n; i++) {
        int cnt = 1, j = 1;
        for (; j < n; j++) {
            if (tary[i][j - 1] == tary[i][j])    ++cnt;
            else if (tary[i][j - 1] + 1 == tary[i][j] && cnt >= l)    
                cnt = 1;
            else if (tary[i][j - 1] - 1 == tary[i][j] && cnt >= 0)    
                cnt = 1-l;
            else    break;
        }
        if (j == n && cnt >= 0)
            res++;
    }
    printf("%d\n", res);
}
 
Colored by Color Scripter

cs

[백준] 1007 벡터 매칭

latter2005 — Thu, 8 Apr 2021 00:52:05 +0900

1007번: 벡터 매칭

평면 상에 N개의 점이 찍혀있고, 그 점을 집합 P라고 하자. 집합 P의 벡터 매칭은 벡터의 집합인데, 모든 벡터는 집합 P의 한 점에서 시작해서, 또 다른 점에서 끝나는 벡터의 집합이다. 또, P에 속

www.acmicpc.net

문제 확인

벡터의 특성과 벡터를 선택하는 조합 문제입니다.

풀이

문제에서 주의해야 할 점은 벡터의 합의 길이이므로 (0, 10), (0, -10) 벡터의 합은 (0, 0)이므로 길이는 0이 됩니다.

따라서 벡터의 합을 구할 때 단순히 sqrt((x1 - x2)^2 + (y1 - y2)^2)로 구하면 틀리게 됩니다.

전체 벡터 합을 구한 후 선택한 벡터들의 차를 이용하여 벡터의 합을 빠른 시간에 구할 수 있습니다.

(x1, y1), (x2, y2) ... (x10, y10)

total = (x1 + x2 + ..+.. + x10, y1 + y2 + .. + y10) => N/2개 선택 : total - (v ...)

= (x1 + x2 .. x5 - x6 - x7 .. x10, (y1 + y2 .. x5 - y6 - y7 .. y10)

해당 과정을 조합을 구하는 dfs를 통해 뺄 점들을 N/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

#include <cstdio>
#include <cmath>
 
typedef struct pir {
    int x, y;
};
pir ary[20], total;
int n;
double mn;
void dfs(int cur, int idx, int x, int y) {
    if (cur) {
        for (int i = idx; i <= n - cur; i++)
            dfs(cur - 1, i + 1, x + ary[i].x, y + ary[i].y);
        return;
    }
    double t = sqrt(pow(total.x - (x << 1), 2) + pow(total.y - (y << 1), 2));
    if (t < mn)mn = t;
 
}
 
int main() {
    int t;
    scanf("%d", &t);
 
    while (t--) {
        total = {}; mn = 1e308;
        scanf("%d", &n);
        for (int i = 0; i < n; i++) {
            scanf("%d%d", &ary[i].x, &ary[i].y);
            total.x += ary[i].x;
            total.y += ary[i].y;
        }
        dfs((n >> 1) - 1, 1, ary[0].x, ary[0].y);
        printf("%.7lf\n", mn);
    }
}
Colored by Color Scripter

cs

[프로그래머스][JAVA] 뉴스 클러스터링

latter2005 — Fri, 2 Apr 2021 02:58:21 +0900

2018 카카오 채용 코딩 테스트 문제입니다.

코딩테스트 연습 - [1차] 뉴스 클러스터링

뉴스 클러스터링 여러 언론사에서 쏟아지는 뉴스, 특히 속보성 뉴스를 보면 비슷비슷한 제목의 기사가 많아 정작 필요한 기사를 찾기가 어렵다. Daum 뉴스의 개발 업무를 맡게 된 신입사원 튜브

programmers.co.kr

문제 확인

Map 컨테이너 활용 문제입니다.

풀이

대소문자 구분을 하지 않기 때문에 처음 입력받은 두 문자열을 toLowerCase() 메서드를 통해 모두 소문자로 만들어줍니다.

Map 컨테이너를 통해 다중집합 원소들을 처리할 수 있습니다.

Map <원소, 등장 횟수>로 선언하고 해당 원소가 문자열에서 몇 번 등장하였는지 기록합니다.

등장 횟수를 통해 합집합, 교집합 원소의 개수를 알아낼 수 있습니다.

2개의 map에서 등장 횟수 중 큰 값이 합집합이 되고 작은 값이 교집합이 됩니다. 주의해야 할 점은 2개의 Map을 모두 탐색하며 공통 원소가 아니라면 이를 합집합 개수에 추가해주어야 합니다.

코드

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

import java.util.*;
import java.util.Map.Entry;
class Solution {
    public int solution(String str1, String str2) {
        int res;
        str1 = str1.toLowerCase();//모두 소문자로 만들기
        str2 = str2.toLowerCase();
        String key;
        Map<String, Integer> mp1 = new HashMap<String, Integer>(),
                mp2 = new HashMap<String, Integer>();//해쉬맵 사용 key : 원소, value : 등장횟수
        for(int i=0;i<str1.length()-1;i++) {
            
            if(Character.isLowerCase(str1.charAt(i)) && Character.isLowerCase(str1.charAt(i+1))) {
                key = str1.substring(i, i+2);
                if(mp1.containsKey(key))
                    mp1.put(key, mp1.get(key) + 1);//이미 있으면 +1
                else
                    mp1.put(key, 1);//없으면 새로 생성
            }
        }
        for(int i=0;i<str2.length()-1;i++) {
            if(Character.isLowerCase(str2.charAt(i)) && Character.isLowerCase(str2.charAt(i+1))) {
                key = str2.substring(i, i+2);
                if(mp2.containsKey(key))
                    mp2.put(key, mp2.get(key) + 1);
                else
                    mp2.put(key, 1);
            }
        }
        double inter = 0, union = 0;
        for(Entry<String, Integer> entry : mp1.entrySet()) {
            key = entry.getKey();
            int val = entry.getValue();
            if(mp2.containsKey(key)){//공통 원소가 있다면
                int tmp = mp2.get(key);
                if(val > tmp) {inter += tmp; union+=val;}//교집합 : 적은값, 합집합 : 큰값
                else {inter += val; union+=tmp;}
            }
            else//공통 원소가 없다면 합집합만 추가
                union+=val;
        }
        for(Entry<String, Integer> entry : mp2.entrySet()) {//str2의 원소들을 합집합에 추가
            if(!mp1.containsKey(entry.getKey()))//str1 검사하면서 추가했으므로 str1에 없는 원소만을 추가
                union+=entry.getValue();
        }
        if(union==0)return 65536;//합집합 개수가 0
        return (int)(inter / union * 65536);
    }
}
Colored by Color Scripter

cs

[운영체제] Inter Process Communication

latter2005 — Fri, 2 Apr 2021 00:03:57 +0900

Inter-Process Communication(IPC)

프로세스 간 통신이란 프로세스가 서로 데이터를 주고받는 방법, 경로 등을 의미합니다. 커널의 디자인에 따라 마이크로 커널, 나노 커널 등 통신이 많이 일어나는 디자인의 경우 IPC 방식이 성능을 크게 좌지우지할 수 있습니다.

Shared memory

운영체제의 도움을 받아 일부 영역의 메모리를 여러 프로세스가 동시에 접근할 수 있도록 권한을 받습니다.
프로세스는 공유 메모리를 읽고 쓰면서 프로세스 간 통신을 하게 됩니다.
같은 메모리를 사용하는 환경에서 작동하므로 메모리에 접근하여 값을 변경하면 그 즉시 변경된 값이 반영되어 다른 프로세스들이 접근 시 변경된 값을 얻을 수 있습니다.
처음 메모리에 여러 프로세스가 접근 권한을 부여하는 작업에서만 커널 작업이 필요하고 이후엔 커널 동작이 필요 없습니다.

동작 과정

공유 메모리를 사용할 프로세스들 중 하나의 프로세스가 자신이 부여받은 메모리 영역 중 일부분을 선택합니다.
다른 프로세스 들은 공유할 메모리의 주소를 받아 이를 자신의 메모리 영역에 붙입니다.
운영체제가 해당 프로세스들 간의 메모리 접근 제한을 풀어줍니다.
이후 프로세스들은 공유 메모리를 통해 통신하게 됩니다.

* 운영체제는 더 이상 관여할 필요 없으며 프로세스가 종료 시 메모리를 반환하면 공유 메모리 또한 같이 반환하게 됩니다.

공유 메모리 방식은 생산자-소비자 모델과 유사합니다. 하나의 프로세스가 전송할 내용, 명령 등을 공유 메모리에 담아두고 이를 다른 프로세스들이 받아서 작업하는 구조를 가집니다.

공유 메모리에는 2가지 메모리 버퍼 형태가 있습니다.

Unbounded buffer : 메모리 버퍼의 크기에 제한이 없으며 소비자 프로세스는 새 자원이 만들어질 때까지 기다려야 하며 생산자 프로세스는 항상 새로운 자원을 만들 수 있습니다. 이때 생산자 역할의 프로세스는 공유한 메모리 자원의 크기를 지정하여 이를 함께 소비자 프로세스에 알려주어야 합니다.
Bounded buffer : 메모리 버퍼 크기에 제한이 있으며 소비자 프로세스는 버퍼가 빈 상황이면 새로운 자원이 채워질 때까지 기다리며 생산자 프로세스는 버퍼가 꽉 차 있으면 공간이 남을 때까지 기다려야 합니다.\

코드 예시

왼 : 생산자 프로세스, 오 : 소비자 프로세스

Message passing

데이터가 하나의 메시지가 되어 프로세스 간 통신을 하게 됩니다.
충돌 위험이 없기 때문에 소량의 데이터 전송에 유리합니다.
명령만을 주고받는 분산 시스템, 마이크로/나노 커널 방식에 유리합니다.
공유 메모리 방식과 다르게 같은 환경에 있지 않아도 인터넷을 통해서 메시지를 주고받을 수 있습니다. (소켓)
생산자-소비자 모델의 공유 메모리 방식을 이용하면 동기화 작업이 필요 없지만 메시지 전달 방식은 동기화 작업이 필요한 경우가 많습니다. 비동기, 동기 방식에 따라 결정합니다.

Send, Receive 2가지 명령에 의해 동작합니다.

Direct communication : send, receive 동작이 특정 프로세스를 지정하며 메시지를 직접 주고받습니다.
Indirect communication : 프로세스들 가운데 하나의 시스템, 네트워크 등을 두고 메시지를 중재하며 동작합니다. 직접 전달 방식보다 더 유연하게 동작할 수 있으며 중재 시스템의 구현에 따라 보안성, 성능 등 다양한 처리가 가능해집니다.

메시지 전달 방식은 동기화 작업이 필요합니다. 동기방식과 비동기 방식이 있습니다.

동기(Blocking, Synchronous)

동기 Send : 메시지를 보내고 나면 받는 프로세스에게 메시지가 도착할 때까지 다른 작업을 할 수 없습니다.
동기 Receive : 메시지를 받기 전까지 해당 프로세스는 다른 작업을 하지 않고 멈춰 있어야 합니다.

비동기(Nonblocking, Asynchronous)

비동기 Send : 메시지를 보내고 프로세스는 멈추지 않고 다음 작업을 진행합니다.
비동기 Receive : 메시지를 받으면 해당 메시지가 유효한 내용인지 검사를 하고 처리를 합니다.

Socket

Client-Server 구조에서 통신을 위한 End-Point의 의미입니다.
연결 특성에 따라 1:1, 1:N, N:M 프로세스들이 짝이 되며 각 프로세스들은 Socket이라는 end point를 가지고 socket에 도달한 메시지를 읽어드리는 메시지 전달 방식 인터페이스입니다.
IP 주소와 port 번호를 통해 소켓을 구분합니다. 이를 통해 같은 컴퓨터 내의 프로세스에게 전달도 가능하며 네트워크를 이용해 다른 환경의 프로세스에 전달 또한 가능합니다.
네트워크 망을 통해 작성한 메시지를 IP 주소와 port 번호를 통해 경로를 찾고 전달하게 됩니다.

* 소켓은 IPC 방식이 아닌 IPC를 구현하기 위한 하나의 인터페이스이며 설계에 따라 동기, 비동기 방식 모두 가능합니다.

Pipe

가장 오래된 UNIX 계열 시스템의 IPC 방식이며 모든 UNIX 계열 시스템이 제공합니다.
두 개의 프로세스가 파일 디스크립터(FD)를 통해 메시지를 주고받는 방식입니다.
기본 파이프 통신은 반이중 방식이며 부모, 자식 관계의 프로세스들만 사용이 가능하다는 한계점이 있습니다.

부모 프로세스가 파이프를 생성하고 fork()를 통해 자식 프로세스를 만든 후 자식 프로세스가 부모 프로세스의 파이프를 통해 통신하게 됩니다.

* 별개의 프로세스 간 통신을 위해 Named Pipe(FIFO)가 있으며 다수의 프로세스가 이를 공유하여 통신이 가능합니다. 하지만 기존 파이프와 같이 같은 컴퓨터 환경에서만 동작이 가능합니다.

[프로그래머스][JAVA] 추석 트래픽

latter2005 — Thu, 1 Apr 2021 05:03:57 +0900

2018 카카오 채용 코딩 테스트 문제입니다.

코딩테스트 연습 - [1차] 추석 트래픽

입력: [ "2016-09-15 20:59:57.421 0.351s", "2016-09-15 20:59:58.233 1.181s", "2016-09-15 20:59:58.299 0.8s", "2016-09-15 20:59:58.688 1.041s", "2016-09-15 20:59:59.591 1.412s", "2016-09-15 21:00:00.464 1.466s", "2016-09-15 21:00:00.741 1.581s", "2016-09-1

programmers.co.kr

문제 확인

prefix sum 혹은 스위핑을 통해 풀 수 있습니다.

풀이

처리 시작시간을 1, 처리가 끝난 시간을 -1로 두고 각 점들을 배열에 기록합니다. 이들을 시간 순으로 정렬하여 prefix sum을 통해 현재 지점에서 처리하는 중인 트래픽을 구하고 현재 지점부터 1초 구간 안에 있는 트래픽을 구합니다.

주의해야 할 점은 처리가 끝난 시간에서도 트래픽으로 간주하므로 해당 지점을 계산 시에는 -1 대신 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
47
48
49
50
51
52

import java.util.*;
class node implements Comparable<node>{
    double key;//시각
    int val;//트래픽 시작지점 : 1, 끝지점 -1
    node(double key, int val){
        this.key = key;
        this.val = val;
    }
 
    @Override
    public int compareTo(node t) {//정렬 함수
        if(this.key < t.key)
            return -1;
        else if(this.key != t.key)
            return 1;
        return 0;
    }
}
class Solution {
    public int solution(String[] lines) {
       node[] ary = new node[lines.length << 1];
        int idx = 0;
        for(String t : lines) {
            String[] log = t.split(" ");
            String[] time_log = log[1].split(":");
            double end = Double.parseDouble(time_log[0])*3600 + //작업 끝시간 : line
                    Double.parseDouble(time_log[1])*60 + 
                    Double.parseDouble(time_log[2]);
            double start = end - Double.parseDouble(log[2].replace("s", "")) + 0.001;//작업 시작 시간 
            end = (double)((int)(end * 1000))/1000;
            start = (double)((int)(start * 1000))/1000;//소수점 3자리 까지
            ary[idx++] = new node(start, 1); 
            ary[idx++] = new node(end, -1);
        }
        Arrays.sort(ary);//정렬
        int sum = 0, mx = -1;//sum : 현재 지점에서의 트래픽 : prefix sum
        
        for(int i=0;i<idx;i++) {
            int val = sum + (ary[i].val== 1 ? 1 : 0); //현재 끝 지점인 경우도 포함하기 위해 0
            
            for(int j=i+1;j<idx;j++) {    
                if(ary[j].key>=ary[i].key + 1) break;//1초 이상의 지점이 나오면 break;
                if(ary[j].val==1)//새로운 트래픽 : 1
                    val++;
            }
            mx = val > mx ? val : mx;
            sum += ary[i].val;//prefix sum
        }
        
        return mx;
    }
}
Colored by Color Scripter

cs

정확성 테스트

테스트 1 〉	통과 (1.41ms, 53.3MB)
테스트 2 〉	통과 (23.19ms, 55.1MB)
테스트 3 〉	통과 (39.29ms, 54.8MB)
테스트 4 〉	통과 (1.06ms, 52MB)
테스트 5 〉	통과 (3.90ms, 54.2MB)
테스트 6 〉	통과 (4.48ms, 53.6MB)
테스트 7 〉	통과 (22.61ms, 55.5MB)
테스트 8 〉	통과 (19.48ms, 54.9MB)
테스트 9 〉	통과 (3.52ms, 53.2MB)
테스트 10 〉	통과 (1.36ms, 51.8MB)
테스트 11 〉	통과 (1.22ms, 52.8MB)
테스트 12 〉	통과 (21.89ms, 55.3MB)
테스트 13 〉	통과 (4.25ms, 52.3MB)
테스트 14 〉	통과 (1.01ms, 52.4MB)
테스트 15 〉	통과 (1.01ms, 54.1MB)
테스트 16 〉	통과 (0.99ms, 52.6MB)
테스트 17 〉	통과 (1.05ms, 53.7MB)
테스트 18 〉	통과 (94.80ms, 57.7MB)
테스트 19 〉	통과 (40.20ms, 56.5MB)
테스트 20 〉	통과 (45.46ms, 57.1MB)
테스트 21 〉	통과 (1.03ms, 52.1MB)
테스트 22 〉	통과 (0.92ms, 52.6MB)

채점 결과

정확성: 100.0

합계: 100.0 / 100.0

[백준] 17833 원판 돌리기

latter2005 — Tue, 30 Mar 2021 20:45:13 +0900

17822번: 원판 돌리기

반지름이 1, 2, ..., N인 원판이 크기가 작아지는 순으로 바닥에 놓여있고, 원판의 중심은 모두 같다. 원판의 반지름이 i이면, 그 원판을 i번째 원판이라고 한다. 각각의 원판에는 M개의 정수가 적혀

www.acmicpc.net

문제 확인

구현 문제입니다.

풀이

후에 사용할 평균값을 빠르게 구할 수 있도록 모든 원소의 총합 total, 모든 원소의 개수 cnt를 미리 구해둡니다.

밴치마크를 기록해두고 이를 이용하여 회전 시 모든 배열의 원소를 수정할 필요 없도록 합니다.

밴치마크를 처음 0번째 원소가 있는 위치 즉 북쪽 위치의 원소를 가리키는 인덱스로 둡니다.

초기 상태

회전을 하게 되면 밴치마크가 가리키는 인덱스가 변하게 되며 회전 방향의 반대 방향의 인덱스가 설정됩니다.

가운대 원판을 회전

위와 같이 1번 원판을 시계방향으로 회전하면 밴치마크가 가리켜야 할 값은 3이 되고 이는 인덱스 [3]에 저장되어 있으므로 첫 번째 원판의 밴치마크 값은 3이 됩니다.

따라서 회전방향에 따라 다음과 같이 밴치마크를 수정합니다.

시계방향 d = 0 : bnchmark[i] = (bnchmark[i] + 회전 횟수) % m
반시계 방향 d = 1 : bnchmark[i] = (bnchmark[i] + 회전 횟수 + m) % m

다음으로 인접한 숫자가 같은 경우 이들을 제거해야 하는데 이때 검사할 값은 ary[i][(bnchmark[i] + j) % m] 이 됩니다.

이는 삼항 연산자 (bnchmark[i]+ j < m ? bnchmark[i] + j : bnchmark[i] + j - m)로 나타낼 수 있으므로 이를 사용합니다.

모듈러 연산보다 조건식 연산이 훨씬 빠르므로 이를 이용하는 것이 좋습니다.

모듈러, 삼항 연산자 성능 비교

Is it better to avoid using the mod operator when possible?

I assume that calculating the modulus of a number is a somewhat expensive operation, at least compared to simple arithmetic tests (such as seeing if a number exceeds the length of an array). If thi...

stackoverflow.com

인접 수가 같은 것을 탐색할 때 그래프 탐색을 이용하여도 좋지만 간단하게 2중 루프로 구현할 수 있습니다.

현재 수 ary[i][(bnchmark[i] + j) % m]가 인접한 수와 같은 경우 visited를 체크 해 두고 2중 루프가 끝나면 visited가 체크되어 있는 수 들을 모두 지워주면 됩니다.

인접수 :

ary[i][clockwise(idx, m)] : 시계방향에 위치한 수

ary[i][conterwise(idx, m)] : 반시계방향에 위치한 수

ary[i - 1][find_idx(bnchmark[i - 1], j)] : 현재 원판 바로 뒤의 큰 원판에 위치한 인접한 수

ary[i + 1][find_idx(bnchmark[i + 1], j)] : 현재 원판 앞에 작은 원판에 위치한 인접한 수

find_idx, clockwise, counterwise는 해당 위치의 원소를 찾기 위해 정의한 매크로입니다.

#define clockwise(idx, m) idx < m ? idx+1 : 1 : 시계방향의 좌표
#define counterwise(idx, m) idx > 1 ? idx-1 : m : 반시계 방향의 좌표
#define find_idx(bnck, j) (bnck + j < m ? bnck + j : bnck + j - m) + 1 : 밴치마크에서 j만큼 이동한 수

체크되어 있는 수 들을 지우면서 total과 cnt 값을 수정해 줍니다.

만약 인접한 수가 없어 지우지 않았다면 total과 cnt를 이용하여 평균 이상 인 수들은 -1, 평균 이하인 수 들은 +1 해주고 이 또한 total에 반영해줍니다.

코드

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

#include<cstdio>
#define clockwise(idx, m) idx < m ? idx+1 : 1
#define counterwise(idx, m) idx > 1 ? idx-1 : m
#define find_idx(bnck, j) (bnck + j < m ? bnck + j : bnck + j - m) + 1
int main() {
    int n, m, t;
    scanf("%d %d %d", &n, &m, &t);
 
    int ary[51][51], bnchmark[51] = { 0 };
    int total = 0, cnt = m * n;
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= m; ++j) {
            scanf("%d", &ary[i][j]);
            total += ary[i][j];
        }
 
    bool visited[51][51] = { 0 };
 
    while (t--) {
        int x, d, k;
        scanf("%d %d %d", &x, &d, &k);
        for (int i = x; i <= n; i += x) {
            if (d)//반시계
                bnchmark[i] = (bnchmark[i] + k) % m;
            else//시계
                bnchmark[i] = (bnchmark[i] + m - k) % m;
        }
 
        bool flag = 0;//수를 지워야 하는 경우의 수가 있음
        for (int i = 1; i <= n; ++i)
            for (int j = 0; j < m; ++j) {
                int idx = find_idx(bnchmark[i], j);
                if (ary[i][idx] && (ary[i][idx] == ary[i][clockwise(idx, m)] //시계방향 인접한 수
                    || ary[i][idx] == ary[i][counterwise(idx, m)] ||//반시계방향
                    (i > 1 && ary[i][idx] == ary[i - 1][find_idx(bnchmark[i - 1], j)]) ||//큰 원판 인접한 수
                    (i < n && ary[i][idx] == ary[i + 1][find_idx(bnchmark[i + 1], j)]))) {//작은 원판
 
                    visited[i][idx] = 1;//지워야 할 수 체크
                    flag = 1;
                }
 
            }
 
        if (flag) //지울 수가 있음
            for (int i = 1; i <= n; ++i)
                for (int j = 1; j <= m; ++j) {
                    if (visited[i][j]) {
                        total -= ary[i][j];//수를 지우면 total, cnt 반영
                        cnt--;
                        ary[i][j] = 0;
                        visited[i][j] = 0;
                    }
                }
 
        else {//지운 수가 없음
            if (cnt == 0)    break;//더이상 수가 없으면 빠르게 종료
            double avg = (double)total / cnt;//평균
            for (int i = 1; i <= n; ++i)
                for (int j = 1; j <= m; ++j) {
                    if (!ary[i][j])    continue;
                    if (ary[i][j] < avg) {//평균이하
                        ary[i][j]++;
                        total++;
                    }
                    else if(ary[i][j]!=avg){//이상
                        ary[i][j]--;
                        total--;
                    }
                }
        }
    }
    printf("%d", total);
}
Colored by Color Scripter

cs

[백준] 16719 ZOAC

latter2005 — Tue, 30 Mar 2021 04:15:34 +0900

16719번: ZOAC

2018년 12월, 처음 시작하게 된 ZOAC의 오프닝을 맡은 성우는 누구보다 화려하게 ZOAC를 알리려 한다. 앞 글자부터 하나씩 보여주는 방식은 너무 식상하다고 생각한 성우는 문자열을 보여주는 새로

www.acmicpc.net

문제 확인

스택 혹은 dfs로 풀어도 되지만 간단한 로직으로 풀 수 있습니다.

풀이

문자열에서 사전 순으로 빠른 문자는 아스키 값으로 낮은 문자이므로 간단하게 대소 비교를 통해 구별할 수 있습니다.

문자열을 구간으로 나누고 해당 구간에서 가장 낮은 문자를 택해 해당 문자를 추가하고 이로 인하여 나뉘는 2개의 구간을 같은 방식으로 처리합니다.

백준 예시 STARTLINK 보면 0 ~ (N-1) 구간에서 가장 빠른 문자는 A입니다.

이로 인하여 ST / RTLINK로 나뉘게 되고 앞 문자 ST를 먼저 처리하게 되면 사전 순서가 A로 시작하는 문자보다 느릴 수밖에 없으므로 뒤 RTLINK 구간을 먼저 처리합니다. 출력할 문자는 A가 됩니다.
RTLINK에서 가장 빠른 문자는 I이므로 ST / RTL / NK로 나뉘게 되며 출력할 문자는 AI가 됩니다.
NK에서 가장 빠른 문자는 K 구간 ST / RTL / N / "", 출력 : AIK, N 뒤의 구간은 빈칸이므로 지워줍니다.
N 구간은 문자가 하나이므로 바로 출력합니다. ST / RTL, 출력 : AINK
ST / RT => ALINK
ST / T => ARLINK
ST => ARTLINK
T => SARTLINK
STARTLINK

주의해야 할 점은 같은 순서의 문자가 여러 개 나오면 앞의 문자를 먼저 선택해야 구간 정리에 문제가 생기지 않습니다.

예를 들어 ABACAD라는 문자가 있을 경우 맨 앞의 A를 선택하여야 합니다.

만약 맨 뒤의 A를 선택한 경우 구간이 ABAC / D로 나뉘게 되며 다음 출력할 문자열은 AD가 되므로 오류가 생깁니다.

이는 간단하게 최솟값을 찾을 때 등호를 넣어 처리 가능합니다.

코드

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

#include <cstdio>
#include <cstring>
 
int main() {
    char ary[101];
    int visited[100] = { 0 };
 
    scanf("%s", ary);
    int n = strlen(ary);
 
    for (int i = 0; i < n; i++) {
        int j = n - 1;
        while (visited[j])--j;//여러 구간 중 뒤의 구간부터 탐색
 
        int mn = j--;//최솟값 찾기
 
        while (j >= 0 && !visited[j]) {
            mn = ary[mn] >= ary[j] ? j : mn;//등호를 통해 예외 처리
            --j;
        }
        visited[mn] = 1;//최솟값 선택
 
        for (int j = 0; j < n; j++)//방문한 문자 출력
            if (visited[j])
                putc(ary[j], stdout);
        putc('\n', stdout);
    }
 
}
Colored by Color Scripter

cs