• 문제

• 풀이

#include <iostream>

using namespace std;

int main()
{
	int y[3] = { 0 };
	int x[3] = { 0 };

	int resultX = 0, resultY = 0;

	for (int i = 0; i < 3; i++)
	{
		cin >> x[i] >> y[i];
	}

	if (x[0] == x[1])
	{
		resultX = x[2];
	}
	else if (x[0] == x[2])
	{
		resultX = x[1];
	}
	else
	{
		resultX = x[0];
	}

	if (y[0] == y[1])
	{
		resultY = y[2];
	}
	else if (y[0] == y[2])
	{
		resultY = y[1];
	}
	else
	{
		resultY = y[0];
	}

	cout << resultX << " " << resultY;

	return 0;
}

• 메모
  결과값의 패턴을 확인해보면 x, y가 각각 중복되지 않은 값이 결과값으로 나오는 것을 확인할 수 있다.
  따라서 if문을 이용해 입력받은 값의 중복 여부를 체크하고 남은 값을 출력해주면 된다.

• 문제

• 풀이

#include <iostream>

using namespace std;

int main()
{
	int x = 0, y = 0, w = 0, h = 0;
	int min = 1001;

	cin >> x >> y >> w >> h;

	if (x < min)
	{
		min = x;
	}
	if (y < min)
	{
		min = y;
	}
	if (w - x < min)
	{
		min = w - x;
	}
	if (h - y < min)
	{
		min = h - y;
	}
	
	cout << min;

	return 0;
}

• 메모
  직사각형의 가장자리에 도달할 수 있는 최단 거리를 구하는 것이기 때문에 입력받은 값 x, y, 그리고 w - x, h -y 값 중에서 가장 작은 값을 구하면 되는 문제다. 최솟값이 여러 조건에 따라 결정되고 각 조건 별로 값이 계속 갱신될 수 있기 때문에 if else문 대신 if문을 사용했다.

• 문제

• 풀이

#include <iostream>
#include <queue>

using namespace std;

int FindPrime(int input)
{
	// 음수, 1은 소수가 아니므로 제외한다.
	if (input < 2)
	{
		return 0;
	}

	for (int i = 2; i < input; i++)
	{
		// 나머지가 없다면 소수가 아니므로 제외한다.
		if (input % i == 0)
		{
			return 0;
		}
	}

	return 1;
}

int main()
{
	int m = 0, n = 0, min = 0;
	queue<int> q;

	cin >> m >> n;

	for (int i = m; i <= n; i++)
	{
		int result = FindPrime(i);

		if (result == 1)
		{
			q.push(i);
		}
	}

	int size = q.size();

	if (size == 0)
	{
		cout << -1;
	}
	else
	{
		min = q.front();

		int sum = 0;

		for (int i = 0; i < size; i++)
		{
			sum += q.front();
			q.pop();
		}

		cout << sum << '\n' << min;
	}

	return 0;
}

• 문제

• 풀이

#include <iostream>
using namespace std;

int main()
{
	int n = 0;

	cin >> n;

	while (true)
	{
		if (n == 1)
		{
			break;
		}

		for (int i = 2; i <= n; i++)
		{
			// 그냥 if문으로 체크하면 한번 체크된 값 이후로 더 큰 값들을 계속 체크하므로
			// 중복한 i 값 ex. 2 -> 2가 나올 수 없는 경우가 생김
			// 따라서 소인수에 해당하는 값이 나오면 break를 해서
			// 다음 체크로 넘어가거나 if 대신 while(n % i == 0)을 사용해야 한다.
			if (n % i == 0)
			{
				cout << i << endl;
				n /= i;
				break;
			}
		}
	}

	return 0;
}

• 메모

소인수분해가 되려면 해당 값으로 N을 나머지 연산했을 때 값이 0이 되면서 가장 작은 값이여야 한다.
이때 1은 소수가 아니기 때문에 2부터 N까지의 수를 나눠준다.

만약 if문을 사용하는 경우 목표 숫자를 찾았을 때 연산을 중간에 멈춰주지 않으면

가장 작은값에 해당하는 소수가 중복되서 나올 수 없는 경우가 생기기 때문에 반드시 break문을 사용한다.

또는 while문을 사용해 나머지 연산 결과가 0인 경우를 조건으로 넣어주는 방법도 있다.

• 문제

• 풀이

#include<iostream>
#include <queue>

using namespace std;

int main()
{
	int n = 0;

	while (true)
	{
		cin >> n;

		if (n == -1)
		{
			break;
		}

		queue<int> s;
		int sum = 0;

		for (int i = 1; i < n; i++)
		{
			if (n % i == 0)
			{
				s.push(i);
				sum += i;
			}
		}

		if (sum != n)
		{
			cout << n << " is NOT perfect." << '\n';
		}
		else
		{
			cout << n << " = ";

			int size = s.size();
			for (int i = 0; i < size; i++)
			{
				cout << s.front();
				s.pop();

				if (false == s.empty())
				{
					cout << " + ";
				}
			}
			cout << '\n';
		}

	}

	return 0;
}

