파트라슈의 코딩

#include <iostream>
using namespace std;
int Answer;

int main(int argc, char** argv)
{
	int T, test_case, N;

	cin >> T;
	for(test_case = 0; test_case  < T; test_case++)
	{
		Answer = 0;
		cin >> N;
		for(int i=2; i<N; i++) {
			if(N / i == N % i) {
				Answer = i;
				break;
			}
		}
				
		cout << "Case #" << test_case+1 << endl;
		cout << Answer << endl;
	}

	return 0;
}

문제

자연수를 표시하기 위한 표기법으로는 10을 기저로 하는 10진법을 가장 많이 사용한다.
하지만, 그 이외에도 어떤 자연수이든지 기저로 하여 표현하는 것이 가능하다.
예를 들어 10을 기저로 하는 10진법에서 238로 표현되는 수가, 2를 기저로 하는 2진법에서는 11101110으로 표현된다.
그리고, 같은 수를 23진법으로 표현하면 10, 8로 표현될 것이다.
(23진법에서는 각 자리수는 10진수로 표현하고 자리수 사이를 콤마로 구분하였다.
 기저가 10 이상인 경우에만 이렇게 콤마로 구분하는 방법을 쓴다.) 

자연수 NN 이 기저 bb 에 대한 bb 진법으로 표현했을 때 모든 자리수의 값이 같게 되는 경우 NN 을 bb 에 대해서 “균일수”라고 부른다.
예를 들어, 10진수 36은 기저 17에 대해서 2,2로 표현되므로, 10진수 36은 17에 대해서 균일수가 되고,
10진수 36은 또한 기저 8에 대해서도 균일수가 된다. 그 이유는 10진수 36의 8진수 표현이 44이기 때문이다.
자연수 NN 이 하나 이상의 기저에 대해 균일수가 된다면, 그 기저들 중 가장 작은 값을 구하려고 한다.
극단적인 경우, 만약 b>Nb>N 이라면 NN 은 bb 진법으로 한자리 수가 되는데, 이 때도 균일수가 되는 것으로 간주한다.
자연수  NN 이 주어졌을 때, NN 이 bb 에 대해서 균일수가 되는 최소의 양의 정수 bb 를 구하는 프로그램을 작성하시오.
단, b 는 2 이상이어야 한다.


- 제한시간: 전체 테스트 케이스는 100개 이하이며, 전체 수행 시간은 1초 이내 (Java 2초 이내) 
    제한 시간을 초과하면 제출한 소스코드의 프로그램이 즉시 종료되며,
    그때까지 수행한 결과에서 테스트 케이스를 1개 그룹 이상 통과하였더라도 점수는 0점이 됩니다.
    그러나, 제한 시간을 초과하더라도 테스트 케이스를 1개 그룹 이상 통과하였다면 '부분 점수(0< 점수< 만점)'를 받을 수 있으며,
    이를 위해서는, C / C++ 에서 "printf 함수" 사용할 경우, 프로그램 시작부분에서 "setbuf(stdout, NULL);"를 한번만 사용하십시오.
    C++에서는 "setbuf(stdout, NULL);"와 "printf 함수" 대신 "cout"를 사용하고, Java에서는 "System.out.printIn"을 사용하시면,
    제한 시간을 초과하더라도 '부분 점수'를 받을 수 있습니다.                                     ※ 언어별 기본 제공 소스코드 내용 참고
    만약, 제한 시간을 초과하지 않았는데도 '부분 점수'를 받았다면, 일부 테스트 케이스를 통과하지 못한 경우 입니다.

- 메모리 사용 제한 : heap, global, static 총계 256MB, stack 1MB
- 제출 제한 : 최대 10회 (제출 횟수를 반영하여 순위 결정 → 동점자의 경우 제출 횟수가 적은 사람에게 높은 순위 부여)
- 점수 : 최대 10회 제출하여 취득한 각각의 점수 중에서 최대 점수

메모리 사용 제한

heap, global, static (총계) : 256MB
stack : 1MB

입력

입력 파일에는 여러 테스트 케이스가 포함될 수 있다.
파일의 첫 번째 줄에 테스트 케이스 개수를 나타내는 자연수 TT 가 주어지고,
이후 차례로 TT개의 테스트 케이스가 주어진다. ( 1≤T≤1001≤T≤100 )
두 번째 줄부터 주어지는 각각의 테스트 케이스는 자연수 NN 으로 주어진다. ( 1≤N≤1091≤N≤109 )

