1. ์ ์ N์ด ์ฃผ์ด์ก์ ๋, N์ด 1 ์ด์ 9 ์ดํ์ ๋ ์ a, b์ ๊ณฑ์ผ๋ก ํํ๋ ์ ์๋์ง ํ๋จํ๋ผ.
์ ๋ ฅ ์กฐ๊ฑด
· ์ฒซ ๋ฒ์งธ ์ค์ ํ ์คํธ ์ผ์ด์ค์ ์ TC๊ฐ ์ฃผ์ด์ง๋ค. ์ดํ TC๊ฐ์ ํ ์คํธ ์ผ์ด์ค๊ฐ ์ ์ค๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค.
· ํ๋์ ์ ์ N์ด ์ฃผ์ด์ง๋ค.(1≤N≤100)
์ถ๋ ฅ ์กฐ๊ฑด
· N์ด 1 ์ด์ 9 ์ดํ์ ๋ ์ a, b์ ๊ณฑ์ผ๋ก ํํ๋ ์ ์์ผ๋ฉด “Yes”, ์๋๋ฉด “No”๋ฅผ ์ถ๋ ฅํ๋ผ.
#include <stdio.h>
// ํ์ค ์
๋ ฅ ์ถ๋ ฅ์ ํ ์ ์๊ฒ ๋์์ฃผ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํจ์๋ก, printf๋ฅผ ์ฌ์ฉํ ์ ์๊ฒ ํด์ค๋ค.
#include <string.h>
// ์ด ํค๋ํ์ผ์๋ C ํ์ ๋ฌธ์์ด (๋ ์ข
๋ฃ ๋ฌธ์์ด)์ ๋ค๋ฃฐ ์ ์๋ ํจ์๋ค์ ํฌํจํ๊ณ ์๋ค.
// ์ด๋ฒ ๋ฌธ์ ์์๋ memcpy๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด ํค๋ํ์ผ์ ์ฌ์ฉํ๋ค.
void init(); // ๋ฐํ๊ฐ์ด ์๋ init ํจ์ ์ ์ธ
void Timetable(); // ๋ฐํ๊ฐ ์๋ Timetable ํจ์ ์ ์ธ
int num[82]; // num ๋ฐฐ์ด์ ์ ์ธ
// 9 * 9 = 81์ด๊ธฐ ๋๋ฌธ์ 0 ~ 81๊น์ง๋ง ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
int N; // 1 ์ด์ 9 ์ดํ์ ๋ ์์ ๊ณฑ์ผ๋ก ์ฐพ๊ณ ์ถ์ ์
int main (int argc, char *argv[]) {
// ์ main ํจ์๊ฐ ํ์ค์ด๋ค.
// void๋ฅผ ์ฐ๋ฉด ์ธ์๊ฐ ์๋ค๋ ๊ฒ์ ์๋ ค์ค ์ ์๋ค.
int T, tc; // T, tc ์ ์ํ ๋ณ์ ์ ์ธ
printf("T๋ฅผ ์
๋ ฅํ์ธ์. : ");
scanf("%d", &T); // T๋ฅผ ์
๋ ฅํ๋ค.
for (tc = 1; tc <= T; tc++) { // T๋ฒ ์
๋ ฅํ๋ฉด for๋ฌธ ํ์ถ
init(); // ์ด๊ธฐํ ๋ฐ ์ด๊ธฐ ์
๋ ฅ
Timetable(); // ๊ตฌ๊ตฌ๋จ
printf("%d %s\n", tc, N == 1? "No" : "Yes"); // N = 1์ด๋ฉด No๋ฅผ ์ถ๋ ฅ, N = 0์ด๋ฉด Yes ์ถ๋ ฅ
}
return 0; // ํ์ฌ ์คํ ์ค์ธ ํจ์๋ฅผ ๋๋ธ๋ค.
}
void init() {
N = 0; // N = 0์ผ๋ก ์ด๊ธฐํํ๋ค.
memset(num, 0, sizeof(num)); // num ๋ฐฐ์ด์ ๋ฉ๋ชจ๋ฆฌ์ ํน์ ํ ๋ธ๋ก์ ๋ณต์ฌํ๋ค.
// memset ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ๋ชจ๋ฆฌ์ ๋ด์ฉ์ ์ํ๋ ํฌ๊ธฐ๋งํผ ํน์ ๊ฐ์ผ๋ก ์ค์ ํ ์ ์๋ค.
printf("N์ ์
๋ ฅํ์ธ์. : ");
scanf("%d", &N); // N์ ์
๋ ฅํ๋ค.
}
void Timetable() {
for (int i = 1; i <= 9; i++) { // i๊ฐ 1๋ถํฐ 9๊น์ง ๋ฐ๋ณต
for(int j = 1; j <= 9; j++) { // j๊ฐ 1๋ถํฐ 9๊น์ง ๋ฐ๋ณต
num[i * j] = 1;
// i๋ฅผ 1๋ถํฐ 9์ดํ, j๋ 1๋ถํฐ 9์ดํ๋ก ํํ ๊ฐ๋ฅํ๋ค๋ฉด num[N]์ ๊ฐ์ด 1์ด ๋๋ค.
}
}
if (num[N] == 0) { // num[N]์ด 0์ด๋ฉด
N = 1; // N = 1๋ก ์ ์ธํ์ฌ No๋ฅผ ์ถ๋ ฅํ ์ ์๋๋ก ํ๋ค.
}
else { // num[N]์ด 1์ด๋ฉด
N = 0; // N = 0์ด๋ฉด Yes๋ฅผ ์ถ๋ ฅํ ์ ์๋๋ก ํ๋ค.
}
}
์คํ ๊ฒฐ๊ณผ
T๋ฅผ ์
๋ ฅํ์ธ์. : 3
N์ ์
๋ ฅํ์ธ์. : 2
1 Yes
N์ ์
๋ ฅํ์ธ์. : 19
2 No
N์ ์
๋ ฅํ์ธ์. : 10
3 Yes
Program ended with exit code: 0
2. (๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ๋ฌธ์ ) ๋ค์ํ ์๋ก ์ด๋ฃจ์ด์ง ๋ฐฐ์ด์ด ์์ ๋ ์ฃผ์ด์ง ์๋ค์ M๋ฒ ๋ํ์ฌ ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ง๋์์ค.
์ ๋ ฅ ์กฐ๊ฑด
· ์ฒซ์งธ ์ค์ N(2≤N≤1,000), M(1≤M≤10,000), K(1≤K≤10,000)์ ์์ฐ์๊ฐ ์ฃผ์ด์ง๋ฉฐ, ๊ฐ ์์ฐ์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ๋ค.
· ๋์งธ ์ค์ N๊ฐ์ ์์ฐ์๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ์์ฐ์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ๋ค. ๋จ, ๊ฐ๊ฐ์ ์์ฐ์๋ 1 ์ด์ 10,000 ์ดํ์ ์๋ก ์ฃผ์ด์ง๋ค.
· ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ K ๋ ํญ์ M ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค.
์ถ๋ ฅ ์กฐ๊ฑด
· ์ฒซ์งธ ์ค์์ ๊ตฌํํ ํฐ ์์ ๋ฒ์น์ ๋ฐ๋ผ ๋ํด์ง ๋ต์ ์ถ๋ ฅํ๋ค.
#include <stdio.h>
// ํ์ค ์
๋ ฅ ์ถ๋ ฅ์ ํ ์ ์๊ฒ ๋์์ฃผ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํจ์๋ก, printf๋ฅผ ์ฌ์ฉํ ์ ์๊ฒ ํด์ค๋ค.
int main(void) {
int N, M, K;
int arr[1000];
int first, second;
int i, j, tmp = 0;
// N, M, K๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ์
๋ ฅ๋ฐ๋๋ค.
printf("N์ ์
๋ ฅํ์์ค: ");
scanf("%d", &N); // ์
๋ ฅ ์ซ์ ํ์
printf("M์ ์
๋ ฅํ์์ค: ");
scanf("%d", &M);
printf("K๋ฅผ ์
๋ ฅํ์์ค: ");
scanf("%d", &K);
// N๊ฐ์ ์๋ฅผ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๊ตฌ๋ถํ์ฌ ์
๋ ฅ๋ฐ๋๋ค.
for (int i = 0; i < N; i++) {
int x;
fflush(stdin); // ์
๋ ฅ ๋ฒํผ ์ง์ฐ๊ธฐ ํจ์
printf("[%d]: ", i + 1);
scanf("%d", &x);
arr[i] = x;
}
// ์
๋ ฅ ๋ฐ์ ์๋ฅผ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
for (i = 0; i < N; i++) {
for (j = i; j < N - 1; j++) { // ๊ธฐ์ค ์ซ์๊ฐ ์๊ธฐ ๋๋ฌธ์ N - 1
if (arr[j] < arr[i]) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
first = arr[N - 1]; // ๊ฐ์ฅ ํฐ ์
second = arr[N - 2]; // ๋ ๋ฒ์งธ๋ก ํฐ ์
// ๊ฐ์ฅ ํฐ ์๊ฐ ๋ํด์ง๋ ํ์ ๊ณ์ฐ
int cnt = (M / (K + 1)) * K;
cnt += M % (K + 1);
int result = 0; // ๊ฒฐ๊ณผ๊ฐ ์ด๊ธฐํ
result += cnt * first; // ๊ฐ์ฅ ํฐ ์ ๋ํ๊ธฐ
result += (M - cnt) * second; // ๋ ๋ฒ์งธ๋ก ํฐ ์ ๋ํ๊ธฐ
printf("๊ฒฐ๊ณผ๊ฐ: %d\n", result); // ๊ฒฐ๊ณผ๊ฐ์ ์ถ๋ ฅํ๋ค.
return 0; // ํ์ฌ ์คํ ์ค์ธ ํจ์๋ฅผ ๋๋ธ๋ค.
}
์คํ ๊ฒฐ๊ณผ
N์ ์
๋ ฅํ์์ค: 5
M์ ์
๋ ฅํ์์ค: 6
K๋ฅผ ์
๋ ฅํ์์ค: 5
[1]: 3
[2]: 5
[3]: 7
[4]: 8
[5]: 6
๊ฒฐ๊ณผ๊ฐ: 38
Program ended with exit code: 0
๋ฌธ์ ํด์
ํ๋์ ์ซ์๋ฅผ ์ฐ์์ผ๋ก ๋ํ ์ ์๋ ํ์๋ ์ต๋ K๋ฒ์ด๋ค.
๋ฐ๋ผ์ ๊ฐ์ฅ ํฐ ์๋ฅผ K๋ฒ ๋ํ๊ณ , ๋ ๋ฒ์งธ๋ก ํฐ ์๋ฅผ ํ ๋ฒ ๋ํ๋ ์ฐ์ฐ์ ๋ฐ๋ณตํ๋ฉด ๋๋ค.
๋ฐ๋ผ์ ๋ง์ ์ฐ์ฐ์ด ์ด M๋ฒ ์งํ๋๋ฉด ๊ณ์ฐ์ ์ข ๋ฃํ๋ค.
๋ฐ๋ณต๋ฌธ ์์์ scanf๊ฐ ์นํ๋ ํ์
fflush(stdin);
for (int s = 0; s < N; s++) {
int x;
printf("O");
scanf("%d", &x);
arr[s] = x;
}
๋ฐ๋ณต๋ฌธ์ด ์ ๋๋ก ์คํ๋๋ ๊ฒ ๊ฐ์ง๊ฐ ์์์
์ถ๋ ฅ๋ฌธ ํ๋๋ฅผ ์จ์ ๋ฐ๋ณต๋ฌธ์ ์คํ๋ณด๋๊น
N, M, K๋ฅผ ์์๋๋ก ์
๋ ฅํ์์ค: 5 8 3
OOO
์ด๋ ๊ฒ ์ถ๋ ฅ๋ฌธ์ด 3๋ฒ ์ถ๋ ฅ๋๊ณ scanf ์ ๋ ฅ์ด ๋ฌ ๊ฒ์ด์๋ค. ๊ทธ๋์ ์ด 3๋ฒ์ ์ ๋ ฅ๋ง ๋๊ณ ,
2๋ฒ์ ์ ๋ ฅ์ ํ ์ ์์๋ค. ๊ทธ๋ฌํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ฐพ์ ๋ฐฉ๋ฒ์ด fflush(stdin);์ด๋ค.
์ ์ฝ๋๋ฅผ ์์ฑํ๋ scanf ์ค๋ฅ๊ฐ ์ฌ๋ผ์ก๋ค.