pushback

사실 결과는 4월 11일에 나오긴 했는데... 바빠서 이제 쓴다.

라인 필기 보기 전에 좀 검색해보니까 다들 어렵다고 그러길래 겁 먹은 상태로 시험에 응시했고, 깊이가 있어 확실히 쉽지 않았다.

34문제를 90분 내에 해결해야하고, 객관식과 단답형 주관식 섞여 나온다.

뻔하지만 OS, 네트워크 + HTTP에 대해 정확하게, 데이터베이스, 자료구조, 알고리즘, 객체 프로그래밍, 컴퓨터 구조론, 컴파일러를 확실하게 알고, 다른 사람의 코드 해석을 해본 경험이 있다면 만점으로 통과할 것이다. (만점으로 몇 명이나 통과하려나;;?)

나 같은 경우, 컴공 전공자에 전공 수업에 꽤 진심이었던 사람이라 넘을 수 없는 벽을 넘어야하는 그런 테스트까진 아니었다. 물론 몇 문제는 모르는 내용이라 찍기도 했지만..ㅋㅋㅋ

당연히 만점으로 통과하진 못했겠지만, 테스트 종료 후에 내가 만약 떨어진다면 자소서 때문에 떨어질 것 같다라는 생각을 했었다.

조언 아닌 조언을 한다면,

• CS에 자신있는 사람 - 5대 CS과목을 위주로 깊이 있게 한번 돌려보자.
• CS에 자신없는 사람 - 코테 합격 후 잠깐 공부해서 합격하기엔 어려운 시험이다. 한번 경험해보자라는 긍정적인 마인드로 시험 볼 때 아는 내용의 문제는 확실하게 풀자. 자소서에서 높은 점수를 받아 합격할지 누가 알겠는가?

정도 일 것 같다. 

이 글을 읽는 모든 분에게 무운을 빈다 !

여담으로 저는 1차 면접을 포기했습니다. 

너무나도 좋은 기회였지만, 면접까지 붙기에는 아직 부족한 실력이라고 생각을 하던 차에 다른 기업에 최종합격을 하여 포기하게 됐습니다.

물론, 최종합격을 포기하고 도전할 수도 있었지만.. 생각처럼 쉽게 최종합격이란 것을 포기할 수가 없었습니다 ㅎㅎ..

면접 불참 메일을 채용 담당자님에게 전했고, 친절하게 응대해주신 라인 채용 담당자분들에게 감사 말씀 드립니다.

저는 비록 여기서 멈췄지만, 계속해서 라인 공개채용을 진행중인 분들 모두 잘되셨으면 좋겠습니다. 화이팅

자. 삼각형을 살짝 바꾸자.

        7
      3   8
    8   1   0
  2   7   4   4
4   5   2   6   5

이 삼각형을

7
3   8
8   1   0
2   7   4   4
4   5   2   6   5

이렇게. 풀기 훨씬 쉬워졌다.

dp[n][k]는 (0,0)에서 (n, k)까지 가면서 선택된 수들의 최대 합이라고 하자.

n-1번째 행에서 (n, k)로 올 수 있는 좌표는 (n-1, k-1)와 (n-1, k)이다.

dp[n][k]는 최댓값을 저장해야하기 때문에 dp[n-1][k-1]와 dp[n-1][k] 중 더 큰 값을 선택하고 (n, k) 좌표에 저장된 수를 더해주면 된다.

결국 점화식은

dp[n][k] = max(dp[n-1][k-1], dp[n-1][k]) + num[n][k]

가 된다.

이제 코딩하자.

어.. 근데.. n이 0부터 시작하게 되면 n-1가 음수가 안되도록 따로 처리해주어야 한다.. k-1도 마찬가지.

귀찮다. 삼각형을 다시 한번 바꿔보자

0
0   7
0   3   8
0   8   1   0
0   2   7   4   4
0   4   5   2   6   5

이제 (0, 0)이 아니라 (1, 1)부터 시작하자.

이렇게 해도 문제가 없을까 ? 없다.

최댓값을 찾는 문제이기 때문에 가장 앞에 있는 0이 선택 될 일은 없다.

진짜 코딩하자.

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