출력

각 테스트 케이스의 답을 순서대로 표준출력으로 출력하여야 하며, 각 테스트 케이스마다 첫 줄에 “Case #T”를 출력하여야 한다.
이때 TT는 테스트 케이스의 번호이다.
그 다음 줄에는 NN 이 bb 에 대해서 균일수가 되는 최소 양수 bb 를 출력한다. 단, bb 는 2이상이다.

느낀 점

i를 계속 증가시키면서 해당수가 균일수에 해당되는지 확인하면 되는 문제라 쉬운편에 속했다.

출처

[SCPC 예선]

문제

N 행 N 열로 이루어진 정사각형 격자구조 내에 방들 중에서
몇 개의 방에는 ╱ 또는 ╲ 형태의 대각선으로 45도 기울어진 양면거울이 들어 있다.
거울은 상하좌우에서 오는 빛을 다시 상하좌우 방향의 방으로 직각 반사시킨다.
본 문제에서는 '가장 윗줄에서 가장 왼쪽 방'의 왼쪽에서 레이저 포인터로 빛을 수평(0도)으로 비추었을 때
빛이 거치는 서로 다른 거울 개수를 계산하려고 한다.
 

예를 들어, 위 그림을 보자.
그림에서는 "①" 방으로 들어온 빛이 6번의 반사를 거친 후 3 ⅹ 3 크기의 격자구조 밖으로 빠져나간다.
그 중 "②" 방에 있는 거울의 경우, 한 거울의 양쪽 면에서 두 번의 반사가 일어난 것이다.
따라서 위의 예에서 빛을 반사한 거울은 5개이다. 이 문제를 해결하는 프로그램을 작성하시오.


- 제한 시간 : 전체 테스트 케이스는 20개 이하이며, 전체 수행 시간은 1초 이내 (Java 2초 이내) 
    제한 시간을 초과하면 제출한 소스코드의 프로그램이 즉시 종료되며,
    그때까지 수행한 결과에서 테스트 케이스를 1개 그룹 이상 통과하였더라도 점수는 0점이 됩니다.
    그러나, 제한 시간을 초과하더라도 테스트 케이스를 1개 그룹 이상 통과하였다면 '부분 점수(0< 점수< 만점)'를 받을 수 있으며,
    이를 위해서는, C / C++ 에서 "printf 함수" 사용할 경우, 프로그램 시작부분에서 "setbuf(stdout, NULL);"를 한번만 사용하십시오.
    C++에서는 "setbuf(stdout, NULL);"와 "printf 함수" 대신 "cout"를 사용하고, Java에서는 "System.out.printIn"을 사용하시면,
    제한 시간을 초과하더라도 '부분 점수'를 받을 수 있습니다.                                     ※ 언어별 기본 제공 소스코드 내용 참고
    만약, 제한 시간을 초과하지 않았는데도 '부분 점수'를 받았다면, 일부 테스트 케이스를 통과하지 못한 경우 입니다.

- 메모리 사용 제한 : heap, global, static 총계 256MB, stack 1MB
- 제출 제한 : 최대 10회 (제출 횟수를 반영하여 순위 결정 → 동점자의 경우 제출 횟수가 적은 사람에게 높은 순위 부여)
- 점수 : 최대 7회 제출하여 취득한 각각의 점수 중에서 최대 점수

메모리 사용 제한

heap, global, static (총계) : 256MB
stack : 1MB

입력

입력 파일에는 여러 개의 테스트 케이스가 포함되어 있다.
파일의 첫째 줄에는 테스트 케이스 개수를 나타내는 자연수 T 가 주어지고,
이후 차례로 TT 개의 테스트 케이스가 주어진다. ( 1≤T≤201≤T≤20) 
각각의 테스트 케이스 첫 번째 줄에는 정사각형 격자구조의 '한 변의 방 개수'를 나타내는 정수 N 이 주어진다. ( 1≤N≤1,0001≤N≤1,000 ) 
다음 줄부터는 NN 개의 줄이 주어지고, 각 줄마다 NN 개의 문자가 주어진다, 각 문자는 { ‘0’, ‘1’ , ‘2’ }에 속하는 문자 중 하나이다.
문자 ‘1’은 우측 상단에서 좌측 하단으로 45도 기울어진 양면거울이 그 방에 있다는 것을 나타내며,
문자 ‘2’는 좌측 상단에서 우측 하단으로 45도 기울어진 양면거울이 그 방에 있다는 것을 나타낸다.
그리고 문자 ‘0’은 거울이 없는 방임을 나타낸다. 각 줄에 들어 있는 문자들 사이에 빈칸(공백)은 없다.

