히더

[BOJ 17837] 새로운 게임 2

히더 — Wed, 6 Nov 2019 10:09:36 +0900

백준 :: BOJ :: 17837 :: 새로운 게임 2

출처 : https://www.acmicpc.net/problem/17837

17837번: 새로운 게임 2

재현이는 주변을 살펴보던 중 체스판과 말을 이용해서 새로운 게임을 만들기로 했다. 새로운 게임은 크기가 N×N인 체스판에서 진행되고, 사용하는 말의 개수는 K개이다. 말은 원판모양이고, 하나의 말 위에 다른 말을 올릴 수 있다. 체스판의 각 칸은 흰색, 빨간색, 파란색 중 하나로 색칠되어있다. 게임은 체스판 위에 말 K개를 놓고 시작한다. 말은 1번부터 K번까지 번호가 매겨져 있고, 이동 방향도 미리 정해져 있다. 이동 방향은 위, 아래, 왼쪽, 오른쪽

www.acmicpc.net

#include <bits/stdc++.h>
using namespace std;

#define F(p,q,r) for(int p=q; p<r; p++)
struct S { int y, x, d; };
int N, K,a,b,c,t,fl, A[14][14], dir[5][2] = { {},{0,1},{0,-1},{-1,0},{1,0} };
deque<int> B[14][14]; S C[11];

int main() {
	cin >> N >> K;
	F(i, 0, N + 2) {
		F(j, 0, N + 2) {
			if (!i || !j || i > N || j > N) A[i][j] = 2;
			else cin >> A[i][j];
		}
	}
	F(i, 0, K) {
		cin >> C[i].y >> C[i].x >> C[i].d; B[C[i].y][C[i].x].push_back(i);
	}
	while (t++ < 1000) {
		F(i, 0, K) {
			a = C[i].y, b = C[i].x, c = C[i].d;
			a += dir[c][0]; b += dir[c][1]; int si = C[i].y, sj = C[i].x;
			if (A[a][b] > 1) {
				c += 1; if (c == 3)c = 1; if (c == 5)c = 3; C[i].d = c;
				a += dir[c][0]; b += dir[c][1];
				if(A[a+dir[c][0]][b+dir[c][1]]<2) a += dir[c][0], b += dir[c][1];			
			}
			int f, D=0,l=B[si][sj].size(), s=0;
			if (A[a][b] == 1) {
				for (int j = l - 1; j >= 0; j--) {
					s = B[si][sj][j]; C[s].y = a; C[s].x = b;
					B[a][b].push_back(s); B[si][sj].pop_back();
					 if (s == i)break;
				}
			}
			else {
				F(j, 0, l) {
					f = B[si][sj][j]; if (f == i) s = 1;
					if (s == 1) {
						C[f].y = a; C[f].x = b; B[a][b].push_back(f); D++;
					}
				}
				while (D-- > 0) B[si][sj].pop_back();
			}
			if (B[a][b].size() >= 4) { fl = 1; break; }
		}
		if (fl)break;
	}
	cout << ((t > 1000)?-1:t);
	return 0;
}

[BOJ 17779] 게리맨더링 2

히더 — Thu, 24 Oct 2019 22:21:43 +0900

백준 :: BOJ :: 17779 :: 게리맨더링 2

출처 : https://www.acmicpc.net/problem/17779

17779번: 게리맨더링 2

재현시의 시장 구재현은 지난 몇 년간 게리맨더링을 통해서 자신의 당에게 유리하게 선거구를 획정했다. 견제할 권력이 없어진 구재현은 권력을 매우 부당하게 행사했고, 심지어는 시의 이름도 재현시로 변경했다. 이번 선거에서는 최대한 공평하게 선거구를 획정하려고 한다. 재현시는 크기가 N×N인 격자로 나타낼 수 있다. 격자의 각 칸은 구역을 의미하고, r행 c열에 있는 구역은 (r, c)로 나타낼 수 있다. 구역을 다섯 개의 선거구로 나눠야 하고, 각 구역은 다

www.acmicpc.net

#include <bits/stdc++.h>
using namespace std;

#define F(p,q,r) for(int p=q; p<r; p++)
int N, A[20][20], s, t, ans = 1e5, v, D[4][2] = { {0,-1},{1,0},{0,1},{-1,0} };

int main() {
	cin >> N;
	F(i, 0, N) {
		F(j, 0, N) {
			cin >> A[i][j]; s += A[i][j];
		}
	}
	F(i, 0, N - 2) {
		F(j, 1, N - 1) {
			F(n1, 1, j + 1) {
				F(n2, 1, N-j) {
					if (i + n1 + n2 >= N) break;
					t = s; int B[5] = { 0, }, ma = 0, mi = 1e5,
						C[4][6] = { {0,i+n1,i,0,j+1,N},{0,i+n2+1,i+1,j+1,N,N},
					{i+n1,N,0,0,j-n1-1,i+n1+n2+1},{i+n2+1,N,0,j+n2+1,N,i+n1+n2+2} };
					F(k, 0, 4) {
						v = 0; F(y, C[k][0], C[k][1]) {
							if (y >= C[k][2] && y<C[k][5]) v++;
							int c1 = C[k][3] + D[k][0]*v, c2= C[k][4] + D[k][1]*v;
							F(x, c1, c2) B[k] += A[y][x];
						}
						ma = max(ma, B[k]); mi = min(mi, B[k]); t -= B[k];
					} ma = max(ma, t); mi = min(mi, t);
					ans = min(ans, ma-mi);
				}
			}
		}
	}
	cout << ans;
	return 0;
}

[BOJ 17142] 연구소 3

히더 — Wed, 18 Sep 2019 18:13:33 +0900

백준 :: BOJ :: 17142 :: 연구소 3

출처 : https://www.acmicpc.net/problem/17142

17142번: 연구소 3

인체에 치명적인 바이러스를 연구하던 연구소에 승원이가 침입했고, 바이러스를 유출하려고 한다. 바이러스는 활성 상태와 비활성 상태가 있다. 가장 처음에 모든 바이러스는 비활성 상태이고, 활성 상태인 바이러스는 상하좌우로 인접한 모든 빈 칸으로 동시에 복제되며, 1초가 걸린다. 승원이는 연구소의 바이러스 M개를 활성 상태로 변경하려고 한다. 연구소는 크기가 N×N인 정사각형으로 나타낼 수 있으며, 정사각형은 1×1 크기의 정사각형으로 나누어져 있다. 연구소는

www.acmicpc.net

#include <bits/stdc++.h>
using namespace std;

#define F(p,q) for(int p=0; p<q; p++)
struct S { int si, sj; };
int i, j, A[50][50], N, M, R = 1e4, c, z, r[4][2] = { {-1,0},{0,1},{1,0},{0,-1} };

int main() {
	vector<S> v; vector<int> v3;
	cin >> N >> M;
	F(i, N) F(j, N) {
		cin >> A[i][j]; if (A[i][j] > 1) { v.push_back({ i,j }); z++; } if (!A[i][j]) c++;
	}
	F(i, z - M) v3.push_back(0); F(i, M) v3.push_back(1);
	if (!c) R = 0;
	else {
		do {
			int B[50][50], dd = c, ti = 0; memcpy(B, A, sizeof(A)); queue<S> q;
			F(i, v3.size()) { if (v3[i]) { q.push(v[i]); B[v[i].si][v[i].sj] = 3; } }
			while (!q.empty()) {
				int qs = q.size(); ti++;
				while ((qs--)) {
					S ts = q.front(); q.pop();
					F(j, 4) {
						int ni = ts.si + r[j][0], nj = ts.sj + r[j][1];
						if ((ni >= 0 && nj >= 0 && ni < N && nj < N && !(B[ni][nj] % 2))) {
							q.push({ ni,nj }); if (!B[ni][nj])dd--; B[ni][nj] = 3;
						}
					}
					if (!dd) { R = min(R, ti); break; }
				}
				if (ti >= R) break;
			}
		} while (next_permutation(v3.begin(), v3.end()));
	}
	cout << (R < 1e4 ? R : -1);
	return 0;
}

[BOJ 17140] 이차원 배열과 연산

히더 — Wed, 18 Sep 2019 18:11:21 +0900

백준 :: BOJ :: 17140 :: 이차원 배열과 연산

출처 : https://www.acmicpc.net/problem/17140

17140번: 이차원 배열과 연산

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

www.acmicpc.net

#include<bits/stdc++.h>
using namespace std;

#define F(p,q,z) for(int p=q; p<z; p++)
#define pi pair<int,int>
int r, c, k, A[100][100], N = 3, M = 3, i, j, ans, ss;

void G(int ii, int jj) {
	ss = 0; F(i, 0, ii) {
		set<int>s1; multiset<int> s2; priority_queue<pi, vector<pi>, greater<pi>>pq; int B = 0;
		F(j, 0, jj) { 
			if (N >= M) { if (!A[i][j]) continue; s1.insert(A[i][j]); s2.insert(A[i][j]); A[i][j] = 0;}
			else {if (!A[j][i]) continue; s1.insert(A[j][i]); s2.insert(A[j][i]); A[j][i] = 0;}
		}
		for (auto it = s1.begin(); it != s1.end(); it++)pq.push(make_pair(s2.count(*it),*it));
		int gg = 0, mm=pq.size(); ss=max(ss,(mm*2));
		while (!pq.empty()) {
			pi tmp = pq.top(); pq.pop();
			if (N >= M) {A[i][gg++] = tmp.second; A[i][gg++] = tmp.first;}
			else {A[gg++][i] = tmp.second; A[gg++][i] = tmp.first;}
			if (gg > 99)break;
		}
	}
}

int main() {
	cin >> r >> c >> k;
	F(i, 0, 3) F(j, 0, 3) cin >> A[i][j];
	while (ans < 101 && A[r - 1][c - 1] != k) { (N >= M ? G(N, M) : G(M, N)); (N >= M ? M = ss : N = ss); ans++; }
	cout << (ans > 100 ? -1 : ans);
	return 0;
}

[BOJ 17143] 낚시왕

히더 — Tue, 14 May 2019 21:28:09 +0900

백준 :: BOJ :: 17143 :: 낚시왕

출처 : https://www.acmicpc.net/problem/17143

#include<bits/stdc++.h>
using namespace std;

#define FO(x,y) for(x=0; x<y; x++)
struct F { int r, c, d, s, z; }; vector<F> v;
int R, C, M, ans, dir[2][5] = { { 0,-1,1,0,0 },{ 0,0,0,1,-1 } }, cd[] = { 0,2,1,4,3 };

inline int go(int a, int b, int c, int e) {
	int pm = (b + (v[a].s*dir[e][v[a].d])), tm = abs(pm) % ((c - 1) * 2);
	if (v[a].s) {
		if (v[a].d == 1 || v[a].d == 4) { if (tm > 0 && tm < c) if (pm < 0) v[a].d = cd[v[a].d]; }
		else { if (tm == 0 || tm > (c - 1)) v[a].d = cd[v[a].d]; }
	}
	return (tm > (c - 1) ? ((c - 1) * 2) - tm : tm);
}

int main() {
	ios::sync_with_stdio(false); cin.tie(0);
	cin >> R >> C >> M; F f;
	while (M--) { cin >> f.r >> f.c >> f.s >> f.d >> f.z; f.r--; f.c--; v.push_back(f); }
	for (int k = 0; k < C && v.size(); k++) {
		F p[100][100] = { 0, }; vector<int>pv[2]; int fc[2] = { 101, }, i, vi[100][100] = { 0, };
		FO(i, v.size()) { if (v[i].c == k && fc[0] > v[i].r) { fc[0] = v[i].r; fc[1] = v[i].z; } }
		FO(i, v.size()) {
			if (v[i].z == fc[1]) { ans += v[i].z; v.erase(v.begin() + i); i--; continue; }
			int ni = v[i].r, nj = v[i].c;
			if (v[i].d < 3) ni = go(i, ni, R, 0);
			else nj = go(i, nj, C, 1);
			if (p[ni][nj].z < v[i].z) {
				v[i].r = ni; v[i].c = nj; p[ni][nj] = v[i]; if (!vi[ni][nj]) { vi[ni][nj] = 1; pv[0].push_back(ni); pv[1].push_back(nj); };
			}
		}v.clear();
		FO(i, pv[0].size()) v.push_back(p[pv[0][i]][pv[1][i]]);
	}
	cout << ans;
	return 0;
}

[BOJ 17144] 미세먼지 안녕!

히더 — Tue, 14 May 2019 21:25:23 +0900

백준 :: BOJ :: 17144 :: 미세먼지 안녕!

출처 : https://www.acmicpc.net/problem/17144

#include <bits/stdc++.h>
using namespace std;

#define F(x,y,u,p) for(int x=0; x<u; x++)for(int y=0;y<p;y++)
int ans, w, q[2][2], R, C, T, a[50][50], dd[4][2] = { {0,1},{-1,0},{0,-1},{1,0} }, dx[8] = { 0,1,2,3,0,3,2,1 };

inline bool chk(int i, int j) { return (i < 0 || j < 0 || i >= R || j >= C || a[i][j] < 0) ? false : true; }