int dp[502][502];
int num[502][502];

int main() {
	ios::ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);

	int n;
	cin >> n;
	for (int i = 1; i <= n; ++i) for (int j = 1; j <= i; ++j) {
		cin >> num[i][j];
	}

	for (int i = 1; i <= n; ++i) for (int j = 1; j <= i; ++j) {
		dp[i][j] = max(dp[i - 1][j - 1], dp[i - 1][j]) + num[i][j];
	}
	
	// 최댓값을 찾자.
	int ans = 0;
	for (int i = 1; i <= n; ++i) ans = max(ans, dp[n][i]);
	
	cout << ans;

	return 0;
}

위에 코드를 보면 음.. num이 필요없어 보인다. 살짝 최적화를 해보자.

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

int dp[502][502];

int main() {
	ios::ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);

	int n;
	cin >> n;
	for (int i = 1; i <= n; ++i) for (int j = 1; j <= i; ++j) {
		cin >> dp[i][j];
	}

	for (int i = 1; i <= n; ++i) for (int j = 1; j <= i; ++j) {
		dp[i][j] += max(dp[i - 1][j - 1], dp[i - 1][j]);
	}
	
	int ans = 0;
	for (int i = 1; i <= n; ++i) ans = max(ans, dp[n][i]);
	
	cout << ans;

	return 0;
}

세우자. 점화식.

비용의 최솟값을 구하는게 목적이다.

확실하게 할 것이 하나있다.

우리는 1~n번째 집들이 각각 어떤 색으로 칠해지는지 궁금하지 않다.

얼마의 비용이 필요한지 궁금하다.

그러므로, 이 문제에선 우리는 세 개의 DP 배열이 필요하다.

빨간색을 선택했을 때 총 비용의 최솟값, 초록색을 선택했을 때 총 비용의 최솟값, 파란색을 선택했을 때 총 비용의 최솟값을 저장할 배열이다.

자세하게 설명하면, dp[n][빨간색]의 값은 n번째 집을 빨간색으로 칠했을 때 총 비용의 최솟값이라고 하자.

그렇다면, n번째 집을 빨간색으로 칠할 때 총 비용의 최솟값은 n번째 집을 빨간색으로 칠하는 비용 + (n-1번째 집이 초록색일 때 총 비용의 최솟값)과 (n-1번째 집이 파란색일 때 총 비용의 최솟값) 중 작은 값이라고 봐도 될까 ? 

식으로 표현하게 되면, 

dp[n][빨간색] = min(dp[n-1][초록색], dp[n-1][파란색]) + cost[n][빨간색]

이라고 해도 될까 ?

된다.

우리는 n번 집을 빨간색으로 칠할 때, 1 ~ n-2번이 어떤 색으로 칠해져 있는지 궁금하지 않다.

그저 n-1번째 집이 초록색 또는 파란색일 때 드는 전체 비용의 최솟값만 알면 n번 집을 빨간색으로 칠할 때 총 비용의 최솟값을 알 수 있다.

결국 점화식을

dp[n][빨간색] = min(dp[n-1][초록색], dp[n-1][파란색]) + cost[n][빨간색]

dp[n][초록색] = min(dp[n-1][빨간색], dp[n-1][파란색]) + cost[n][초록색]

dp[n][파란색] = min(dp[n-1][빨간색], dp[n-1][초록색]) + cost[n][파란색]

으로 정리할 수 있다.

자, 밑의 예제를 통해 세 개의 DP배열을 어떻게 사용하는지 알아보자.

각각의 집을 색칠할 때마다 드는 비용이 위와 같다고 하자.

1번 집은 첫번째 집이기 때문에 어떤 색으로 칠하든 그 값이 곧 총 비용의 최솟값이 된다. DP의 첫번째 행을 업데이트 하자.

2번 집을 빨간색으로 칠하려고 한다. 규칙에 의해 1번 집은 초록색 or 파란색이 되어야 한다.

때문에 dp[2][R]은 dp[1][G]과 dp[1][B] 중 더 작은 값 + 2번 집을 빨간색으로 칠하는 비용이다.