출력

각 테스트 케이스의 답을 순서대로 표준출력으로 출력하여야 하며, 각 테스트 케이스마다 첫 줄에 “Case #T”를 출력하여야 한다.
이때 T는 테스트 케이스의 번호이다.
그 다음 줄에는 정사각형 격자구조 건물의 '맨 위 맨 왼쪽 방'의 왼쪽에서 수평(0도)으로 들어간 빛이
그 건물을 빠져나올 때까지 거치는 서로 다른 거울의 개수를 출력한다.

입출력예

푸는 TIP

구조체 room에 거울의 데이터를 저장하는 mirror, 이미 지나쳐 갔는지 확인하는 bool형 been 변수를 만들어 놓는다.

소스코드

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>
#pragma warning(disable : 4996) //비주얼스튜디오 scanf 오류 무시
int Answer;
typedef struct room {
	int mirror; //거울 데이터 저장
	bool been; //이미 갔는지 확인
}Room;
typedef struct location {
	int x;
	int y;
	char dir; //진행하려는 방향
	int count;
}Loc;
void myFlush(void) {
	while (getchar() != '\n')
		getchar();
}

Room** build_room(Room** room, int N) {
	int i = 0, j = 0, temp = 0;
	room = (Room**)malloc(sizeof(Room) * N);
	for (i = 0; i < N; i++) {
		room[i] = (Room*)malloc(sizeof(Room) * N);
	}
	for (i = 0; i < N; i++) {
		myFlush();
		for (j = 0; j < N; j++) {
			scanf("%c", &temp);
			room[j][i].mirror = temp-48; //%c로 받았으니 숫자가 아닌 문자로 인식되서 '0'을 받음으로 아스키 코드만큼 빼기
			if (temp == 0) {
				room[j][i].been = 0;
			}
			else {
				room[j][i].been = 1;
			}
		}
	}
	return room;
}
void loc_reset(Loc *loc) {
	loc->x = 0;
	loc->y = 0;
	loc->dir = 'R';
	loc->count = 0;
}
void make_dir_0(Loc * loc) {
	switch (loc->dir) {
	case 'L':
		loc->x--;
		break;
	case 'R':
		loc->x++;
		break;
	case 'U':
		loc->y--;
		break;
	case 'D':
		loc->y++;
		break;
	}
}
void make_dir_1(Loc * loc) {
	switch (loc->dir) {
	case 'L':
		loc->y++;
		loc->dir = 'D';
		break;
	case 'R':
		loc->y--;
		loc->dir = 'U';
		break;
	case 'U':
		loc->x++;
		loc->dir = 'R';
		break;
	case 'D':
		loc->x--;
		loc->dir = 'L';
		break;
	}
}
void make_dir_2(Loc * loc) {
	switch (loc->dir) {
	case 'L':
		loc->y--;
		loc->dir = 'U';
		break;
	case 'R':
		loc->y++;
		loc->dir = 'D';
		break;
	case 'U':
		loc->x--;
		loc->dir = 'L';
		break;
	case 'D':
		loc->x++;
		loc->dir = 'R';
		break;
	}
}
void endless_move(Room** room, Loc * loc, int N) {
	int check_mirror;
	while ((loc->x < N) && (loc->x >= 0) && (loc->y < N) && (loc->y >= 0)) {
		check_mirror = room[loc->x][loc->y].mirror;
		if (check_mirror == 0) {
			make_dir_0(loc);
		}
		else if (check_mirror == 1) {
			if (room[loc->x][loc->y].been == true) {
				room[loc->x][loc->y].been = false;
				loc->count++;
			}
			make_dir_1(loc);
		}
		else { //room[x][y]의 mirror 상태가 2인 경우
			if (room[loc->x][loc->y].been == true) {
				room[loc->x][loc->y].been = false;
				loc->count++;
			}
			make_dir_2(loc);
		}
	}
}
void set_free(Room*** room, int N) {
	for (int i = 0; i < N; i++) {
		free(room[i]);
	}
	free(room);
}