int main() {
	cin >> R >> C >> T;
	F(i, j, R, C) { cin >> a[i][j]; if (a[i][j] < 0)q[w][0] = i,q[w++][1] = j; }
	while (T--) {
		int ta[50][50] = { 0, }, cz = 0;
		F(i, j, R, C) {
			if (a[i][j] > 4) {
				int n = a[i][j] / 5, m = 0;
				for (int d = 0; d < 4; d++) { int ni = i + dd[d][0], nj = j + dd[d][1]; if (chk(ni, nj)) { ta[ni][nj] += n; m++; } }
				a[i][j] -= n * m;
			}
		}
		F(i, j, R, C) a[i][j] += ta[i][j];
		for (int i = 0; i < 2; i++) {
			int cn = 0, cm = 0, ii = q[i][0], jj = q[i][1];
			while (1) {
				int ni = ii + dd[dx[cz]][0], nj = jj + dd[dx[cz]][1];
				if (ni == q[i][0]&&nj==0) { cz++; break; }
				if (chk(ni, nj)) { cm = a[ni][nj]; a[ni][nj] = cn; cn = cm; ii = ni; jj = nj; }
				else cz++;
			}
		}
	}
	F(i, j, R, C) if (a[i][j] > 0) ans += a[i][j];
	cout << ans;
	return 0;
}

삼성 SW 역량 테스트 기출 풀이

히더 — Wed, 13 Feb 2019 15:09:20 +0900

1. 게리맨더링 2 (백준17779)

2. 새로운 게임 2 (백준17837)

5. 연구소 3 (백준17142)

6. 이차원 배열과 연산 (백준17140)

7. 낚시왕 (백준17143)

8. 미세먼지 안녕! (백준17144)

9. 아기상어 (백준16236)

10. 나무재테크 (백준16235)

11. 인구이동 (백준16234)

12. 큐빙 (백준5373)

13. 감시 (백준15683)

14. 사다리조작 (백준15684)

15. 드래곤커브 (백준15685)

16. 치킨배달 (백준15686)

- SWEA : https://www.swexpertacademy.com/main/searchAll/searchMore.do?category=CODE&keyword=%EB%AA%A8%EC%9D%98+sw

작성자 : 히더

[BOJ 3190] 뱀

히더 — Mon, 21 Jan 2019 12:49:09 +0900

백준 :: BOJ :: 3190 :: 뱀

출처 : https://www.acmicpc.net/problem/3190

#include <bits/stdc++.h>

using namespace std;

int N, K, L, ti, tj, dd, ans, m[101][101];

int di[] = {0,1,0,-1}, dj[] = {1,0,-1,0};

deque <pair<int,int>> dq, r;

inline bool chk(int i, int j) { return (i>0&&j>0&&i<=N&&j<=N) ? true : false; }