마찬가지로 2번 집을 초록색인 경우(dp[2][G])는 dp[1][R]과 dp[1][B] 중 더 작은 값 + 2번 집을 초록색을 칠하는 비용이다.

2번 행을 채우자.

3번 집을 칠해보자.

우리는 2번 집을 초록색으로 칠했을 때 총 비용의 최솟값(dp[2][G])과 파란색으로 칠했을 때 총 비용의 최솟값(dp[2][B])을 알고 있다.

따라서 3번 집을 빨간색으로 칠할 때 총 비용의 최솟값은 dp[2][G]와 dp[2][B] 중 더 작은 값 + 3번 집을 빨간색으로 칠하는 비용이다.

같은 매커니즘으로 초록색과 파란색의 경우도 구하자.

결국 1, 2, 3번 집을 칠하는데 드는 총 비용의 최솟값은 96, 172, 185 중 가장 작은 값인 96이 된다.

이해가 안될 수도 있다. 나도 그랬다.

dp[n][R]의 의미를 n번째 집을 빨간색으로 칠할 때 전체 비용의 최솟값이라고 설정했을 때,

dp[n-1][R], dp[n-1][G], dp[n-1][B]의 의미를 생각하고 이것들을 이용하여 dp[n][R]을 만드는 연습을 해보자.

이 문제는 n-1번째만 보면 되지만, n-2번째나 n-3번째를 봐야하는 경우도 있으니.. 점화식 만드는 연습을 하자.

이해됐으면 코딩하자.

#include <bits/stdc++.h>

using namespace std;

// 0 : R, 1 : G, 2 : B
int cost[1001][3];
int dp[1001][3];

int main() {
	ios::ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);

	int n;
	cin >> n;

	for (int i = 1; i <= n; i++) cin >> cost[i][0] >> cost[i][1] >> cost[i][2];

	for (int i = 1; i <= n; i++) {
		dp[i][0] = min(dp[i - 1][1], dp[i - 1][2]) + cost[i][0];
		dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]) + cost[i][1];
		dp[i][2] = min(dp[i - 1][0], dp[i - 1][1]) + cost[i][2];
	}

	cout << min({ dp[n][0],dp[n][1],dp[n][2] });

	return 0;
}

아무 생각 없이 int형 배열로 통과하긴 했는데.. 만약 틀렸을 때는 long long 타입으로 바꿔야하는지부터 의심해보자.

대놓고 점화식 세우라고 힌트 준 DP문제이다.

한 삼각형의 변이 어떤 규칙에 의해 정해지는지 확인해보자.

1, 1, 1, 2, 2, 3, 4, 5, 6, 7, 9

이 문제를 해결할 때, 난 6번째 삼각형부터 확실한 규칙이 보였다.

6번째부터 파란색 삼각형의 한 변의 길이는 두 개의 흰색 삼각형 변의 길이의 합이고, 흰색 삼각형의 한변의 길이는 두 개의 파란색 변의 길이의 합인 것을 봤다.

다시 눈을 크게 뜨고 보자.

삼각형의 변의 길이를 결정하는 두 개의 삼각형 중 하나는 무조건 바로 전에 만들어진 삼각형이고, 다른 하나는 5번째 전에 만들어진 삼각형이다.

결국 점화식은 \(a_n = a_{n-1} + a_{n-5}\) 이 된다. 

코딩 하자 !

아 참.. 이 문제는 n이 100까지라 int형 범위를 초과할 수 있다.

사실 나도 배열을 int형으로 선언하고 틀렸습니다를 받은 다음에 범위를 초과할 수 있다는 것을 캐치했다.

그러니.. 배열을 long long 타입으로 선언하자.

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

long long dp[101];

int main() {
	ios::ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	
	dp[1] = 1;
	dp[2] = 1;
	dp[3] = 1;
	dp[4] = 2;
	dp[5] = 2;

	for (int i = 6; i < 101; i++) dp[i] = (dp[i - 1] + dp[i - 5]);

	int T, n;
	cin >> T;
	while (T--) {
		cin >> n;
		cout << dp[n] << '\n';
	}


	return 0;
}

자.. 나왔다. 큰 수로 나눈 나머지를 출력하라는 문제.