int main(void)
{
	int T, test_case;
	setbuf(stdout, NULL);
	Room** room = NULL;
	Loc loc;
	int N = 0;
	scanf("%d", &T);
	for (test_case = 0; test_case < T; test_case++)
	{
		loc_reset(&loc);
		scanf("%d", &N);
		room = build_room(room, N);
		endless_move(room, &loc, N);
		Answer = loc.count;
		printf("Case #%d\n", test_case + 1);
		printf("%d\n", Answer);
		set_free(&room, N);
	}
	return 0;
}

느낀 점

일단 메모리 오버플로우가 발생해서 실패상태이긴 하다.

모든 test case를 통과하긴 했지만 어느 부분이 메모리 초과를 발생하는지는 모르겠다. set_free함수로 malloc으로 메모리 설정해놓은거를 free 해줬지만, 

출처

[SCPC 2015 - 1차 예선]

문제

일직선 상에 돌들이 놓여있고, 개구리가 처음에는 '좌표 0'에 위치한 돌 위에 앉아 있다.
'좌표 0'에는 돌이 항상 놓여 있고, 모든 돌들은 정수 좌표에 놓여 있다. (그림 1)

 

[ 그림 1 ]

개구리는 점프를 통해서 돌들 사이를 이동해서 마지막 돌까지 이동해야 한다.
이 때, 개구리가 한번의 점프로 이동 가능한 최대 거리 KK 가 주어진다.
개구리는 한번의 점프로 자신이 앉아 있던 돌에서  KK 이하의 거리에 위치한 돌들 중 하나의 돌로 이동 할 수 있다. 
여기서 문제는, '좌표 0'에 위치한 개구리가 마지막 돌까지 이동할 수 있다면,
마지막 돌까지 이동하기 위한 최소 점프 횟수를 계산하는 것이다. 

예를 들어서, 위의 "그림1"의 예에서 보면, 한번의 점프로 이동 가능한 최대 거리가 K=4K=4 로 주어질 때,
아래 "그림2"에서와 같이 5회의 점프로 마지막 돌로 이동할 수 있고, 이것이 최소의 점프 횟수이다. 

 

[ 그림 2 ]

또한 위의 예에서, K=2K=2 로 주어진다면 개구리는 마지막 돌로 이동할 수가 없다.
왜냐하면, 개구리가 '좌표 2'의 돌로 이동한 후 '좌표 5'이상의 돌로는 이동할 수 없기 때문이다. 



- 제한시간 : 전체 테스트 케이스는 5개 이하이며, 전체 수행 시간은 1초 이내 (Java 2초 이내) 
    제한 시간을 초과하면 제출한 소스코드의 프로그램이 즉시 종료되며,
    그때까지 수행한 결과에서 테스트 케이스를 1개 그룹 이상 통과하였더라도 점수는 0점이 됩니다.
    그러나, 제한 시간을 초과하더라도 테스트 케이스를 1개 그룹 이상 통과하였다면 '부분 점수(0< 점수< 만점)'를 받을 수 있으며,
    이를 위해서는, C / C++ 에서 "printf 함수" 사용할 경우, 프로그램 시작부분에서 "setbuf(stdout, NULL);"를 한번만 사용하십시오.
    C++에서는 "setbuf(stdout, NULL);"와 "printf 함수" 대신 "cout"를 사용하고, Java에서는 "System.out.printIn"을 사용하시면,
    제한 시간을 초과하더라도 '부분 점수'를 받을 수 있습니다.                                     ※ 언어별 기본 제공 소스코드 내용 참고
    만약, 제한 시간을 초과하지 않았는데도 '부분 점수'를 받았다면, 일부 테스트 케이스를 통과하지 못한 경우 입니다.

- 메모리 사용 제한 : heap, global, static 총계 256MB, stack 1MB
- 제출 제한 : 최대 10회 (제출 횟수를 반영하여 순위 결정 → 동점자의 경우 제출 횟수가 적은 사람에게 높은 순위 부여)
- 제출 제한 : 최대 7회

메모리 사용 제한

heap, global, static (총계) : 256MB
stack : 1MB

입력