• 메모
  약수의 개수가 얼마나 될지 알 수 없기 때문에 배열을 사용하지 않았다.
  마지막에 저장된 값을 빼낼 때 가장 먼저 저장된 값부터 차례대로 출력해야 하기 때문에 스택 대신 큐를 사용했다.

• 문제

• 풀이

#include<iostream>

using namespace std;

int main()
{
	int n = 0, k = 0;
	int temp = 0, result = 0, count = 0;

	cin >> n >> k;

	for (int i = 1; i <= n; i++)
	{
		if (count == k)
		{
			break;
		}

		temp = n % i;

		if (temp == 0)
		{
			count++;
			result = i;
		}
	}

	// n의 약수 개수인 count가 k보다 작은 경우가 있을 수 있다.
	// 이 경우에는 k번째 약수가 존재하지 않기 때문에 따로 0을 출력한다.
	if (count < k)
	{
		cout << 0;
	}
	// count가 k보다 큰 경우 해당하는 k번째 약수를 출력해준다.
	else
	{
		cout << result;
	}

	return 0;
}

• 메모
  나머지 연산 결과가 0인 경우만 카운팅 하면 되는 간단한 문제다.
  이때 주의할 점은 k가 실제 약수의 갯수보다 많게 입력되는 경우 0으로 출력해야 한다.
  실제로 25, 4를 입력하는 경우 25의 약수는 3개밖에 존재하지 않기 때문에 4번째 약수가 존재하지 않는다.
  따라서 마지막 출력 부분에서 이 부분을 체크하고 각각 출력 조건을 설정해 준다.

• 문제

• 풀이

#include<iostream>

using namespace std;

void run(int x, int y)
{
	// 1. x가 y의 약수이다.
	if (y % x == 0)
	{
		cout << "factor" << '\n';
	}
	// 2. x가 y의 배수이다.
	else if (x % y == 0)
	{
		cout << "multiple" << '\n';
	}
	// 3. 앞의 두 경우에 전부 해당하지 않는 경우
	else
	{
		cout << "neither" << '\n';
	}
}

int main()
{
	int x = 0, y = 0;

	while (true)
	{
		cin >> x >> y;

		if ((x == 0) && (y == 0))
		{
			break;
		}

		run(x, y);
	}

	return 0;
}

• 메모
  나머지 연산을 사용해서 입력받은 값이 첫 번째 값과 두 번째 값의 약수 혹은 배수 관계에 있는지 판별한다.
  서로 약수 관계인 경우 두 번째 값에 첫 번째 값을 나머지 연산한 결과가 남지 않고 딱 맞아떨어져야 한다.
  서로 배수 관계인 경우에도 첫 번째 값에 두 번째 값을 나머지 연산한 결과가 남지 않아야 한다.

• 문제

• 풀이

#include<iostream>

using namespace std;
int main()
{
	int n = 0, result = 0;
	int count = 2;

	cin >> n;

	for (int i = 0; i < n; i++)
	{
		count += count - 1;
	}

	result = count * count;

	cout << result;

	return 0;
}

• 메모
  초기 상태 (1)에서 점은 4개이고 그 다음엔 (2) 9개, (3) 25개.... (4) 1089개가 된다.
  여기서 규칙을 하나 찾을 수 있는데, 가로 점의 갯수만 따졌을 때
  
  가로가 2개면 점 4개
  가로가 3개면 점 9개
  
  여기까지 보면 점의 갯수는 가로의 점 갯수를 같은 값으로 제곱한 것과 같게 된다.
  
  그런데 이어지는 (3)의 경우 가로 점이 5개일 때 총점의 수는 25개가 되는데, 이는 점과 점 사이에 새로운 점(검정)이 한개씩 추가 되는 패턴이 있기 때문이다.
  
  즉, 최종적으로 가로의 점은 현재 점에서 하나를 뺀 값만큼 증가하게 된다는 걸 알 수 있다.
  
  이를 일반화된 식으로 나타내면
  
  현재 점 개수에서 다음 점이 추가된 값 = 2 * 점의 개수 - 1
  
  이 된다.
  
  초기 상태 (1)에서 최초의 점이 4개이므로, 가로 개수만 따지면 2개로 시작하기 때문에 count 값을 2로 초기화한 뒤
  n번만큼 반복하며 count += count-1을 해준 다음, 마지막으로 도출된 값을 동일 값으로 제곱해주면 최종 답을 얻을 수 있다.