지금이야 DP문제인 것을 알고 풀지만, 이 문제처럼 어떤 수로 나눈 나머지를 출력하는 문제는 DP로 풀릴 확률이 매우 높다.

1과 00을 갖고 N자리의 이진 수열의 개수를 구하는 것이 목표이다.

잘 모르겠으면 일단 적어보자. 어떤 "규칙"을 발견할 지도 모르니...

1자리 : 1 - 1개

2자리 : 00, 11 - 2개

3자리 : 001, 100, 111- 3개

4자리 : 0000, 0011, 1001,  1100, 1111- 5개

5자리 : 00001, 00100, 00111, 10000, 10011, 11001, 11100, 11111 - 8개

6자리 : 000000, 000011, 001001, 001100, 001111, 100001, 100100, 100111, 110000, 110011, 111001, 111100, 111111 - 13개

1, 2, 3, 5, 8, 13 ... ? 익숙하다. 앞에 1이 빠진 피보나치 수열이다.

피보나치인 거 발견했으니까 점화식을 갖고 코딩하면 끝이긴 하지만.. 뒤가 좀 구리다.

정말 정말 정말 우연히 6자리까지 피보나치 수열을 만족하고 7자리부터 다른 수가 나올 수도 있지 않나 ?

당신의 생각이 맞다. 그래서 "왜" 피보나치인지 알아보자.

N자리의 모든 이진 수열은 1 또는 00으로 시작한다.

다시 말하면, 1 또는 00 뒤에 1 또는 00을 붙여 N자리의 이진수를 만드는 것이다.

또 다시 말하면, N자리의 이진수를 만들기 위해서 N-1자리 이진수 뒤에 1을 붙이거나 N-2자리 이진수 뒤에 00을 붙이면 된다.

그렇기 때문에 \(a_n\)을 n자리의 이진수라고 하면, \(a_n = a_{n-1} + a_{n-2}\) 이라는 점화식을 만들 수 있다.

어 근데 N-1자리 이진수 뒤에 1을 붙인 수와 N-2자리 이진수 뒤에 00을 붙인 수가 같은 경우는 생각 안하나요 ?

네. 그런 경우는 나올 수 없습니다.

이유를 수학적으로 풀어보자.

이진수 뒤에 1을 붙이는 행위 = 십진수 x 2 + 1

이진수 뒤에 00을 붙이는 행위 = 십진수 x 4

위에 두 식이 이해가 안된다면 직접 한번 이진수 100에 1이나 00을 붙이고 십진수로 표현해보면 된다.

깨알 상식으로 이진수를 왼쪽으로 한번 Shift하는 것은 곱하기 2를 해주는 것과 같은 효과임을 생각해주면 된다.

(그래서 고인물들이 가끔 더 빠른 연산을 위해 x * 2 보다 x << 1을 선호하는 경우도 있다.)

자 그럼 여기 어떤 정수 \(x, y\)가 있다.

\(x\)에는 1을 붙이고 \(y\)에는 00을 붙이면, 각각 \(2x + 1, 4y\)가 된다.

이제 우리는 \(2x + 1 = 4y\)를 만족시키는 정수 \(x, y\)를 찾아야 한다. 그래야 같은 수가 나올 수 있다는 것이 증명된다.

식을 \(x\)에 대해 살짝 정리하자.

\(x = 2y - \frac{1}{2}\)

음... \(y\)에 어떤 정수를 넣든 \(-\frac{1}{2}\)에 의해 \(x\)는 정수가 나올 수 없음을 알아버렸다.

결국, 우리는 사전에 생각해놨던 피보나치 수열로 이 문제를 해결하면 된다 !

단, 15746으로 나눈 나머지를 출력해야한다는 것을 유의하면서.

여기서 15746으로 나눈 나머지는 또 어떻게 처리하지?라고 생각할 수도 있는데, 정수론에 의해 그냥 모든 결과를 15746으로 나눈 나머지로 저장해주면 된다 ㅎㅎ

코드로 한번 보자.

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

int fibo[1000001];