입력 파일에는 여러 개의 테스트 케이스가 포함될 수 있다.
파일의 첫째 줄에는 테스트 케이스 개수를 나타내는 자연수 TT가 주어지고,
이후 차례로 TT개의 테스트 케이스가 주어진다. ( 1≤T≤51≤T≤5 ) 
각각의 테스트 케이스 첫 번째 줄에는 '좌표 0'에 놓인 돌을 제외한 나머지 돌들의 개수 NN 이 주어진다. ( 1≤N≤1,000,0001≤N≤1,000,000 )
두 번째 줄에는 돌들이 놓인 좌표를 나타내는 NN 개의 정수 aiai들이 빈칸(공백)을 사이에 두고 주어진다. (1≤ai≤1091≤ai≤109 )
여기서, 주어진 좌표들은 증가하는 순서로 주어지고 모두 다르다.
세 번째 줄에는 개구리가 한 번의 점프로 이동 가능한 최대 거리 KK 가 주어진다. ( 1≤K≤1091≤K≤109 )

출력

각 테스트 케이스의 답을 순서대로 표준출력으로 출력하여야 하며, 각 테스트 케이스마다 첫 줄에 “Case #T”를 출력하여야 한다.
이때 TT는 테스트 케이스의 번호이다.
그 다음 줄에는 개구리가 마지막 돌로 이동할 수 있는 최소 점프 횟수를 출력한다.
만약, 개구리가 마지막 돌로 이동하는 것이 불가능한 경우에는 "-1"을 출력한다.

입출력예

푸는 TIP

나같은 경우는 배열 입력을 받았을 때, arr[0]에 배열의 크기를 저장하고, 데이터들을 arr에 저장해준다. -> 배열이 포인터로 데이터를 옮기기 때문에 데이터의 크기가 얼마나 되는지 알 수 없다.(sizeof로) 따라서 따로 arr[0]에 size를 저장해준다.

그리고 jump로 저장된 최대 점프로 해보고, 만약 배열에 동일한 데이터가 없는 경우 -1인 상태로 데이터 있는지 확인한다. 이를 반복해서 확인해보고 가장 멀리 점프하도록 유도한다. 기능을 분리해야함으로 새로운 함수를 작성해서 적용한다.

소스 코드

#include <stdio.h>
#include <malloc.h>
int Answer;
int move(int * arr, int jump);
int checking(int* arr, int input);
int* insert_data(int* arr);
int can_Across(int * arr, int jump);

int main(void)
{
	int T, test_case;
	int* arr = NULL;
	int jump = 0;
	setbuf(stdout, NULL);
	scanf("%d", &T);

	for (test_case = 0; test_case < T; test_case++)
	{
		Answer = 0;
		arr = insert_data(arr);
		scanf("%d", &jump);
		if (can_Across(arr, jump) == 0) {
			Answer = -1;
		}
		else {
			Answer = move(arr, jump);
		}
		printf("Case #%d\n", test_case + 1);
		printf("%d\n", Answer);
		free(arr);
	}
	return 0;
}

int move(int * arr, int jump) {
	int moved = 0;
	int count = 0;
	int size = arr[0];
	int toMove=0;
	while(moved < arr[size]) {
		toMove=jump+1; //밑에 while문을 do while로 고치기 싫어서 사용 
		while(toMove--){
			if(checking(arr, moved+toMove)){
				moved = moved+toMove;
				count++;
				break;
			}
			else{
				continue;
			}
		}
	}
	return count;
}

int checking(int* arr, int input) {
	int size = arr[0];
	int i=1;
	for(i=1;i<=size;i++){
		if(input == arr[i]){
			return 1;
		}
	}
	return 0;
}
int* insert_data(int* arr) { //arr의 index 0에는 data의 개수를 저장 
	int size;
	scanf("%d",&size);
	arr = (int *)malloc(sizeof(int) * (size+1));
	int i=1;
	for (i = 1; i <= size; i++) {
		scanf("%d", &arr[i]);
	}
	arr[0] = size;
	return arr;
}

int can_Across(int * arr, int jump) {
	int size = arr[0];
	int i = 1;
	for (i = 1; i < size; i++) { //data 개수-1까지 확인하면 종료 
		if (arr[i + 1] - arr[i] > jump){
			return 0;
		}
		else {
			continue;
		}
	}
	return 1;
}

느낀 점

test case들은 모두 통과했지만 time out이 뜬 걸로 봐서 시간 복잡도가 매우 높은걸로 예상된다. 아마 moving 함수에서 for문 2개에다가 checking함수의 for문까지 하나, 총 3개의 for문과 1개의 함수를 이동하는 것 때문에 시간 복잡도가 O(N^3)이상으로 커진 것 같다. 다른 방법을 찾아봐야겠다.