int main() {

std::ios::sync_with_stdio(false); cin.tie(0);

cin >> N >> K; dq.push_back(make_pair(1, 1)); m[1][1] = -1; dd = 0;

while (K--) {

cin >> ti >> tj; m[ti][tj] = 1;

}

cin >> L;

while (L--) {

char c; cin >> ti >> c;

if (c == 'L') tj = -1;

else tj = 1;

r.push_back(make_pair(ti, tj));

}

while (1) {

ans++;ti = dq.front().first+di[dd]; tj = dq.front().second+dj[dd];

if (chk(ti, tj)) {

if (m[ti][tj]>=0) {

if (m[ti][tj] < 1) {

m[dq.back().first][dq.back().second] = 0; dq.pop_back();

}

dq.push_front(make_pair(ti, tj)); m[ti][tj] = -1;

}

else break;

}

else break;

if (!r.empty() && r.front().first == ans) {

dd += r.front().second; r.pop_front();

if (dd == -1) dd = 3;

else if (dd == 4) dd = 0;

}

cout << ans;

return 0;

}

[BOJ 16235] 나무 재테크

히더 — Thu, 10 Jan 2019 13:51:13 +0900

백준 :: BOJ :: 16235 :: 나무 재테크

출처 : https://www.acmicpc.net/problem/16235

#include <bits/stdc++.h>

using namespace std;

struct Tr {

int i, j, a;

bool operator<(const Tr& vv) const { return a < vv.a; }

};

int N, M, K, A[11][11], arr[11][11];

int di[] = { -1,-1,-1,0,1,1,1,0 }, dj[] = { -1,0,1,1,1,0,-1,-1 };

vector <Tr> v, tv; queue<Tr> q;

inline bool chk(int i, int j) { return (i > 0 && j > 0 && i <= N && j <= N) ? true : false; }

void year() {

sort(v.begin(), v.end()); Tr t;

for (int i = 0; i < v.size(); i++) {

t = v[i];

if (arr[t.i][t.j] >= t.a) { arr[t.i][t.j] -= t.a; t.a++; tv.push_back(t); }

else q.push(t);

}

v.swap(tv); tv.clear();

while (!q.empty()) {

t = q.front(); q.pop();

arr[t.i][t.j] += (t.a / 2);

}

for (int i = 0; i < v.size(); i++) {

if (v[i].a % 5 == 0) {

for (int d = 0; d < 8; d++) {

t = v[i]; t.i += di[d]; t.j += dj[d]; t.a = 1;

if (chk(t.i, t.j)) v.push_back(t);

}

if (K) for (int i = 1; i <= N; i++) for (int j = 1; j <= N; j++) arr[i][j] += A[i][j];

}

int main() {

std::ios::sync_with_stdio(false); cin.tie(0);

cin >> N >> M >> K;

for (int i = 1; i <= N; i++) for (int j = 1; j <= N; j++) {

cin >> A[i][j]; arr[i][j] = 5;

}

while (M--) {

Tr tmp; cin >> tmp.i >> tmp.j >> tmp.a;

v.push_back(tmp);

}

while (K--) {

year();

}

cout << v.size();

return 0;

}

[BOJ 16234] 인구 이동

히더 — Wed, 9 Jan 2019 17:48:23 +0900

백준 :: BOJ :: 16234 :: 인구 이동

출처 : https://www.acmicpc.net/problem/16234

#include <bits/stdc++.h>

using namespace std;

struct A { int a, b; };

int N, L, R, f, sum, ans,

arr[50][50], dir[4][2] = { {0,1},{0,-1},{1,0},{-1,0} };

bool vi[50][50];

queue<A> q; vector<A> v;

inline bool check(int i, int j) { return (i >= 0 && j >= 0 && i < N&&j < N) ? true : false; }

inline bool cal(int a, int b) { return (abs(a - b) >= L && abs(a - b) <= R) ? true : false; }

void bfs() {

while (!q.empty()) {

auto tmp = q.front(); q.pop();

for (int d = 0; d < 4; d++) {

int ni = tmp.a + dir[d][0], nj = tmp.b + dir[d][1];

if (check(ni, nj) && !vi[ni][nj] && cal(arr[tmp.a][tmp.b], arr[ni][nj])) {

vi[ni][nj] = 1; q.push({ ni,nj });

v.push_back({ ni,nj }); sum += arr[ni][nj];

}

void ch() {

while (!f) {

f = 1; memset(vi, 0, sizeof(vi));

for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) {

if (!vi[i][j]) {

q.push({ i,j }); vi[i][j] = 1;

v.push_back({ i,j }); sum += arr[i][j]; bfs();

if (v.size() > 1) {

int tra = sum / v.size(); f = 0;

for (int i = 0; i < v.size(); i++) arr[v[i].a][v[i].b] = tra;

}

v.clear(); sum = 0;

}

if (!f) ans++;

}

int main() {

std::ios::sync_with_stdio(false); cin.tie(0);

cin >> N >> L >> R; ans = 0; sum = 0; f = 0;

for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> arr[i][j];

ch();

cout << ans;

return 0;

}

[BOJ 16236] 아기 상어

히더 — Wed, 9 Jan 2019 17:45:40 +0900

백준 :: BOJ :: 16236 :: 아기 상어

출처 : https://www.acmicpc.net/problem/16236

#include <bits/stdc++.h>

using namespace std;

int N, t, tt, fs, ss, si, sj, ni, nj,

arr[21][21], v[21][21], di[] = {-1,0,0,1}, dj[] = {0,-1,1,0};

queue<pair<int, int>> q; priority_queue<int,vector<int>,greater<int>> pq;

void clear() {

queue<pair<int, int>> e; priority_queue<int, vector<int>, greater<int>>ee; swap(pq, ee); swap(q, e);

memset(v, 0, sizeof(v)); q.push(make_pair(ni, nj));

}

void bfs() {

while (!q.empty()) {

int s = q.size(); tt++;

while (s--) {

auto tmp = q.front(); q.pop();

for (int d = 0; d < 4; d++) {

ni = tmp.first + di[d]; nj = tmp.second + dj[d];

if (ni > 0 && ni <= N && nj > 0 && nj <= N && arr[ni][nj] <= ss &&!v[ni][nj]) {

if (arr[ni][nj] < ss && arr[ni][nj] >0) pq.push(ni*100+nj);

else v[ni][nj] = 1, q.push(make_pair(ni, nj));

}

if (!pq.empty()) {

ni = pq.top() / 100; nj = pq.top() % 100;

fs++; arr[ni][nj] = 0; clear(); t += tt; tt = 0;

if (ss == fs) ss++, fs = 0;

}

int main() {

std::ios::sync_with_stdio(false); cin.tie(0);

cin >> N; t = 0; ss = 2; fs = 0;

for (int i = 1; i <= N; i++) for (int j = 1; j <= N; j++) {

cin >> arr[i][j]; if (arr[i][j] == 9) arr[i][j]=0, si = i, sj = j, q.push(make_pair(i,j));

}

bfs();

cout << t;

return 0;

}

2019 10대 전략 기술 트렌드

히더 — Thu, 1 Nov 2018 18:38:55 +0900

시장조사 기관 '가트너(Gartner)'가 선정한 2019년 IT 10대 전략 기술 트렌드와 이에 대한 생각을 정리하였다.

구분	명칭	내용
지능	1. 자율 사물 (Autonomous Things)	-로봇, 드론, 자율주행차 등 AI가 결합되 자동, 자율화 된 사물이 된다. 사물이 환경 및 사람과 상호작용하는 수준의 행동을 선보인다.
	2. 증강 분석 (Augmented Analytics)	-증강 분석은 분석 콘텐츠가 개발, 소비 및 공유되는 방식을 혁신하기 위해 머신러닝을 이용해 증강 지능의 특정 영역에 초점을 맞춘다. 증강 분석 기능은 데이터 준비, 데이터 관리, 분석, 프로세스 관리, 마이닝 및 데이터 사이언스 플랫폼의 주요 기능으로 빠르게 발전한다. 증강 분석으로부터 얻은 자동화된 통찰력은 HR, 재무, 영업, 마케팅, 서비스, 구매조달 및 자산관리 등에 적용되 최적화 결과를 낼 것이다.
	3. 인공지능 주도 개발 (AI-Driven Development)	-기존의 데이터, 애플리케이션 등 협업을 통해 만들어진 AI 솔루션 방식에서 벗어나, 전문 개발자들이 서비스형 사전 정의 모델을 사용해 단독으로 운영할 수 있는 모델로 시장이 변하고 있다. 이는 개발자에게 AI 알고리즘, 모델 생태계는 물론 모델 및 AI 역량을 솔루션에 통합하도록 설계된 개발 툴을 제공한다.
디지털	4. 디지털 트윈 (Digital Twin)	-디지털 트윈은 ‘현실 세계에 존재하는 대상이나 시스템의 디지털 버전’을 말함. 디지털 트윈은 향후 3~5년간 특히 IoT 프로젝트에서 유망할 것으로 예상한다. 비즈니스 목표에 맞게 효과적으로 데이터를 수집, 시각화, 분석, 규칙 적용을 하며 역량을 향상시키면서 진화할 것이다.
	5. 자율권을 가진 에지 (Empowred Edge)	-에지 컴퓨팅은 정보 처리와 콘텐츠 수집, 전달이 해당 정보 소스와 인접한 곳에서 처리되는 컴퓨팅 토폴로지(topology)이다. 즉 에지는 사람들이 사용하거나 우리 주변에 내장된 엔드포인트 디바이스를 지칭한다. 에지는 IoT에 주도되어 클라우드, 에지 컴퓨팅이 중앙 서버 뿐 아니라 분산화 된 에지 디바이스 자체에서 중앙 서비스로서 관리되는 클아우드 서비스를 보완하는 모델로 진화할 것이다.
	6. 몰입 경험 (Immersive Experience)	-대화형 플랫폼은 디지털 세계와 인간 상호작용 방식 간 차세대 패러다임 전환을 야기할 것으로 예측한다. 디지털 세상을 인식하는 방식과 상호작용 모델의 통합된 변화는 미래 몰입형 사용자 경험을 이끌어 낸다.
메시	8. 블록체인 (Blockchain)	-블록체인은 디지털 통화 인프라에서 디지털 혁신 플랫폼으로 진화 중이다. 블록체인은 대안적 신뢰 모드를 제공하고 중재 거래에서 중앙당국의 필요성을 없앤다.
메시	9. 스마트 공간 (Smart Spaces)	-스마트 공간은 인간과 기술 시스템이 더욱 개방되고, 연결되며, 조율되고, 지능적인 생태계에서 상호작용하는 물리적 혹은 디지털 환경이다. 사람, 프로세스, 서비스 그리고 사물 등 여러 요소들은 스마트 공간에 모여 타깃 사용자 및 산업 시나리오를 겨냥한 보다 몰입적이고 상호적이며 자동화된 경험을 창출한다.
공통	10. 디지털 윤리와 개인정보보호 (Privacy and Ehtics)	-디지털 윤리와 개인정보보호는 개인, 조직 및 정부가 모두 우려하는 부분이다. 사람들은 자신의 개인정보가 공공 및 민간부문에서 조직에 의해 어떻게 사용되는지에 대해 점점 더 우려하고 있고, 이러한 우려에 대해 적극적인 조치를 취하지 않는 조직들에 대한 반발도 증가하고 있다.
공통	10. 양자 컴퓨팅 (Quantum Computing)	-양자 컴퓨팅은 정보를 양자 비트 요소로 나타내는 전자와 이온과 같은 아원자 입자의 양자 상태에서 작동하는 비고전적인 컴퓨팅의 한 유형이다. 양자 컴퓨터의 병렬 실행과 기하 급수적인 확장성은 기존의 문제점을 해결한다. 금융, 보험, 제약, 군사 및 연구 기관과 같은 기업들이 복잡하고 시간적 문제를 해결하며 큰 혜택을 이루고 있다.

지능, 디지털, 메시는 작년과 동일하게 지속적으로 주목받았던 주제이다. 2019는 초기 상태에서 벗어나 보다 폭넓은 영향력과 활용 사례를 보이는 신기술과 급성장세를 보인다. 이는 기술 중심에서 보다 넓은 시야로 기술이 적용되는 환경을 고려한 기술이 중요시 되고 있다고 생각한다. 현재 우리나라의 기술력은 해외보다 늦다고 생각한다. 그러나 강점은 사회 전반에 디지털화가 가장 잘 되어 있다는 점이라고 생각한다. 2019년 부터 상용화 될 5G의 파급력으로 이러한 전략 기술들은 좀 더 사용자 및 개발자에게 가깝게 느껴지고 필요성이 절실할 것이다. 기업에서도 이러한 점을 고려하여 자체 목표, 전략에 맞게 발전해야 한다고 생각한다.

출처 : http://www.itworld.co.kr/news/111118

작성자 : 히더

[BOJ 5373] 큐빙

히더 — Thu, 25 Oct 2018 18:30:04 +0900

백준 :: BOJ :: 5373 :: 큐빙

출처 : https://www.acmicpc.net/problem/5373

#include <bits/stdc++.h>

using namespace std;

int T, N, i, h,

c[21] = {13,8,3,18,14,9,4,0,19,15,10,5,1,20,16,11,6,2,17,12,7 },

u[6][21] = {

{ 20,19,18,27,8,7,6,11,28,5,4,3,10,29,2,1,0,9,45,46,47 },

{ 18,21,24,6,11,14,17,36,3,10,13,16,39,0,9,12,15,42,47,50,53 },

{ 6,7,8,11,18,19,20,27,14,21,22,23,30,17,24,25,26,33,36,37,38 },

{ 26,23,20,38,33,30,27,8,41,34,31,28,5,44,35,32,29,2,51,48,45 },

{ 24,25,26,17,36,37,38,33,16,39,40,41,34,15,42,43,44,35,53,52,51 },

{ 42,43,44,15,53,52,51,35,12,50,49,48,32,9,47,46,45,29,0,1,2 } };

char s[86], t[21], g[54], d[2], in[6] = { 'o','g','w','b','r','y' };

int main() {

std::ios::sync_with_stdio(false); cin.tie(0);

cin >> T;

for (i = 0; i < 6; i++) s["BLURFD"[i]] = i;

while (T--) {

cin >> N; vector<pair<int, int>> v;

while (N--) {

cin >> d[0] >> d[1]; d[0] = s[d[0]];

v.push_back(make_pair(d[0], d[1]));

}

i = -1; while ((++i) < 55) g[i] = in[i / 9];

for (i = 0; i < v.size(); i++) {

h = -1; while ((++h) <= 20) t[h] = g[u[v[i].first][h]];

h = -1; while ((++h) <= 20) g[u[v[i].first][h]] = v[i].second>44 ? t[20-c[h]] : t[c[h]];

}

for (i = 18; i < 27; i++) {

cout << g[i];

if ((i % 3) == 2) cout << '\n';

}

[SWEA 5789] 현주의 상자 바꾸기

히더 — Wed, 10 Oct 2018 16:56:51 +0900

SW Expert Academy :: SWEA :: 5789 :: 현주의 상자 바꾸기

출처 : https://www.swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWYygN36Qn8DFAVm

#include <bits/stdc++.h>

using namespace std;

int i, j, T, N, Q, n1, n2;

int main() {

std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);

cin >> T;

for (int tc = 1; tc <= T; tc++) {

cin >> N >> Q;

vector<pair<int, int>>q; vector<int>v(N + 1, 0), a(N + 1, 0);

while (Q--) {

cin >> n1 >> n2; q.push_back(make_pair(n1, n2));

}

for (i = q.size() - 1; i >= 0; i--) {

for (j = q[i].first; j <= q[i].second; j++) {

if (v[j]) j = v[j];

else {

a[j] = i + 1; v[j] = q[i].second;

}

cout << "#" << tc << " ";

for (i = 1;i <= N;i++) cout << a[i] << " ";

cout << '\n';

}

return 0;

}

오버헤드 (Overhead)

히더 — Tue, 9 Oct 2018 16:41:09 +0900

오버헤드

프로그램이 실행되는 중에 다른 위치의 코드를 실행시켜야 할 때, 간접적으로 시간, 메모리, 자원 등이 사용되는 현상이다.

즉, 반드시는 아니고 간접적인 것이다.

외부 함수 사용 시 함수 사용을 위해 스택메모리를 할당하고 함수에 따라 여러가지 연산 등이 일어난다. 이는 예상치 못한 자원들이 사용되는 것이고 이것이 오버헤드이다.

오버헤드를 줄이기 위해 매크로, 인라인 함수 등을 사용하고 최적화가 필요하다.

작성자 : 히더

정렬 알고리즘 (Sorting Algorithm)

히더 — Tue, 9 Oct 2018 06:22:07 +0900

정렬 알고리즘 정리에 앞서 두 가지를 정리하였다.

안전 정렬 ( stable )	불안전 정렬 ( not stable )
같은 값(key)의 위치가 정렬 과정에서 바뀌지 않는 것	같은 값(key)의 위치가 정렬 과정에서 바뀌는 것

내부 정렬 ( Internal sorting )

외부 정렬 ( External sorting )

데이터의 크기가 주 기억장소 용량보다 적을 경우

기억장소를 활용하여 정렬

데이터의 크기가 주 기억장소 용량보다 클 경우

외부 기억장치를 사용하여 정렬

가장 효율적인 정렬 알고리즘이 무엇인가? 라는 질문에 대한 답은 상황에 따라 다르다이다.

데이터의 크기, 양, 정렬상태 등 다양한 상황에 따라 최적의 정렬 알고리즘을 선택하기 위해 각각의 정렬 알고리즘들을 정리하였다.

1. Bubble Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- 안전 정렬 - 내부 정렬 - 비교와 교환

- 연산이 완료되었는지를 나타내는 flag를 통한 코드 수정으로 복잡도 줄일 수 있다.

- 이미 정렬이 되어 있는지 확인 가능하다.

- 가장 쉬운 정렬 알고리즘 - 시간복잡도가 높아 잘 사용하지 않는다

- 나란히 있는 2개의 데이터를 계속해서 바꾸어 나간다.

- 데이터가 적고 단순한 구현이 필요한 경우 사용한다.

2. Selection Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- 불안전 정렬 - 내부 정렬 - 비교와 교환

- 데이터 중 최솟값을 선택하여 제일 앞과 자리를 바꾸며 정렬한다.

- 데이터가 적을 때 사용한다.

- 데이터의 초기 정렬형태에 영향을 받지않고 일정한 시간 복잡도를 나타낸다.

- 거품 정렬에 비해 2~3배 빠르다.

3. Insertion Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- 안전 정렬 - 내부 정렬 - 비교와 교환

- 데이터에 대해 더 작거나 큰 값이 나올때까지 진행하며 값을 찾아가며 바꾼다.

- 버블, 선택 정렬보다 빠르고 안전성이 높아 다른 분할정복으로 구현되는 알고리즘의 base가 된다.

- 이미 정렬된 상태면 최선의 시간 복잡도가 나온다. 반면 역순으로 정렬되어 있는 경우 최악의 시간 복잡도가 나온다.

- 선택 정렬보다 2배정도 빠르다. - 많은 이동때문에 적은 양의 데이터에 유리하다.

- 데이터의 초기 정렬형태에 영향을 받는다.

4. Shell Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- 불안전 정렬 - 내부 정렬 - 비교와 교환

- 속도가 빠르다.

- 정렬되지 않은 데이터의 경우에 비효율적인 삽입정렬을 개선한 방법

- 일정한 간격(gap)으로 그룹을 만들어 각각 삽입정렬을 한 후 전체를 간격 1로 보고 삽입정렬로 종합한다.

- 간격에 따라 시간 복잡도가 결정되며 아직 정확한 시간 복잡도는 확인되지 않았다. 약 n의 1.25승 정도이다.

- 일정한 간격의 수열이 서로 소가 되게 정의해야 성능이 좋아진다. (ex 701, 301, 132, 57, 23, 10, 4, 1)

- 간격에 따른 그룹 별 정렬 방식이 H/W로 정렬 알고리즘을 구현하는데 적합하여 임베디드 시스템에 주로 사용된다.

5. Merge Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- 안전 정렬 - 외부 정렬

- 외부 정렬로 몇 번 패스(read/write)하냐 를 가지고 시간 복잡도를 측정한다.

- 가장 많이 쓰이는 알고리즘 중 하나이다.

- 데이터를 2개의 균등 크기로 분할하고, 각각 재귀적으로 합병 정렬을 이용하여 정렬한 후 합병한다.

- 데이터 크기만큼 외부 메모리가 필요하다.

- 퀵 정렬과 달리 안정적인 복잡도를 발휘한다.

- 데이터의 초기 상태에 별로 영향을 받지 않는다.

6. Tim Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- 안전 정렬 - 외부 정렬 - 2분할 삽입 정렬 + 병합 정렬

- 병합 정렬일 때 요소수가 적은 경우 오버헤드에 의해 느려진다. 이를 개선한 알고리즘

- 미리 어느 정도의 크기의 정렬이 끝난 열(run)로 분할하고 병합한다.

- run은 32보다 작게 하여 2분할 삽입 정렬을 한다.

- 가장 많이 쓰이는 알고리즘 중 하나이다.

- 데이터를 2개의 균등 크기로 분할하고, 각각 재귀적으로 합병 정렬을 이용하여 정렬한 후 합병한다.

- 데이터 크기만큼 외부 메모리가 필요하다.

- 퀵 정렬과 달리 안정적인 복잡도를 발휘한다.

- 데이터의 초기 상태에 별로 영향을 받지 않는다.

7. Quick Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- 불안전 정렬 - 내부 정렬

- 실제 데이터에서 빠르다고 알려져서 가장 많이 쓰는 알고리즘

- 최악의 경우에 시간 복잡도가 큰 약점이 있다.

- 임의의 값(pivot)을 기준으로 한쪽은 pivot보다 작은 것, 다른 쪽은 큰것으로 나누어(partition) 양쪽을 다시 재귀로 반복한다.

- pivot을 선택이 매우 중요하다.

- 원소 개수가 한자리로 떨어졌을 때는 재귀가 아니라 삽입 정렬로 효율을 높일 수 있다.

- 정렬된 데이터에 대해서는 시간이 더 걸린다.

8. Intro Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- 불안전 정렬 - 내부 정렬

- 퀵 정렬의 개량 버전이다.

- 퀵 정렬에서 pivot의 선택에 의해 시간 복잡도가 최악으로 되는 경우를 대처하기 위해 재귀 탐색이 요소수의 대수를 넘으면

힙 정렬로 바꾼다. 또한 퀵 정렬에서 32미만의 데이터 수의 경우 오버헤드를 적게하기 위해 삽입 정렬로 바꾼다.

9. Heap Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- 불안전 정렬 - 내부 정렬

- 퀵 정렬의 최악의 경우 때문에 힙 정렬을 많이 쓴다.

- 힙 조건(각 노드의 값이 자식 노드 값보다 커야 한다)을 만족하는 완전 이진 트리이다.

- 배열에 저장하여 힙을 만든 후 n개의 데이터를 삭제하고 힙을 재구성하는 과정을 반복한다. 삭제된 노드를 배열에 차례로 저장하면 정렬된 리스트가 된다.

- 재구성은 이진 트리를 힙으로 만들기 위한 재구성으로 트리의 깊이 만큼의 시간이 걸린다.

10. Counting Sort

시간 복잡도

공간 복잡도

최악

최선

평균

- 데이터에서 최대값 만큼의 메모리가 필요하다. 따라서 메모리 낭비가 있을 수 있다.

- 정렬하는 데이터들의 값이 특정한 범위 안에 있을 때 사용한다.

- 데이터의 처음부터 끝까지 돌면서 각 숫자가 몇번 등장하는지 counting한다.

11. Radix Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- 데이터를 특정 진수로 자릿수 별로 정렬하는 알고리즘이다.

- 비교 정렬 알고리즘에서 가장 빠르다.

- radix(기수), 즉 특정 진수로 일의 자리, 십의 자리, 백의 자리, 이렇게 차례로 정렬한다.

- 기수의 크기만큼의 메모리가 필요하다.

- 부동 소숫점, 음수값 처럼 특수한 비교 연산에는 불가능하다.

- 숫자, 알파벳 관련 데이터 등 대용량 데이터 정렬에 적절하다.

12. Bucket Sort

시간 복잡도			공간 복잡도
최악	최선	평균

- n개의 데이터에 대해 범위를 n개로 나누고 n개의 버킷을 만든다. 그 후 각 데이터를 버킷에 넣고 버킷 별로 정렬하여 합친다.

- 데이터가 확률적으로 균등하게 분포한다고 가정할 때 성능이 나타난다.

- 연결 리스트로 버킷을 구성할 수 있고, 버킷들을 정렬할 때는 퀵 정렬 등을 사용한다.

정리

- 데이터의 값을 정확히 모른다면 Heap을 사용하면 가장 무난한 성능을 기대할 수 있다.

- 만약 데이터가 정렬되어 있거나 거의 정렬되어 있으면 Insertion 이나 Tim을 사용한다.

- quick 보다는 intro가 더 성능이 좋으므로 무난하게 사용한다.

정렬 알고리즘 별 비교 및 요약 :

작성자 : 히더

CX (Customer Experience)

히더 — Tue, 9 Oct 2018 03:56:49 +0900

CX는 Customer Experience 즉, 고객 경험을 말한다. 서비스 공급자와 고객의 관계가 지속됨에 따라 관련하여 고객이 체험하는 모든 경험을 CX라고 한다.

사용자 경험 즉, UX (User Experience)와는 사람 또는 넓은 대상의 니즈에 대한 경험으로 비슷하지만 다른 점이 있다.

CX는 UX에서 더 나아가 회사의 전략, 사업 등을 염두에 둔다. UX가 디자인적 시각에서 다가간다면 CX는 비즈니스 적이라고 생각한다.

꼭 제품 또는 서비스에만 한하지 않고 고객의 전반적인 라이프 스타일부터 구체적인 니즈가 무엇인가 이해하는 데서 시작한다. 브랜드와 만나는 접점이 무엇인지 정의하고 이 점점에서 이슈가 무엇인지 분석하여 고객 경험을 더 좋게 만들어 비즈니스 목표를 달성시키는 것이다.

UX보다는 CX가 좀 더 넓은 관점이라고 생각한다. 이는 앞으로 많은 기업들에서 CX를 중요시 하게 되며 CX Consultant가 비즈니스 전략의 큰 역할을 할 것이라고 생각한다.

소비자들이 경험을 중요시하는 시대가 왔다. 오프라인, 온라인 스토어 등에서 간단하게 특정 제품을 파는 형태에서 발전하여 특정 제품을 구매하는 소비자에게 해당 스토어 안에서 비주얼, 푸드, 액티비티 등 다양한 경험을 주고있다.

빅데이터, 클라우드, AR, 인공지능 등 다양한 신 기술들과의 결합을 통해 소비자들에게 더 앞선 경험을 줄 수 있는 시장이 열리고 있다. Data, Analysis, Experience, Customer 등을 고려하며 형태가 있는 제품에서부터 IT 서비스, 앱 등 무형의 서비스까지 소비자에게 더 나은 CX를 제공하는 전략이 필요하다고 생각한다.

참고 : http://uxd-trend.tistory.com/37

작성자 : 히더

[BOJ 15686] 치킨 배달

히더 — Mon, 8 Oct 2018 15:33:32 +0900

백준 :: BOJ :: 15686 :: 치킨 배달

출처 : https://www.acmicpc.net/problem/15686

#include <bits/stdc++.h>

using namespace std;

struct s {

int r, c, ch;

};

int N, M, tmp, ans;

vector <s> h, c;

vector<int>a;

vector<vector<int>> hh;

void dfs(int n, int ii) {

if (n == M) {

int r = 0;

for (int i = 0; i < h.size(); i++) {

int rr = 1e9;

for (int j = 0; j < a.size(); j++) {

rr = min(rr, hh[i][a[j]]);

}

r += rr;

}

ans = min(ans, r);

return;

}

for (int i = ii; i < c.size(); i++) {

a.push_back(c[i].ch); dfs(n+1, i + 1); a.pop_back();

}

return;

}

int main() {

std::ios::sync_with_stdio(false); cin.tie(0);

cin >> N >> M; ans = 1e9;

int cnt = 0;

for (int i = 1; i <= N; i++) for (int j = 1; j <= N; j++) {

cin >> tmp;

if (tmp == 1) h.push_back({ i,j,0 });

else if (tmp == 2) c.push_back({i,j,cnt++});

}

hh.resize(h.size());

int r = 0;

for (int i = 0; i < h.size(); i++) for (int j = 0; j < c.size(); j++)

hh[i].push_back(abs(h[i].c - c[j].c) + abs(h[i].r - c[j].r));

dfs(0,0);

cout << ans;

return 0;

}

[BOJ 15685] 드래곤 커브

히더 — Sun, 7 Oct 2018 19:52:10 +0900

백준 :: BOJ :: 15685 :: 드래곤 커브

출처 : https://www.acmicpc.net/problem/15685

#include <bits/stdc++.h>

using namespace std;

struct dc {

int x, y, d, s;

};

int N, ans, arr[101][101]; dc p;

int dx[] = {1,0,-1,0}, dy[] = {0,-1,0,1};

bool visited[101][101];

vector <dc> v; vector <int> dir;

inline bool check(int x, int y) { return arr[y][x] && arr[y + 1][x] && arr[y][x + 1] && arr[y + 1][x + 1] ? true : false; }

void cal() {

dir.push_back(0); dir.push_back(1);

for (int i = 2; i <= 10; i++) {

int m = pow(2, i - 1);

for (int j = 0; j < m; j++) {

if (j < (m / 2)) dir.push_back(dir[j] + 2);

else dir.push_back(dir[j]);

}

int main() {

std::ios::sync_with_stdio(false); cin.tie(0);

cin >> N; ans = 0;

while (N--) {

cin >> p.x >> p.y >> p.d >> p.s;

v.push_back({p.x,p.y,p.d,p.s});

}

cal();

for (int i = 0; i < v.size(); i++) {

p = v[i];arr[p.y][p.x] = 1;

for (int j = 0; j < pow(2, p.s); j++) {

p.x += dx[(dir[j] + p.d)%4]; p.y += dy[(dir[j] + p.d)%4];

arr[p.y][p.x] = 1;

}

for (int i = 0; i < 101; i++) for (int j = 0; j < 101; j++) if (check(j, i)) ans++;

cout << ans;

return 0;

}

[삼성 SW 테스트] 기출, 모의 기출 문제 정리 [업데이트 중]

히더 — Thu, 4 Oct 2018 19:38:06 +0900

[업데이트 중...]

최신 문제들 풀이 : https://2heedu.tistory.com/169

19 하반기, 19 상반기, 18 하반기, 18 상반기 관련 문제 : https://2heedu.tistory.com/169

옛날 코드들은 코드를 작성한지 꽤 시간이 지나서 좋지않은 코드가 많습니다. 참고해주세요.

다시 풀면서 수정해나가겠습니다.

삼성 SW 테스트 (S직군 인적성) 관련 알고리즘 문제들을 정리하였다.

백준 사이트에 있는 기출 문제와 SWEA에 있는 모의 SW 테스트 문제를 정리하였다.

문제의 분류는 직접 푼 방법으로 나누어 보았고, 난이도는 주관적인 기준이다.

문제 정리

[완전탐색]

시험 감독 (기출) / 백준 13458 / 난이도 1

보물상자 비밀번호 (모의 기출) / SWEA 5658 / 난이도 2

[시뮬레이션]

주사위 굴리기 (기출) / 백준 14499 / 난이도 2

핀볼 게임 (모의 기출) / SWEA 5650 / 난이도 2

로봇 청소기 (기출) / 백준 14503 / 난이도 2

활주로 건설 (모의 기출) / SWEA 4014 / 난이도 2

경사로 (기출) / 백준 14890 / 난이도 2

특이한 자석 (모의 기출) / SWEA 4013 / 난이도 2

톱니바퀴 (기출) / 백준 14891 / 난이도 2

미생물 격리 (모의 기출) / SWEA 5644 / 난이도 2

감시 (기출) / 백준 15683 / 난이도 3

드래곤 커브 (기출) / 백준 15685 / 난이도 3

벽돌 깨기 (모의 기출) / SWEA 5656 / 난이도 3

줄기세포배양 (모의 기출) / SWEA 5653 / 난이도 3

원자 소멸 시뮬레이션 (모의 기출) / SWEA 5648 / 난이도 3

무선 충전 (모의 기출) / SWEA 5644 / 난이도 3

[브루트포스 / 백트레킹]

요리사 (모의 기출) / SWEA 4012 / 난이도 2

스타트와 링크 (기출) / 백준 14889 / 난이도 2

숫자 만들기 (모의 기출) / SWEA 4008 / 난이도 2

연산자 끼워넣기 (기출) / 백준 14888 / 난이도 2

치킨 배달 (기출) / 백준 15686 / 난이도 2

보호 필름 (모의 기출) / SWEA 5644 / 난이도 2

벌꿀채취 (모의 기출) / SWEA 5644 / 난이도 2

연구소 (기출) / 백준 14502 / 난이도 2

사다리 조작 (기출) / 백준 15684 / 난이도 2

디저트 카페 (모의 기출) / SWEA 5644 / 난이도 2

등산로 조성 (모의 기출) / SWEA 5644 / 난이도 2

점심 식사시간 (모의 기출) / SWEA 5644 / 난이도 3

테트로미노 (기출) / 백준 14500 / 난이도 3

[BFS]

홈 방범 서비스 (모의 기출) / SWEA 5644 / 난이도 2

[DP]

수영장 (모의 기출) / SWEA 1952 / 난이도 3

퇴사 (기출) / 백준 14501 / 난이도 3

코드 및 설명

완전탐색

시험 감독 (기출) / 백준 13458 / 난이도 1

보물상자 비밀번호 (모의 기출) / SWEA 5658 / 난이도 2

시뮬레이션

주사위 굴리기 (기출) / 백준 14499 / 난이도 2

핀볼 게임 (모의 기출) / SWEA 5650 / 난이도 2

로봇 청소기 (기출) / 백준 14503 / 난이도 2

활주로 건설 (모의 기출) / SWEA 4014 / 난이도 2

경사로 (기출) / 백준 14890 / 난이도 2

특이한 자석 (모의 기출) / SWEA 4013 / 난이도 2

톱니바퀴 (기출) / 백준 14891 / 난이도 2

미생물 격리 (모의 기출) / SWEA 5644 / 난이도 2

감시 (기출) / 백준 15683 / 난이도 3

드래곤 커브 (기출) / 백준 15685 / 난이도 3

벽돌 깨기 (모의 기출) / SWEA 5656 / 난이도 3

줄기세포배양 (모의 기출) / SWEA 5653 / 난이도 3

원자 소멸 시뮬레이션 (모의 기출) / SWEA 5648 / 난이도 3

무선 충전 (모의 기출) / SWEA 5644 / 난이도 3

브루트포스 백트레킹

요리사 (모의 기출) / SWEA 4012 / 난이도 2

스타트와 링크 (기출) / 백준 14889 / 난이도 2

연산자 끼워넣기

숫자 만들기 (모의 기출) / SWEA 4008 / 난이도 2

치킨 배달 (기출) / 백준 15686 / 난이도 2

보호 필름 (모의 기출) / SWEA 5644 / 난이도 2

벌꿀채취 (모의 기출) / SWEA 5644 / 난이도 2

연구소 (기출) / 백준 14502 / 난이도 2

사다리 조작 (기출) / 백준 15684 / 난이도 2

디저트 카페 (모의 기출) / SWEA 5644 / 난이도 2

등산로 조성 (모의 기출) / SWEA 5644 / 난이도 2

점심 식사시간 (모의 기출) / SWEA 5644 / 난이도 3

테트로미노 (기출) / 백준 14500 / 난이도 3

BFS

홈 방범 서비스 (모의 기출) / SWEA 5644 / 난이도 2

수영장 (모의 기출) / SWEA 1952 / 난이도 3

퇴사 (기출) / 백준 14501 / 난이도 3

모든 문제 관련 출처

- 백준 SW 테스트 기출 문제 : https://www.acmicpc.net/workbook/view/1152

- SWEA 모의 SW 테스트 문제 : https://www.swexpertacademy.com/main/searchAll/searchMore.do?category=CODE&keyword=%EB%AA%A8%EC%9D%98+sw

작성자 : 히더

[BOJ 14499] 주사위 굴리기

히더 — Thu, 4 Oct 2018 14:58:41 +0900

백준 :: BOJ :: 14499 :: 주사위 굴리기

출처 : https://www.acmicpc.net/problem/14499

#include <bits/stdc++.h>

using namespace std;

int N, M, x, y, K;

int arr[20][20];

vector<int>dice = { 0,0,0,0,0,0 };

int dx[] = {0,1,-1,0,0}, dy[] = {0,0,0,-1,1};

inline bool check(int i, int j) { return i >= 0 && j >= 0 && i < N && j < M ? true : false; }

void Rolling(int d) {

vector<int>tmp(dice);

if (d == 1) {

dice[0] = tmp[3]; dice[2] = tmp[0]; dice[3] = tmp[5]; dice[5] = tmp[2];

}

else if (d == 2) {

dice[0] = tmp[2]; dice[2] = tmp[5]; dice[3] = tmp[0]; dice[5] = tmp[3];

}

else if (d == 3) {

dice[1] = tmp[0]; dice[0] = tmp[4]; dice[4] = tmp[5]; dice[5] = tmp[1];

}

else {

dice[1] = tmp[5]; dice[0] = tmp[1]; dice[4] = tmp[0]; dice[5] = tmp[4];

}

int main() {

std::ios::sync_with_stdio(false);cin.tie(0);

cin >> N >> M >> y >> x >> K; vector<int> order(K);

for (int i = 0;i < N;i++) for (int j = 0; j < M; j++) cin >> arr[i][j];

for (int i = 0; i < K; i++) cin >> order[i];

for (int k = 0; k < K; k++) {

if (check(y + dy[order[k]], x + dx[order[k]])) {

y += dy[order[k]]; x += dx[order[k]]; Rolling(order[k]);

if (arr[y][x]) {

dice[5] = arr[y][x]; arr[y][x] = 0;

}

else arr[y][x] = dice[5];

cout << dice[0] << '\n';

}

return 0;

}

[STL] List 리스트

히더 — Thu, 4 Oct 2018 13:11:19 +0900

List 리스트

자료구조 중 Doubly Linked list를 템플릿으로 구현 된 노드 기반 컨테이너이다.

STL list는 연결 리스트를 따로 만들지 않고 사용할 수 있다.

특징

1. 저장할 데이터 개수가 가변적일 때 유연하다. vector, deque 같이 배열 기반이 아니라 노드 기반이라 유연하다.

2. 중간에 데이터 삽입/삭제가 빠르다.

3. 배열은 랜덤 접근이 가능하나 list는 순차 접근만 가능하다.

#include <list>

list <int> l; int 자료형 list l 선언

l.push_front(a) : 첫 번째 위치에 a 데이터 추가

l.pop_front() : 첫 번째 위치 데이터 삭제

l.push_back(a) : 마지막 위치에 a 데이터 추가

l.pop_back() : 마지막 위치 데이터 삭제

l.front() : 첫 번째 위치 데이터 참조 리턴

l.back() : 마지막 위치 데이터 참조 리턴

l.clear() : 모든 데이터 삭제

l.empty() : 비었으면 true, 데이터가 있으면 false 리턴

l.size() : 데이터 개수 리턴

l.assign(3,0) : 0으로 초기화된 3개의 원소 할당

l.rbegin() : reverse begin

list의 특징적인 함수

l.remove(a) : a와 같은 원소 모두 삭제

l.remove_if(조건) : 조건에 해당하는 원소 모두 삭제

l. sort() : 오름차순 정렬

l.splice(it,l2) : l의 it이 가리키는 곳에서 l2의 모든 원소를 잘라 붙임

l.splice(it,l2,it2) : l의 it이 가리키는 곳에서 l2의 it2가 가리키는 원소를 잘라 붙임

l.unique() : 인접한 원소가 같으면 하나만 남기고 삭제

l.merge(l2) : l2를 l로 합병 정렬(오름차순)

작성자 : 히더

[STL] Hash_set 해시셋

히더 — Wed, 3 Oct 2018 18:42:28 +0900

Hash_set

hash 구조를 통해 정렬하지 않고 저장하여 map, set보다 더 빠른 검색속도를 가진다.

hash_map과 다르게 key만 있다. 단일 검색을 할때 사용한다.

#include <hahs_set>

hahs_set<int> hs; : int 자료형 key를 가지는 hahs_set hs선언

hs.size() : 노드 개수 리턴

hs.begin() : 첫 번째 원소 iterator

hs.end() : 마지막 원소 iterator

hs.find(a) : key가 a인 노드 찾아 해당 iterator 리턴, 만약 존재하지 않으면 마지막 iterator 리턴

hs.insert(a) : a key 삽입

hs.erase(hm.begin()) : 가장 앞 원소 삭제

hs.clear() : 모든 원소 삭제

hs.count(a) : key가 a인 원소들 개수 리턴

hs.lower_bound(a) : key가 a인 원소가 있다면 해당 위치의 반복자 리턴

hs.upper_bound(a) : key가 a인 원소가 있다현 해당 위치 다음 위치의 반복자 리턴

작성자 : 히더

[STL] Hash_map 해시맵

히더 — Wed, 3 Oct 2018 18:36:06 +0900

Hash_map

map이 트리 구조를 통해 원소를 정렬하여 저장하는 것과 다르게

hash 구조를 통해 정렬하지 않고 저장하여 map, set보다 더 빠른 검색속도를 가진다.

단일 검색을 할때 사용한다.

#include <hash_map>

hash_map<int, int> hm; : int 자료형 key, int 자료형 value를 가지는 hash_map hm 선언

hm.size() : 노드 개수 리턴

hm.begin() : 첫 번째 원소 iterator

hm.end() : 마지막 원소 iterator

hm.find(a) : key가 a인 노드 찾아 해당 iterator 리턴, 만약 존재하지 않으면 마지막 iterator 리턴

hm.insert(hash_map<int,int>::value_type(a,b)) : a key의 b value 삽입

hm.erase(hm.begin()) : 가장 앞 원소 삭제

hm.clear() : 모든 원소 삭제

hm.count(a) : key가 a인 원소들 개수 리턴

hm.lower_bound(a) : key가 a인 원소가 있다면 해당 위치의 반복자 리턴

hm.upper_bound(a) : key가 a인 원소가 있다현 해당 위치 다음 위치의 반복자 리턴

ex)

hash_map<int,string> hm;

hm.insert((hash_map<int,int>::value_type(1,"A"));

hm.insert((hash_map<int,int>::value_type(2,"B"));

hm.insert((hash_map<int,int>::value_type(3,"C"));

for(auto i=hm.lower_bound(1); i!=hm.upper_bound(3); i++)

cout << i->second << endl;

auto it = hm.find("2");

if(it!=hm.end()) it->second = "D";

작성자 : 히더

[STL] 시퀀스 컨테이너와 연관 컨테이너

히더 — Wed, 3 Oct 2018 18:19:42 +0900

시퀀스 컨테이너

데이터가 선형으로 저장되며, 제약이나 규칙이 없고 순서가 그대로 유지되는 컨테이너이다.

종류 : vector, list, deque

연관 컨테이너

중복되는 key를 통해 자료를 저장, 검색, 삽입, 삭제한다. 대용량 데이터와 빠른 검색을 위해 사용한다.

중복되는 key값을 위해서는 multi를 붙여 사용한다.

종류 : map, set, hash_map, hash_set

작성자 : 히더

[BOJ 7576] 토마토

히더 — Tue, 2 Oct 2018 21:04:57 +0900

백준 :: BOJ :: 7576 :: 토마토

출처 : https://www.acmicpc.net/problem/7576

#include <bits/stdc++.h>

using namespace std;

struct a {

int i, j;

};

int N, M, ans, result;

int arr[1000][1000];

int di[] = { 0,0,1,-1 }, dj[] = {1,-1,0,0};

bool visited[1000][1000];

queue<a> q;

inline bool check(int i, int j) { return (i >= 0 && j >= 0 && i < N && j < M) ? true : false; }

int bfs() {

if (ans == 0) return 0;

while (!q.empty()) {

int t = q.size();

while (t--) {

auto tmp = q.front(); q.pop();

for (int d = 0; d < 4; d++) {

int ni = tmp.i + di[d], nj = tmp.j + dj[d];

if (check(ni, nj) && arr[ni][nj]==0 && !visited[ni][nj]) {

visited[ni][nj] = 1; ans--; q.push({ ni,nj });

}

result++;

if (ans == 0) return result;

}

return -1;

}

int main() {

std::ios::sync_with_stdio(false); cin.tie(0);

cin >> M >> N; ans = 0; result = 0;

for (int i = 0; i < N; i++) for (int j = 0; j < M; j++) {

cin >> arr[i][j];

if (arr[i][j]==1) {

q.push({ i,j }); visited[i][j] = 1;

}

else if (arr[i][j] == 0) ans++;

}

cout << bfs();

return 0;

}

[BOJ 2178] 미로탐색

히더 — Tue, 2 Oct 2018 20:50:18 +0900

백준 :: BOJ :: 2178 :: 미로탐색

출처 : https://www.acmicpc.net/problem/2178

#include <bits/stdc++.h>

using namespace std;

struct a {

int i, j, c;

};

int N, M, ans;

int arr[101][101];

int di[] = { 0,0,1,-1 }, dj[] = {1,-1,0,0};

bool visited[101][101];

inline bool check(int i, int j) { return (i > 0 && j > 0 && i <= N && j <= M) ? true : false; }

int bfs() {

queue<a> q;

q.push({ 1, 1, 1 }); visited[1][1] = 1;

while (!q.empty()) {

auto tmp = q.front(); q.pop();

if (tmp.i == N && tmp.j == M) return tmp.c;

for (int d = 0; d < 4; d++) {

int ni = tmp.i + di[d], nj = tmp.j + dj[d];

if (check(ni, nj) && arr[ni][nj] && !visited[ni][nj]) {

q.push({ ni,nj,tmp.c + 1 }); visited[ni][nj] = 1;

}

int main() {

cin >> N >> M; ans = 0;

for (int i = 1; i <= N; i++) for (int j = 1; j <= M; j++) scanf("%1d", &arr[i][j]);

cout << bfs();

return 0;

}

[C++] 파일 입출력 string 한 줄씩 읽어오기

히더 — Tue, 2 Oct 2018 18:34:35 +0900

string이 들어있는 파일을 읽어서 한 줄씩 vector에 넣는 코드

#include <bits/stdc++.h>

using namespace std;

vector<string> ReadLine(string s) {

vector<string> r;

string line("");

ifstream in(s.c_str());

if (in.is_open())

{

while (!in.eof())

{

getline(in, line);

r.push_back(line);

}

in.close();

}

return r;

}

int main() {

string filename;

cin >> filename;

vector<string> v;

v = ReadLine(filename);

string Output = "aaa"

ofstream ofs;

ofs.open(Output);

ofs << 1 ;

ofs.close();

return 0;

}

작성자 : 히더

[HackerRank] Connected Cells in a Grid

히더 — Tue, 2 Oct 2018 14:33:04 +0900

출처 : https://www.hackerrank.com/challenges/connected-cell-in-a-grid/problem

#include <bits/stdc++.h>

using namespace std;

bool visited[10][10];

int cnt, dy[] = {0,0,1,-1, 1, 1 , -1, -1}, dx[] = {1,-1,0,0,-1,1,1,-1};

inline bool check(int i, int j, int n, int m) { return (i >= 0 && j >= 0 && i < n && j < m) ? true : false; }

int dfs(int n, int m, int i, int j, int cnt, vector<vector<int>> v) {

visited[i][j] = 1; cnt++;

for (int d = 0; d < 8; d++) {

int ni = i + dy[d], nj = j + dx[d];

if (check(ni,nj,n,m) && v[ni][nj] && !visited[ni][nj]) cnt = dfs(n,m,ni, nj, cnt, v);

}

return cnt;

}

int connectedCell(vector<vector<int>> matrix) {

int ans = 0, n = matrix.size(), m = matrix[0].size();

memset(visited, 0, sizeof(visited));

for (int i = 0; i < n; i++) {

for (int j = 0; j < m; j++) {

if (matrix[i][j] && !visited[i][j]) {

ans = max(ans, dfs(n,m,i, j, 0, matrix));

}

return ans;

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

int n;

cin >> n;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

int m;

cin >> m;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

vector<vector<int>> matrix(n);

for (int i = 0; i < n; i++) {

matrix[i].resize(m);

for (int j = 0; j < m; j++) {

cin >> matrix[i][j];

}

cin.ignore(numeric_limits<streamsize>::max(), '\n');

}

int result = connectedCell(matrix);

fout << result << "\n";

fout.close();

return 0;

}

[STL] Set 셋

히더 — Tue, 2 Oct 2018 13:51:19 +0900

Set 셋

set은 map과 비슷하지만 오직 key만 있다. map과 특징이 같고 빠른 검색이 필요할때 사용한다.

insert를 하게 되면 자동으로 정렬되어 저장된다.

만약, key값 중복을 원하면 multiset을 사용한다.

#include <set>

set<int> s; : int 자료형의 set s 선언

s.size() : 노드 개수 리턴

s.begin() : 첫 번째 원소 iterator

s.end() : 마지막 원소 iterator

s.find(a) : key가 a인 노드 찾아 해당 iterator 리턴, 만약 존재하지 않으면 마지막 iterator 리턴

s.insert(make_pair(a,b)) : a key의 b value 삽입

s.erase(a) : key가 a인 원소 삭제

s.clear() : 모든 원소 삭제

s.count(a) : key가 a인 원소들 개수 리턴

ex) set s에 vector v추가

// s : 1, 3 , v : 2, 3, 4

s.insert(v.begin(), v.end());

// s : 1, 2, 3, 4

작성자 : 히더

[HackerRank] Lily's Homework

히더 — Tue, 2 Oct 2018 13:39:37 +0900

출처 : https://www.hackerrank.com/challenges/lilys-homework/problem

#include <bits/stdc++.h>

using namespace std;

vector<string> split_string(string);

int cnt(vector<int>arr, vector<int>a, map<int, int> m) {

int ans = 0;

for (int i = 0; i<arr.size(); i++) {

if (arr[i] != a[i]) {

int tmp = m[a[i]];swap(arr[tmp], arr[i]);

m[arr[tmp]] = tmp; ans++;

}

return ans;

}

int lilysHomework(vector<int> arr) {

vector<int> v(arr); map<int, int> m;

for (int i = 0; i < arr.size(); i++) m[arr[i]] = i;

sort(v.begin(), v.end());

int ans = cnt(arr, v, m);

reverse(v.begin(), v.end());

return min(ans, cnt(arr, v, m));

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

int n;

cin >> n;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

string arr_temp_temp;

getline(cin, arr_temp_temp);

vector<string> arr_temp = split_string(arr_temp_temp);

vector<int> arr(n);

for (int i = 0; i < n; i++) {

int arr_item = stoi(arr_temp[i]);

arr[i] = arr_item;

}

int result = lilysHomework(arr);

fout << result << "\n";

fout.close();

return 0;

}

vector<string> split_string(string input_string) {

string::iterator new_end = unique(input_string.begin(), input_string.end(), [](const char &x, const char &y) {

return x == y and x == ' ';

});

input_string.erase(new_end, input_string.end());

while (input_string[input_string.length() - 1] == ' ') {

input_string.pop_back();

}

vector<string> splits;

char delimiter = ' ';

size_t i = 0;

size_t pos = input_string.find(delimiter);

while (pos != string::npos) {

splits.push_back(input_string.substr(i, pos - i));

i = pos + 1;

pos = input_string.find(delimiter, i);

}

splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

return splits;

}

[STL] Map 맵

히더 — Tue, 2 Oct 2018 13:38:15 +0900

Map 맵

각 노드가 key와 value의 쌍으로 이루어진 red-black tree이다.

key를 기준으로 정렬된 상태이기 때문에 검색, 삽입, 삭제 등의 속도가 빠르다.

주의할 점은 key가 중복이면 새로 추가하는 value값으로 덮어쓰기가 된다.

만약, key값 중복을 원하면 map말고 multimap을 사용한다.

#include <map>

map<key,value>처럼 key, value의 pair로 선언

map<int,int> m : key와 value 자료형이 int인 map m 선언

m.size() : 노드 개수 리턴

m.begin() : 첫 번째 원소 iterator

m.end() : 마지막 원소 iterator

m.find(a) : key가 a인 노드 찾아 해당 iterator 리턴, 만약 존재하지 않으면 마지막 iterator 리턴

m.insert(make_pair(a,b)) : a key의 b value 삽입

m.erase(a) : key가 a인 원소 삭제

m.clear() : 모든 원소 삭제

m.count(a) : key가 a인 원소들 개수 리턴

ex) unsorted 배열과 sorted 배열을 비교하여 sorting count 계산 코드

vector <int> unsorted_arr = { 4,3,1,2 };

vector <int> sorted_arr(unsorted_arr);

sort(sorted_arr.begin(), sorted_arr.end());

map<int, int> m;

for (int i = 0; i < arr.size(); i++) m[arr[i]] = i;

int ans = 0;

for (int i = 0; i<unsorted_arr.size(); i++) {

if (unsorted_arr[i] != sorted_arr[i]) {

int tmp = m[sorted_arr[i]]; swap(unsorted_arr[tmp], unsorted_arr[i]);

m[unsorted_arr[tmp]] = tmp; ans++;

}

cout << ans;

작성자 : 히더

[HackerRank] The Grid Search

히더 — Mon, 1 Oct 2018 21:32:52 +0900

출처 : https://www.hackerrank.com/challenges/the-grid-search/problem

#include <bits/stdc++.h>

using namespace std;

vector<string> split_string(string);

string gridSearch(vector<string> G, vector<string> P, int R, int r, int C, int c) {

for (int i = 0; i <= R - r; i++) {

for (int j = 0; j <= C - c; j++) {

bool chk = false;

for (int n = 0; n < r; n++) {

for (int m = 0; m < c; m++) {

if (G[i + n][j + m] != P[n][m]) {

chk = true; break;

}

if (chk) break;

}

if (!chk) return "YES";

}

return "NO";

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

int t;

cin >> t;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

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

string RC_temp;

getline(cin, RC_temp);

vector<string> RC = split_string(RC_temp);

int R = stoi(RC[0]);

int C = stoi(RC[1]);

vector<string> G(R);

for (int i = 0; i < R; i++) {

string G_item;

getline(cin, G_item);

G[i] = G_item;

}

string rc_temp;

getline(cin, rc_temp);

vector<string> rc = split_string(rc_temp);

int r = stoi(rc[0]);

int c = stoi(rc[1]);

vector<string> P(r);

for (int i = 0; i < r; i++) {

string P_item;

getline(cin, P_item);

P[i] = P_item;

}

string result = gridSearch(G, P,R,r,C,c);

fout << result << "\n";

}

fout.close();

return 0;

}

vector<string> split_string(string input_string) {

string::iterator new_end = unique(input_string.begin(), input_string.end(), [](const char &x, const char &y) {

return x == y and x == ' ';

});

input_string.erase(new_end, input_string.end());

while (input_string[input_string.length() - 1] == ' ') {

input_string.pop_back();

}

vector<string> splits;

char delimiter = ' ';

size_t i = 0;

size_t pos = input_string.find(delimiter);

while (pos != string::npos) {

splits.push_back(input_string.substr(i, pos - i));

i = pos + 1;

pos = input_string.find(delimiter, i);

}

splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

return splits;

}

[HackerRank] The Time in Words

히더 — Mon, 1 Oct 2018 20:56:16 +0900

출처 : https://www.hackerrank.com/challenges/the-time-in-words/problem

#include <bits/stdc++.h>

using namespace std;

string minutes[30] = { "one minute",

"two minutes",

"three minutes",

"four minutes",

"five minutes",

"six minutes",

"seven minutes",

"eight minutes",

"nine minutes",

"ten minutes",

"eleven minutes",

"twelve minutes",

"thirteen minutes",

"forteen minutes",

"quarter",

"sixteen minutes",

"seventeen minutes",

"eighteen minutes",

"nineteen minutes",

"twenty minutes",

"twenty one minutes",

"twenty two minutes",

"twenty three minutes",

"twenty four minutes",

"twenty five minutes",

"twenty six minutes",

"twenty seven minutes",

"twenty eight minutes",

"twenty nine minutes",

"half" };

string hours[12] = { "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve" };

string timeInWords(int h, int m) {

if (m == 0) return hours[h - 1] + " o' clock";

else if (m <= 30) return minutes[m - 1] + " past " + hours[h - 1];

else return minutes[60 - m - 1] + " to " + hours[h];

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

int h;

cin >> h;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

int m;

cin >> m;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

string result = timeInWords(h, m);

fout << result << "\n";

fout.close();

return 0;

}

[HackerRank] Bigger is Greater

히더 — Mon, 1 Oct 2018 20:49:00 +0900

출처 : https://www.hackerrank.com/challenges/bigger-is-greater/problem

#include <bits/stdc++.h>

using namespace std;

string biggerIsGreater(string w) {

string z; int n = w.size();

for (int i = n - 1; i >= 0; i--) {

if (i == 0) return "no answer";

if (w[i] == w[i - 1]) continue;

if (w[i] > w[i - 1]) {

char c; c = w[i]; w[i] = w[i - 1]; w[i - 1] = c;

return w;

}

else {

int j = i-1;

while (j>=0) {

if (w[j] >= w[j + 1]) {

if (j == 0) return "no answer";

j--; continue;

}

else {

char c = w[j];

z = w.substr(j + 1, n - (j + 1));

w.erase(j, n - j);

for (int m = 0; m < z.size(); m++) {

if (z[m] <= c) {

w += z[m - 1]; z[m - 1] = c;

for (int kk = z.size() - 1; kk >= 0; kk--) w += z[kk];

return w;

}

if (m == z.size() - 1) {

w += z[m]; z[m] = c;

for (int kk = z.size() - 1; kk >= 0; kk--) w += z[kk];

return w;

}

return w;

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

int T;

cin >> T;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

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

string w;

getline(cin, w);

string result = biggerIsGreater(w);

fout << result << "\n";

}

fout.close();

return 0;

}

[HackerRank] Organizing Containers of Balls

히더 — Mon, 1 Oct 2018 19:14:39 +0900

출처 : https://www.hackerrank.com/challenges/organizing-containers-of-balls/problem

#include <bits/stdc++.h>

using namespace std;

string organizingContainers(vector<vector<int>> container) {

int n = container.size(); vector<int> a(n,0), b(n,0);

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j++) {

b[i] += container[i][j]; a[j] += container[i][j];

}

sort(a.begin(), a.end()); sort(b.begin(), b.end());

for (int i = 0; i < n; i++) if (a[i] != b[i]) return "Impossible";

return "Possible";

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

int q;

cin >> q;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

for (int q_itr = 0; q_itr < q; q_itr++) {

int n;

cin >> n;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

vector<vector<int>> container(n);

for (int i = 0; i < n; i++) {

container[i].resize(n);

for (int j = 0; j < n; j++) {

cin >> container[i][j];

}

cin.ignore(numeric_limits<streamsize>::max(), '\n');

}

string result = organizingContainers(container);

fout << result << "\n";

}

fout.close();

return 0;

}

[HackerRank] Queen's Attack II

히더 — Sun, 30 Sep 2018 20:17:00 +0900

출처 : https://www.hackerrank.com/challenges/queens-attack-2/problem?h_r=internal-search

#include <bits/stdc++.h>

using namespace std;

vector<string> split_string(string);

int queensAttack(int n, int k, int r_q, int c_q, vector<vector<int>> obstacles) {

int ans = 0;

bool check[8] = {0,0,0,0,0,0,0,0};

int ck[8] = { 0,0,0,0,0,0,0,0 };

for (int i = 0; i < k; i++) {

int xr = obstacles[i][0]; int xc = obstacles[i][1];

if (xr == r_q && xc != c_q) {

if (xc > c_q) {

if (check[2]) ck[2] = min(ck[2], (xc - c_q - 1));

else { check[2] = true; ck[2] = (xc - c_q - 1); }

}

else {

if (check[6]) ck[6] = min(ck[6], (c_q - xc - 1));

else { check[6] = true; ck[6] = (c_q - xc - 1);}

}

else if (xc == c_q && xr != r_q) {

if (xr > r_q) {

if (check[0]) ck[0] = min(ck[0], (xr - r_q - 1));

else { check[0] = true; ck[0] = (xr - r_q - 1); }

}

else {

if (check[4]) ck[4] = min(ck[4], (r_q - xr - 1));

else { check[4] = true; ck[4] = (r_q - xr - 1); }

}

else if (abs(xr - r_q) == abs(xc - c_q)) {

if (xr > r_q) {

if (xc > c_q) {

if (check[1]) ck[1] = min(ck[1], (abs(xr - r_q) - 1));

else { check[1] = true; ck[1] = (abs(xr - r_q) - 1); }

}

else {

if (check[7]) ck[7] = min(ck[7], (abs(xr - r_q) - 1));

else { check[7] = true; ck[7] = (abs(xr - r_q) - 1); }

}

else {

if (xc > c_q) {

if (check[3]) ck[3] = min(ck[3], (abs(xr - r_q) - 1));

else { check[3] = true; ck[3] = (abs(xr - r_q) - 1); }

}

else {

if (check[5]) ck[5] = min(ck[5], (abs(xr - r_q) - 1));

else { check[5] = true; ck[5] = (abs(xr - r_q) - 1); }

}

for (int i = 0; i < 8; i++) if (ck[i]) ans += ck[i];

for (int d = 0; d < 8; d++) {

if (!check[d]) {

if (d == 0) ans += (n - r_q);

else if (d == 4 ) ans += (r_q - 1);

else if (d == 2 ) ans += (n - c_q);

else if (d == 6 ) ans += (c_q - 1);

else if (d == 1 ) ans += (min((n-c_q),(n-r_q)));

else if (d == 3 ) ans += (min((n - c_q), (r_q-1)));

else if (d == 5 ) ans += (min((c_q-1), (r_q-1)));

else if (d == 7 ) ans += (min((c_q-1), (n - r_q)));

}

return ans;

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

string nk_temp;

getline(cin, nk_temp);

vector<string> nk = split_string(nk_temp);

int n = stoi(nk[0]);

int k = stoi(nk[1]);

string r_qC_q_temp;

getline(cin, r_qC_q_temp);

vector<string> r_qC_q = split_string(r_qC_q_temp);

int r_q = stoi(r_qC_q[0]);

int c_q = stoi(r_qC_q[1]);

vector<vector<int>> obstacles(k);

for (int i = 0; i < k; i++) {

obstacles[i].resize(2);

for (int j = 0; j < 2; j++) {

cin >> obstacles[i][j];

}

cin.ignore(numeric_limits<streamsize>::max(), '\n');

}

int result = queensAttack(n, k, r_q, c_q, obstacles);

fout << result << "\n";

fout.close();

return 0;

}

vector<string> split_string(string input_string) {

string::iterator new_end = unique(input_string.begin(), input_string.end(), [](const char &x, const char &y) {

return x == y and x == ' ';

});

input_string.erase(new_end, input_string.end());

while (input_string[input_string.length() - 1] == ' ') {

input_string.pop_back();

}

vector<string> splits;

char delimiter = ' ';

size_t i = 0;

size_t pos = input_string.find(delimiter);

while (pos != string::npos) {

splits.push_back(input_string.substr(i, pos - i));

i = pos + 1;

pos = input_string.find(delimiter, i);

}

splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

return splits;

}

[HackerRank] Encryption

히더 — Sun, 30 Sep 2018 17:02:31 +0900

출처 : https://www.hackerrank.com/challenges/encryption/problem

#include <bits/stdc++.h>

using namespace std;

string encryption(string s) {

string ans;

int L = s.length(), row = sqrt(L), col = row + 1, it = 0;

if (row*row == L) col -= 1;

if (row*col < L) row += 1;

char arr[10][10]; memset(arr, 0, sizeof(arr));

for (int i = 0; i < row; i++) {

for (int j = 0; j < col && it<L; j++) {

arr[i][j] = s.at(it);it++;

}

for (int j = 0; j < col; j++) {

for (int i = 0; i < row; i++) {

if (arr[i][j]) ans += arr[i][j];

}

if(j!=col-1)ans += " ";

}

return ans;

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

string s;

getline(cin, s);

string result = encryption(s);

fout << result << "\n";

fout.close();

return 0;

}

[HackerRank] Non-Divisible Subset

히더 — Sun, 30 Sep 2018 16:28:32 +0900

출처 : https://www.hackerrank.com/challenges/non-divisible-subset/problem

#include <bits/stdc++.h>

using namespace std;

vector<string> split_string(string);

int check[100];

int nonDivisibleSubset(int k, vector<int> S) {

int ans = 0; memset(check, 0, sizeof(check));

for (int i = 0; i < S.size(); i++) {

S[i] %= k; check[S[i]]++;

}

int tmp = k / 2; int i = tmp; int j = tmp + 1;

if (check[0]) ans++;

if (!(k % 2)) {

if (check[tmp]) ans++;

i--;

}

for (i,j; i >= 1; i--, j++) {

int z = min(check[i], check[j]);

ans += (check[i] + check[j] - (z * 2) + z);

}

return ans;

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

string nk_temp;

getline(cin, nk_temp);

vector<string> nk = split_string(nk_temp);

int n = stoi(nk[0]);

int k = stoi(nk[1]);

string S_temp_temp;

getline(cin, S_temp_temp);

vector<string> S_temp = split_string(S_temp_temp);

vector<int> S(n);

for (int i = 0; i < n; i++) {

int S_item = stoi(S_temp[i]);

S[i] = S_item;

}

int result = nonDivisibleSubset(k, S);

fout << result << "\n";

fout.close();

return 0;

}

vector<string> split_string(string input_string) {

string::iterator new_end = unique(input_string.begin(), input_string.end(), [](const char &x, const char &y) {

return x == y and x == ' ';

});

input_string.erase(new_end, input_string.end());

while (input_string[input_string.length() - 1] == ' ') {

input_string.pop_back();

}

vector<string> splits;

char delimiter = ' ';

size_t i = 0;

size_t pos = input_string.find(delimiter);

while (pos != string::npos) {

splits.push_back(input_string.substr(i, pos - i));

i = pos + 1;

pos = input_string.find(delimiter, i);

}

splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

return splits;

}

[HackerRank] Forming a Magic Square

히더 — Sun, 30 Sep 2018 15:53:17 +0900

출처 : https://www.hackerrank.com/challenges/magic-square-forming/problem

#include <bits/stdc++.h>

using namespace std;

int MS[8][3][3] = {{ 2,9,4,7,5,3,6,1,8 },

{ 4,3,8,9,5,1,2,7,6 },

{ 4,9,2,3,5,7,8,1,6 },

{ 8,3,4,1,5,9,6,7,2 },

{ 8,1,6,3,5,7,4,9,2 },

{ 2,7,6,9,5,1,4,3,8 },

{ 6,1,8,7,5,3,2,9,4 },

{ 6,7,2,1,5,9,8,3,4 }};

int formingMagicSquare(vector<vector<int>> s) {

int ans = 9999, cnt=0;

for (int m = 0; m < 8; m++) {

cnt = 0;

for (int i = 0; i < 3; i++) for (int j = 0; j < 3; j++) cnt += abs(s[i][j] - MS[m][i][j]);

ans = min(ans, cnt);

}

return ans;

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

vector<vector<int>> s(3);

for (int i = 0; i < 3; i++) {

s[i].resize(3);

for (int j = 0; j < 3; j++) {

cin >> s[i][j];

}

cin.ignore(numeric_limits<streamsize>::max(), '\n');

}

int result = formingMagicSquare(s);

fout << result << "\n";

fout.close();

return 0;

}

[STL] Deque 덱

히더 — Sun, 30 Sep 2018 14:35:04 +0900

Deque 덱

Double Ended Queue 자료구조다. 즉 queue와 stack의 장점을 가져온 것이다.

double linked list와 비슷하다고 생각하면 된다.

장점

앞과 뒤에서 삽입, 삭제가 좋다.

리스트처럼 크기가 가변적이다.

vector처럼 원소에 랜덤 접근 가능하다.

단점

vector와 같이 중간에 삽입, 삭제를 위해서는 해당 위치 앞 뒤 데이터를 모두 이동해야 한다.

#include <deque>

deque<int> dq : int형 deque dq 선언

deque dq(n) : n개의 원소를 가진 dq 선언

deque dq(n,a) : a로 초기화된 n개의 원소를 가진 dq 선언

deque dq(dq2) : deque dq2를 dq에 복사

dq.assign(n,a) : a값으로 n개의 원소를 v에 할당

dq.at(a) : a번째 원소 (범위를 점검, 안전)

dq[a] : a번째 원소 (범위를 점검X, 빠름)

dq.front() : 제일 앞 원소

dq.back() : 마지막 원소

dq.begin() : beginning iterator

dq.end() : end iterator

dq.clear() : 모든 원소 제거 ( 메모리는 제거X)

dq.empty() : 비었는지 판단

dq.erase(i) : i가 가리키는 곳 제거

dq.erase(a,b) : [a,b) 범위 제거

dq.insert(a,b) : a위치에 b삽입

dq.insert(a,b,c) : a위치에 b개의 c 삽입 / a위치에 [b,c)의 원소 삽입 (값인지 iterator인지의 차이)

dq.max_size() : 최대 원소 개수 (메모리 크기)

dq.size() : 원소의 개수

dq.capacity : 메모리 크기

dq. pop_back() : 마지막 원소 제거

dq.push_front(a) : dq의 앞에 a추가

dq. push_back(a) : v의 끝에 a추가

dq.rbegin() : 역 순의 첫 원소 가리킴

dq.rend() : 역 순의 마지막의 다음 가리킴

dq.reserve(n) : n개의 원소 공간 미리 동적할당

dq.resize(n) : 크기를 n으로 변경

dq.resize(a,b) : 크기를 a로 변경하는데 더 커졌을 경우 b로 초기화

작성자 : 히더

비트 연산자

히더 — Sat, 29 Sep 2018 20:54:36 +0900

비트 연산자

& : And 연산 101 & 100 = 100

| : OR 연산 011 | 100 = 111

^ : XOR 연산 101 ^ 111 = 010

~ : 비트 반전 ~(101) = 010

<< : 비트 열 왼쪽 이동 1<<3 = 100

>> : 비트 열 오른쪽 이동 1101>>2 = 11

작성자 : 히더

[SWEA 5653] 줄기세포배양

히더 — Sat, 29 Sep 2018 20:37:33 +0900

SW Expert Academy :: SWEA :: 5653 :: 줄기세포배양

출처 : https://www.swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWXRJ8EKe48DFAUo

#include <bits/stdc++.h>

using namespace std;

struct cell {

int life, x, y;

};

int t, tc, ans;

int N, M, K;

int J[450][450];

int dx[] = { 0,0,1,-1 }, dy[] = { 1,-1,0,0 };

queue<cell> q[11];

void input() {

for (int i = 0;i < 11;i++)while (!q[i].empty()) q[i].pop();

ans = 0; memset(J, 0, sizeof(J)); cin >> N >> M >> K;

for (int i = 0; i < N; ++i) for (int j = 0; j < M; ++j) {

cin >> J[i + 175][j + 175];

if (J[i + 175][j + 175]) {

q[J[i + 175][j + 175]].push({ 2 * J[i + 175][j + 175], i + 175, j + 175 });

}

void cal() {

for (int i = 0; i <= K; ++i) {

for (int j = 10; j >= 1; --j) {

int q_s = q[j].size();

for (int k = 0; k < q_s; ++k) {

cell cl = q[j].front(); q[j].pop();

if (cl.life > j) {

if (J[cl.x][cl.y]>0) {

J[cl.x][cl.y] *= -1; ans++;

}

q[j].push({ cl.life - 1,cl.x,cl.y });

}

else if (cl.life == j) {

q[j].push({ j - 1,cl.x,cl.y });

for (int l = 0; l < 4; ++l) {

int nx = cl.x + dx[l];int ny = cl.y + dy[l];

if (J[nx][ny]) continue;

q[j].push({ 2 * j,nx,ny });J[nx][ny] = j;

}

else if (j > cl.life && cl.life) q[j].push({ cl.life - 1,cl.x,cl.y });

else ans--;

}

int main() {

ios::sync_with_stdio(false); cin.tie(0);

cin >> t;

for (tc = 1; tc <= t; ++tc) {

input(); cal();

cout << "#" << tc << " " << ans << '\n';

}

return 0;

}

[SWEA 5656] 벽돌 깨기

히더 — Sat, 29 Sep 2018 17:29:21 +0900

SW Expert Academy :: SWEA :: 5656 :: 벽돌 깨기

출처 : https://www.swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWXRQm6qfL0DFAUo

#include <bits/stdc++.h>

using namespace std;

int T, tc, c, N, W, H;

int dx[] = { 0,0,1,-1 }, dy[] = { 1,-1,0,0 };

int arr[5][15][12];

void go(int D) {

queue<int> q;

for (int j = 0; j < W; j++) {

for (int i = H - 1; i >= 0; i--) {

if (arr[D][i][j]) {

q.push(arr[D][i][j]); arr[D][i][j] = 0;

}

for (int i = H - 1; q.size(); i--, q.pop()) arr[D][i][j] = q.front();

}

int dfs(int x, int y, int D) {

int k = arr[D][x][y]; int ans = 1; arr[D][x][y] = 0;

for (int i = 0; i < k; i++) {

for (int j = 0; j < 4; j++) {

int nx = x + i*dx[j]; int ny = y + i*dy[j];

if (nx < 0 || ny < 0 || nx >= H || ny >= W || !arr[D][nx][ny]) continue;

ans += dfs(nx, ny, D);

}

return ans;

}

int cal(int D) {

if (D > N) return 0; int ans = 0;

for (int i = 0; i < W; i++) {

for (int m = 0; m < H; m++) for (int n = 0; n < W; n++) arr[D][m][n] = arr[D - 1][m][n];

int tmp = 0; bool flg = 1;

for (int j = 0; j < H; j++) {

if (arr[D][j][i]) {

flg = 0;

tmp = dfs(j, i, D);

break;

}

if(flg) continue;

go(D); ans = max(ans, cal(D + 1) + tmp);

}

return ans;

}

int main() {

ios::sync_with_stdio(false); cin.tie(0);

cin >> T;

for (tc = 1; tc <= T; tc++) {

cin >> N >> W >> H;

int cnt = 0;

for (int i = 0; i < H; i++) for (int j = 0; j < W; j++) {

cin >> c; arr[0][i][j] = c; cnt += c ? 1 : 0;

}

cout << "#" << tc << " " << cnt - cal(1) << '\n';

}

return 0;

}

[알고리즘] 기본 및 복잡도

히더 — Sat, 29 Sep 2018 14:26:25 +0900

알고리즘이란?

유한한 단계로 문제를 해결하는 로직이다. 컴퓨터가 어떤 일을 하는 수행의 단계적 방법이다.

효율적인 알고리즘

메모리 공간을 최적화 하는 공간적 효율성, 수행 시간에 대해 최소의 시간을 고려하는 시간적 효율성 고려해야한다.

효율성이 즉 복잡도가 된다.

이러한 부분은 아키텍처, 자료구조, HW 환경, SW 환경 등 다양한 요소를 고려해야한다.

복잡도의 점근적 표기 Big-Oh

시간 복잡도를 입력 크기에 대한 함수로 표기할 수 있다. 이를 점근적 표기(Asymptotic Notation)라 한다.

가장 큰 예로 Big-Oh 표기법이 있다. Big-Oh는 최대 이런 시간이 걸린다는 의미를 가진다.

O(1) : 상수 시간 (Constant time)

O(logn) : 로그(대수) 시간 (Logarithmic time)

O(n) : 선형 시간 (Linear time)

O(nlongn) : 로그 선형 시간 (Log-linear time)

O(n제곱) : 제곱 시간 (Quadratic time)

O(n세제곱) : 세제곱 시간 (Cubic time)

O(2의n제곱) : 지수 시간 (Exponential time)

작성자 : 히더

auto

히더 — Fri, 28 Sep 2018 20:07:19 +0900

auto는 자동으로 타입을 추론한다. 그러나 초기화는 반드시 해주어야 한다.

iterator을 사용하게 될 때 유용하다.

아래는 HackerRank 알고리즘 문제에서 사용했었던 auto의 예시이다. vector의 iterator type을 위해 auto를 사용했다.

이때 j는 iterator이라서 *j 는 v[j]의 값을 가리키게 된다.

void extraLongFactorials(int n) {

vector<int> v; v.push_back(1);

for (int i = 2; i <= n; i++) {

for (auto j = v.begin();j != v.end();j++) *j *= i;

for (int k = 0; k < v.size(); k++) {

if (v[k] < 10) continue;

if (k == v.size() - 1) v.push_back(0);

v[k + 1] += v[k] / 10; v[k] %= 10;

}

for (auto it = v.rbegin(); it != v.rend(); it++) cout << *it;

}

작성자 : 히더

[HackerRank] Extra Long Factorials

히더 — Fri, 28 Sep 2018 20:02:29 +0900

출처 : https://www.hackerrank.com/challenges/extra-long-factorials/problem

#include <bits/stdc++.h>

using namespace std;

void extraLongFactorials(int n) {

vector<int> v; v.push_back(1);

for (int i = 2; i <= n; i++) {

for (auto j = v.begin();j != v.end();j++) *j *= i;

for (int k = 0; k < v.size(); k++) {

if (v[k] < 10) continue;

if (k == v.size() - 1) v.push_back(0);

v[k + 1] += v[k] / 10; v[k] %= 10;

}

for (auto it = v.rbegin(); it != v.rend(); it++) cout << *it;

}

int main()

{

int n;

cin >> n;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

extraLongFactorials(n);

return 0;

}

[HackerRank] Climbing the Leaderboard

히더 — Fri, 28 Sep 2018 19:18:02 +0900

출처 : https://www.hackerrank.com/challenges/climbing-the-leaderboard/problem

#include <bits/stdc++.h>

using namespace std;

vector<string> split_string(string);

vector<int> climbingLeaderboard(vector<int> scores, vector<int> alice) {

int s_size = scores.size(); int a_size = alice.size();

vector <int> ans(a_size), tmp(s_size); int n = 1; tmp[0] = n;

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

if (scores[i] == scores[i - 1]) tmp[i] = n;

else tmp[i] = ++n;

}

int it = s_size - 1;

for (int j = 0; j < a_size; j++) {

for (int i = it; i >=0; i--) {

if (scores[i] < alice[j]) {

if (i == 0) {

ans[j] = 1; it = 1; break;

}

continue;

}

else if (scores[i]>alice[j]) {

ans[j] = tmp[i] + 1; it = i;break;

}

else {

ans[j] = tmp[i]; it = i; break;

}

return ans;

}

int main()

{

ofstream fout(getenv("OUTPUT_PATH"));

int scores_count;

cin >> scores_count;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

string scores_temp_temp;

getline(cin, scores_temp_temp);

vector<string> scores_temp = split_string(scores_temp_temp);

vector<int> scores(scores_count);

for (int i = 0; i < scores_count; i++) {

int scores_item = stoi(scores_temp[i]);

scores[i] = scores_item;

}

int alice_count;

cin >> alice_count;

cin.ignore(numeric_limits<streamsize>::max(), '\n');

string alice_temp_temp;

getline(cin, alice_temp_temp);

vector<string> alice_temp = split_string(alice_temp_temp);

vector<int> alice(alice_count);

for (int i = 0; i < alice_count; i++) {

int alice_item = stoi(alice_temp[i]);

alice[i] = alice_item;

}

vector<int> result = climbingLeaderboard(scores, alice);

for (int i = 0; i < result.size(); i++) {

fout << result[i];

if (i != result.size() - 1) {

fout << "\n";

}

fout << "\n";

fout.close();

return 0;

}

vector<string> split_string(string input_string) {

string::iterator new_end = unique(input_string.begin(), input_string.end(), [](const char &x, const char &y) {

return x == y and x == ' ';

});

input_string.erase(new_end, input_string.end());

while (input_string[input_string.length() - 1] == ' ') {

input_string.pop_back();

}

vector<string> splits;

char delimiter = ' ';

size_t i = 0;

size_t pos = input_string.find(delimiter);

while (pos != string::npos) {

splits.push_back(input_string.substr(i, pos - i));

i = pos + 1;

pos = input_string.find(delimiter, i);

}

splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

return splits;

}

[Kotlin] Kotlin과 Java

히더 — Fri, 28 Sep 2018 16:23:38 +0900

참조 : https://kotlinlang.org https://blog.jetbrains.com/kotlin/

Kotlin?

Android 앱 개발을 하면서 Java를 사용하였고 Studio에서 제공하는 Kotlin 변환 기능을 보면서 Kotlin에 관심을 가지게 되었다.

Kotlin은 Jetbrains에서 만든 개발언어다. Android, JVM, 브라우저 등에서 사용가능하며 앞으로 웹, 임베디드, IoT 등 다양한 플랫폼으로 진출한다는 목표를 가지고 있다고 한다. 정적 타입의 언어로 2011년에 출시되었고 많은 앱 개발자들이 사용하고 있다.

Kotlin vs Java

1. val과 var

Kotlin은 변수 선언에서 val과 var을 사용한다. 타입추론이 가능하여서 Java와 다르게 type 생략이 가능하다. 또한 ;을 생략가능하다.

var은 variable의 약자로 read/write가 가능한 일반 변수(mutable)이다.

val은 valuable의 약자로 read만 가능한 final 변수(immutable)이다.

Java	Kotlin
final int tmp = 1;	val tmp = 1
String tmp = "a";	var tmp = "a"

초기화시 값을 할당하지 않는다면 type을 명시합니다. val tmp: Int type명은 제일 앞글자를 대문자로 합니다.

Java에서 Void tmp = null; 처럼 val tmp: Nothing? = null 과 같이 type을 생략할 수 있습니다.

2. Non-Null / Nullable

Kotlin은 null 안정성을 가지고 있다. 모든 변수는 null을 허용하지 않지만 변수에 ?를 붙여서 nullable로 만들 수 있다.

null을 값으로 가질 수 없으면 Non-Null, 가질 수 있으면 Nullable

var tmp: String? = null 과 같이 쓰며 ?를 사용한다.

val tmp: Nothing? = null 과 같이 type을 생략할 수 있다.

3. variable cast

Kotlin에서는 as와 is를 통해 casting이 가능하다. as는 값의 casting, is는 값이 맞는지 체크한다.

Java

Kotlin

Object object = "a";

int it = 0;

if(object instanceof Integer) {

it = (int) object;

}

val a: Any? = "a"

val b: Int? = a as? Int

if (a is Int) {

b = a as? Int

}

4. Println

출력을 할 때 $를 통해 간편하게 할 수 있다.

Java	Kotlin
System.out.println("a" + tmp);	println("a $tmp")

5. Class와 Propery

Kotlin에서는 1개의 primary constructor, N개의 secondary constructor을 가진다. primary constructor을 위한 init {} block을 제공한다.

또한 primary constructor와 함께 오는 변수는 전역 변수이다.

default 값을 가질 수 있으며 default value 정의한 생성자를 Java에서 부르려면, @JvmOverloads를 적용해야 한다.

Kotlin에서는 따로 나타내지 않으면 모두 public이다. class는 아래와 같이 선언한다.

class Example(

val name: String

var isMan: Boolean

)

fun main(args: Array<String>) {

val person = Example("Heedu", true)

}

위와 같은 코드가 있을 때 컴파일러가 자동으로 getter와 setter를 만들어 준다. isMan처럼 is로 시작하는 property getter에는 get이 붙지 않고 is를 사용한다.

6. companion object

Kotlin에서는 static 대신 companion object를 사용하여 외부 접근을 가능하게 한다.

7. when

Kotlin에서 when은 다양하게 쓰인다.

when을 switch처럼 쓰는데 이때, break이 필요없다. 조건문 및 반복문에서 when이 is와 함께 많이 쓰인다.

8. Loop

Kotlin에서 반복문 중 for문이 Java와 조금 다르다.

Java

Kotlin

for (i=0;i<10;i++)

for(i=0;i<=10;i++)

for(i=10;i>=0;i--)

for(i=0;i<=10;i+=3);

for (i in 0 until 10)

for (i in 0 .. N)

for (i in 10 downTo 0)

for(i in 0 .. 10 step 3)

9. Safe call과 Elvis operator

Kotlin에서 ?. 을 통해 안전 호출을 할 수 있다. 앞의 타입이 null이 아니면 호출하여 값을 리턴하고 아니면 null을 호출한다.

Elvis operator ?: 은 앞의 값이 참이면 값을 반환하고 아니면 지정한 값을 반환한다.

val tmp = a?.length ?: -1

강제호출을 할때는 !! 을 사용한다.

10. 상속

Java

Kotlin

Default class : 모든 class/function은 재 정의 가능

abstract : extends로 상속 구현

interface : implement로 상속 구현

public interface A {

void init();

}

public abstract class B {

public abstract void init();

}

public class C extends B implements A {

@Override

public void init() {

}

Default class : 모든 class/function은 재 정의 불가

재 정의를 위해서는 open 사용

상속의 정의는 : 으로 한다.

다중 상속은 , 로 한다.

interface A {

fun init()

}

abstract class B {

abstract fun init()

}

class C : B(), A {

override fun init() {

}

11. data class

Java

Kotlin

public class User {

private long id;

private String name;

private String email;

@Override

public int hashCode() {

return 1;

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null) return false;

if (this.getClass() != o.getClass()) return false;

User user = (User) o;

return id != user.id

&& (!name.equals(user.name)

&& !email.equals(user.email));

}

data class User(val id: Long = 0,

val name: String? = null,

val email: String? = null)

12. 기타

외에도 여러가지 Java와 다른 Kotlin 기능들이 있다. Sealed class, singleton, lazy evaluation, Lambda, ViewBinding 등이 있다.

위 글을 써보면서 실제 대형 프로젝트를 kotlin을 이용해서 하기 위해서는 더 많은 공부가 필요하다고 생각했다. 아직 완전 Kotlin으로만 완성된 앱보다는 Java와의 혼용이 된 앱이 많으므로 이를 고려해야 할 것 같다.

작성자 : 히더

메모리와 비메모리

히더 — Fri, 28 Sep 2018 14:07:45 +0900

메모리

1. 휘발성 (RAM)

- D램 : PC용 주기억장치로 정보처리 속도 및 그래픽 처리 능력에 따라 SSD, DDR 등이 있다.

- S램 : 소비전력이 적고 처리속도가 빨라서 cache에 사용.

- V램 : 화상정보를 기억하기 위한 전용 메모리.

2. 비휘발성 (ROM)

- Mask롬 : 제조공정 시 고객이 원하는 정보를 저장.

- EP롬 : 자외선을 이용하여 정보를 지우거나 저장.

- EEP롬 : ROM의 특징과 입출력할 수 있는 RAM의 특징을 가짐.

- Flash 메모리 : 전력소모가 적고 고속 프로그래밍, 대용량 저장 가능. HDD를 대체할 수 있는 제품으로 NOR(코드저장)과 NAND(데이터저장).

비메모리

1. 시스템 IC

- 마이크로컴포넌트 : 컴퓨터 제어. Micro Processor Unit, Micro Controller Unit, Digital Signal Processor.

- Logic (ASIC) : 사용자 요구에 의해 설계된 특정 회로 반도체로 주문형 IC

- Analog IC : 제반 신호의 표현 처리를 연속적인 신호변환에 의해 인식하는 IC.

- LDI : LCD driver IC로서 구동 또는 제어 사용.

2. 개별소자 : Diode, 트랜지스터처럼 직접회로(IC)와는 달리 개별품목으로서 단일기능을 갖는 제품. 개별소자가 모여 IC.

3. 기타 : Opto (광반도체), 반도체 센서 등

작성자 : 히더