int main() {
	ios::ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	
	int n;
	cin >> n;

	fibo[1] = 1;
	fibo[2] = 2;
	// 매번 15746으로 나눈 나머지를 저장
	for (int i = 3; i <= n; i++) fibo[i] = (fibo[i - 1] + fibo[i - 2]) % 15746;

	cout << fibo[n];

	return 0;
}

문제에서 대놓고 점화식을 줬다. 천사같은 문제라고 볼 수 있다.

고민해야될 것은 Top-Down으로 할 지, Bottom-Up으로 할 지이다.

그냥 둘 다 해보자.

1. Top-Down문제에서 대놓고 그대로 구현하면 값을 구하는데 오래 걸린다고 한다.DP 1번 문제였던 피보나치와 마찬가지로 너무 많은 재귀함수가 호출되기 때문이다.그러면.. 해결방법은 재귀함수 호출을 줄이면 된다. 뭘 이용해서 ? Memorization !

이 문제에선 배열에 저장된 값이 0이 될 수 있기 때문에, 처음에 배열에 모든 값을 -1로 초기화해주자.

왜 ?

예를 들어, w[20][20][20]을 구하기 위해서 w[20][20][19]에 접근했더니 w[20][20][19]에 저장된 값이 0이라고 가정해보자.

재귀함수를 통해 이미 계산된 값이라면 더 돌아볼 것도 없이 0을 리턴해주면 되지만, 초기화된 값이었다면 w[20][20][19] 값을 구하기 위해 또 다른 재귀함수가 실행될 것이다.

자... 이 저장된 0은 재귀함수를 통해 이미 계산된 값인지 프로그램 실행 때 초기화된 값인지.. 어떻게 알 것인가 ? 모른다;; 그렇기 때문에, 아직 계산되지 않은 원소라는 의미에서 배열 안에 모든 원소를 -1로 초기화시켜주자.

이제 재귀함수만 작성하면 끝난다.재귀함수 내에서 w[a][b][c]에 저장된 값이 -1인지 체크해보자. -1이라면 문제에서 준 점화식을 통해 값을 계산하면 될 것이고, -1 아니라면 이미 계산된 값이기 때문에 그 값을 바로 리턴하자.

그럼 끝! 이 아니다. a, b, c 중 하나라도 0보다 작거나 같은 경우와 20보다 큰 경우는 따로 처리해주어야하기 때문에, w[a][b][c]에 먼저 접근하지 말고 a, b, c의 값을 먼저 체크 해주어야 한다. 

무슨 소리인지 모르겠다면 코드로 한번 보자.

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

int w[21][21][21];

int getW(int a, int b, int c) {
	// a, b, c 범위 체크
	if (a <= 0 || b <= 0 || c <= 0) return 1;
	if (a > 20 || b > 20 || c > 20) return getW(20, 20, 20);
	
	// 이미 계산된 a b c인지 확인
	// 계산된 게 맞다면 바로 저장된 값 리턴
	if (w[a][b][c] != -1) return w[a][b][c];
    
	// 아니라면 점화식 수행
	if (a < b && b < c) return w[a][b][c] = getW(a, b, c - 1) + getW(a, b - 1, c - 1) - getW(a, b - 1, c);
	else return w[a][b][c] = getW(a - 1, b, c) + getW(a - 1, b - 1, c) + getW(a - 1, b, c - 1) - getW(a - 1, b - 1, c - 1);

	return -1;
}

int main() {
	ios::ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	// 배열 안에 모든 값 -1로 초기화, for문을 사용하는 것보다 빠름
	memset(w, -1, sizeof(w));

	int a, b, c;
	while (true) {
		cin >> a >> b >> c;

		if (a == -1 && b == -1 && c == -1) break;

		cout << "w(" << a << ", " << b << ", " << c << ") = " << getW(a, b, c) << '\n';
	}

	return 0;
}

2. Bottom-Up

점화식이 있을 때 Bottom-Up방식 구현은 너무나도 쉽다.그냥 for문을 통해 구현해서 배열w를 채우자 !

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

int w[21][21][21];