출처

[SCPC 2015 - 1차 예선]

문제

자연수 m이 자연수 n의 약수가 된다는 것은 n을 m으로 나누었을 때, 나머지가 없음을 의미한다. 예를 들어, 6의 약수는 1, 2, 3, 6 네 개가 있고 이의 합은 12이다. 자연수 A와 B가 주어졌을 때, A이상 B 이하의 모든 수에 대해 약수의 합을 다 더한 값을 구하는 프로그램을 작성하시오.

- 제한시간: 전체 테스트 케이스는 20개 이하이며, 전체 수행 시간은 1초 이내. (Java 2초 이내) 
    제한 시간을 초과하면 제출한 소스코드의 프로그램이 즉시 종료되며,
    그때까지 수행한 결과에서 테스트 케이스를 1개 그룹 이상 통과하였더라도 점수는 0점이 됩니다.
    그러나, 제한 시간을 초과하더라도 테스트 케이스를 1개 그룹 이상 통과하였다면 '부분 점수(0< 점수< 만점)'를 받을 수 있으며,
    이를 위해서는, C / C++ 에서 "printf 함수" 사용할 경우, 프로그램 시작부분에서 "setbuf(stdout, NULL);"를 한번만 사용하십시오.
    C++에서는 "setbuf(stdout, NULL);"와 "printf 함수" 대신 "cout"를 사용하고, Java에서는 "System.out.printIn"을 사용하시면,
    제한 시간을 초과하더라도 '부분 점수'를 받을 수 있습니다.                                     ※ 언어별 기본 제공 소스코드 내용 참고
    만약, 제한 시간을 초과하지 않았는데도 '부분 점수'를 받았다면, 일부 테스트 케이스를 통과하지 못한 경우 입니다.

메모리 사용 제한

heap, global, static (총계) : 256MB
stack : 1MB

입력

입력 파일에는 여러 테스트 케이스가 포함될 수 있다.
파일의 첫째 줄에 테스트 케이스의 개수를 나타내는 자연수 T 가 주어지고,
이후 차례로  T 개의 테스트 케이스가 주어진다. (1 ≤ T ≤ 20)
각 테스트 케이스의 입력은 다음과 같은 형식이다.
첫 번째 줄에 수의 범위를 나타내는 두 자연수 A와 B가 공백으로 구분되어 주어진다. (1 ≤ A ≤ B ≤ 5,000)

- 점수 : 최대 10회 제출하여 취득한 각각의 점수 중에서 최대 점수 (만점 100점)
모든 테스트 케이스를 맞추었을 때 만점을 받는다.

출력

각 테스트 케이스의 답을 순서대로 표준출력으로 출력하여야 하며,
각 테스트 케이스마다 첫 줄에는 “Case #C”를 출력하여야 한다. 이때 C는 테스트 케이스의 번호이다.
그 다음 줄에 문제의 정답을 출력한다. A이상 B이하의 모든 수에 대해 약수의 합을 다 더한 값을 출력한다.

푸는 TIP

main함수에 약수를 확인하는 것은 매우 더러워 보이니 따로 함수를 생성해서 사용할 때마다 호출하는 것이 간편하다.

나눠서 나머지가 0이 아니면 약수가 아니므로 '%' 연산자로 약수 판별을 쉽게 해낼 수 있다.

소스코드

#include <stdio.h>
int Answer;
void Devided(int input);
int main(void)
{
	int T, test_case;
	int min = 0, max = 0;
	setbuf(stdout, NULL);
	scanf("%d", &T);
	for (test_case = 0; test_case < T; test_case++)
	{
		Answer = 0;
		scanf("%d %d", &min, &max);
		for (int i = min; i <= max; i++) {
			Devided(i);
		}
		printf("Case #%d\n", test_case + 1);
		printf("%d\n", Answer);
	}

	return 0;//Your program should return 0 on normal termination.
}
void Devided(int input) {
	for (int i = 1; i <= input; i++) {
		if (input % i == 0) {
			Answer += i;
		}
	}
}

느낀 점

SCPC가 곧 다가와서 준비하는 차원으로 코드 그라운드 문제를 풀어보았는데, 첫 번째로 올라와있는걸 풀어서 그런지 백준이나 SW 아카데미에서 푼 문제들에 비해 쉽게 풀렸다.

링크