int main() {
	ios::ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
    
	for (int a = 0; a < 21; a++)
		for (int b = 0; b < 21; b++)
			for (int c = 0; c < 21; c++) {
				// a, b, c가 20을 넘는 경우는 없기 때문에, 0보다 작거나 같은 경우만 신경쓰자.
				if (a <= 0 || b <= 0 || c <= 0){
					w[a][b][c] = 1;
				}
				else if (a < b && b < c){
					w[a][b][c] = w[a][b][c - 1] + w[a][b - 1][c - 1] - w[a][b - 1][c];
				}
				else {
					w[a][b][c] = w[a - 1][b][c] + w[a - 1][b - 1][c] + w[a - 1][b][c - 1] - w[a - 1][b - 1][c - 1];
				}
			}
				

	int a, b, c, result;
	while (true) {
		cin >> a >> b >> c;

		if (a == -1 && b == -1 && c == -1) break;

		if (a <= 0 || b <= 0 || c <= 0) result = 1;
		else if (a > 20 || b > 20 || c > 20) result = w[20][20][20];
		else result = w[a][b][c];

		cout << "w(" << a << ", " << b << ", " << c << ") = " << result << '\n';
	}

	return 0;
}

[문제 유형]

총 6문제가 출제되었고, 실버~골드정도 되는 문제들이 출제되었다.

구현 문제 위주였고, 나는 구간합을 사용해서 사용해서 푼 문제도 있었다 (맞는 풀이인지는 모르겠다).

밑에서 설명하겠지만.. 라인은 빨리 많이 푸는 것보단 정확하게 푸는 것을 추천한다 !

[후기]

사실, 작년 하반기에 지원했었는데.. 처음으로 코테에서 탈락이라는 쓴 맛을 맛보았다. ㅋㅋㅋㅋ

라인 코테는 바로 정답 코드인지 알려주는 게 아니라 코드를 가져가서 테케를 돌려보기 때문에, 엣지 케이스와 히든 케이스를 생각하며 코드를 작성하는 것이 매우매우매우 중요하다. 

이걸 강조하는 이유는 작년 하반기 코테에서는.. 문제에서 제공하는 테스트 케이스에서 돌아가면 오 좋아! 하면서 넘어갔고, 탈락했다. (6제출 탈락)

하지만 이번 코테에선 엣지 케이스와 히든 케이스에 대해 끊임없이 생각하며 코드를 작성했고, 합격했다. (5제출 합격)

코테에 참여해서 문제를 읽으면 내가 왜 이런 말을 했는지 알 수 있을 것이다 ㅎㅎ.. 맞으면서 배우시길 !

또 다른 팁으로 두번 코테를 본 입장에서 .. 음 파이썬이 유리한 느낌이다.

내가 왜 파이썬이 유리하다고 말했는지는, 어떤 문제 유형에서 C++보다 파이썬이 편한지 생각해보시면 될 것 같다.

필기 테스트 후기는 결과가 나오면 올려보겠다. (쉽진 않더라.. ㅋㅋ)

1차는 4제출, 2차는 2솔로 합격했다.

1차, 2차 모두 거의 구현에 가까운 문제들이었다.

물론, 2차는 1차에 비해 적절한 자료구조의 사용이 요구되었다.

굳이 따지자면 1차는 백준 사이트 기준 실버, 2차는 골드 수준이었던 것 같다. (그래서 더 아쉬웠던 2차였다)

매우매우 아쉬운 점은 2차에서 1번 문제를 해결할 때 시간복잡도가 살짝 애매한 것 같아서 후순위로 미루고 풀었는데.. 이게 알고 보니까 카카오 1차 코딩테스트처럼 정답을 바로 알려준다. 

이럴 줄 알았으면 일단 구현해서 제출했지 ㅠㅠㅋㅋㅋ

어떤 기준으로 합격컷이 난 건진 모르겠지만.. 일단 4지망에 합격했다.

(1차 + 2차) 결과로 줄을 세웠다는 의견도 있고, 2차에서 많이 푼 사람 - 동점자들 중 먼저 해결한 사람을 기준으로 줄을 세웠다는 의견도 있다.

1차에서 시간이 남아 나름 엣지 케이스도 찾아보면서 코드를 작성했기 때문에, 전자였다면 1지망에 합격하지 않았을까싶다. 그래서 후자가 킹능성 있지 않나.. 라는 의미없는 의견을 내본다.