[정보처리기사 실기] C언어 프로그래밍 특강(3)

17번 문제

#include <stdio.h>

void main() {
    int c = 100; // 정수형 변수 c를 선언하고 100으로 초기화합니다.

    switch (9) { // switch 문은 값 9로 시작합니다.
        case 0: // case 0에 해당하는 블록: 실행되지 않음. default로 이동.
            c += 2;
            break;
        default: // 기본(default) 블록: 다음으로 이동
            c = 0; // c를 0으로 설정합니다. (c = 0)
        case 2: // case 2에 해당하는 블록: 실행됨
            c += 1; // c에 1을 더합니다. (c = c + 1 = 1)
        case 8: // case 8에 해당하는 블록: 실행됨
            c += 2; // c에 2를 더합니다. (c = c + 2 = 3)
            break; // switch 문을 빠져나갑니다.
        case 7: // 실행되지 않음
            c = c + 4;
    }

    printf("%d\n", c); // c의 값을 출력합니다.
}

1. int c가 선언되고 100으로 초기화됩니다.
2. switch 문은 값 9로 시작합니다.
3. case 9가 없으므로 default 케이스로 이동합니다.
4. default 케이스에서 c는 0으로 설정됩니다.
5. 실행은 case 2로 이어집니다. case 2에서 c가 1만큼 증가하여 1이 되고, 여전히 break 문이 없으므로 바로 아래의 case 8로 이동합니다.
6. case 8에서 c가 2만큼 증가하여 총 값은 3이 됩니다.
7. case 8 이후의 break 문이 실행되어 switch 문을 종료합니다.
8. 마지막으로 printf("%d\n", c);가 실행되어 c의 값, 즉 3이 출력됩니다.

3

 

​

​

​

18번 문제

#include <stdio.h>

void main() {
    int sum = 0, n = 0;
    int i[7] = {3, -5, 8, 10, -9, 4, 6};
    
    for (; n < 6; n++) {
        if (i[n] > sum) {
            int temp;
            temp = i[n + 1]; //
            i[n + 1] = i[n];
            i[n] = temp; // 자리 바꿈 문제
        }
        sum += i[n];
    }
    
    printf("%d\n", sum);
}

1. sum을 0으로 초기화하고 n을 0으로 초기화합니다.
2. i라는 정수 배열을 선언하고 값은 {3, -5, 8, 10, -9, 4, 6} 입니다.
3. for 루프에 진입합니다. 조건은 n < 6이므로 n은 0에서 시작하여 총 6번 반복됩니다.

이제 루프 각 반복에서 다음을 설명하겠습니다:

​

반복 1 (n = 0):

• i[0]는 3이고 sum은 0입니다. 3 > 0 이므로 if 조건이 충족됩니다.
• i[0]과 i[1]을 교환합니다. 이후 i는 { -5, 3, 8, 10, -9, 4, 6 }이 됩니다.
• sum을 sum + i[0]로 업데이트합니다. 이는 0 + (-5) = -5가 됩니다.

​

반복 2 (n = 1):

• i[1]은 이제 3이고 sum은 -5입니다. 3 > -5 이므로 if 조건이 충족됩니다.
• i[1]과 i[2]를 교환합니다. 이후 i는 { -5, 8, 3, 10, -9, 4, 6 }이 됩니다.
• sum을 sum + i[1]로 업데이트합니다. 이는 -5 + 8 = 3이 됩니다.

​

반복 3 (n = 2):

• i[2]는 3이고 sum은 3입니다. 3 > 3 이므로 if 조건이 충족되지 않습니다.
• i는 { -5, 8, 3, 10, -9, 4, 6 } (변화 없음)이 됩니다.
• sum을 sum + i[2]로 업데이트합니다. 이는 3 + 3 = 6이 됩니다.

​

반복 4 (n = 3):

• i[3]은 10이고 sum은 6입니다. 10 > 6 이므로 if 조건이 충족됩니다.
• i[3]과 i[4]를 교환합니다. 이후 i는 { -5, 3, 8, -9, 10, 4, 6 }이 됩니다.
• sum을 sum + i[3]로 업데이트합니다. 이는 6 + (-9) = -3이 됩니다.

​

반복 5 (n = 4):

• i[4]는 10이고 sum은 -3입니다. 10 > -3 이므로 if 조건이 충족됩니다.
• i[4]와 i[5]를 교환합니다. 이후 i는 { -5, 3, 8, -9, 4, 10, 6 }이 됩니다.
• sum을 sum + i[4]로 업데이트합니다. 이는 -3 + 4 = 1이 됩니다.

​

반복 6 (n = 5):

• i[5]는 10이고 sum은 1입니다. 10 > 1 이므로 if 조건이 충족됩니다.
• i[5]와 i[6]을 교환합니다. 이후 i는 { -5, 3, 8, -9, 4, 6, 10 }이 됩니다.
• sum을 sum + i[5]로 업데이트합니다. 이는 1 + 6 = 7이 됩니다.

7

 

루프가 종료되면 sum은 7이 됩니다. 따라서 코드는 최종 출력으로 7을 출력합니다.

​

​

​

19번 문제

#include <stdio.h>
#define change(x,y) imsi=x; x=y; y=imsi;
void main() {
    int i, j, K=5, imsi;
    int num[5] = {5, 9, 3, 7, 4};
    for (i = 0; i < K; i++) {
        for (j = 0; j < (K - i); j++) {
            if (num[j] < num[j+1]) {
                change(num[j], num[j+1]); // 이 부등호에 따라 오름차순, 내림차순 결정됨
            } // 현재는 내림차순 코드
        }
    }
    printf("%d\n", num[1]);
}

문제 풀이 순서

1. #define change(x,y) imsi=x; x=y; y=imsi;는 x와 y의 값을 임시 변수 imsi를 사용하여 교환하는 change 매크로를 정의합니다.
2. int i, j, K=5, imsi;는 정수 변수 i, j, K, imsi를 선언합니다. K는 5로 초기화됩니다.
3. int num[5] = {5, 9, 3, 7, 4};는 5개의 요소로 이루어진 정수 배열 num을 선언하고 값 {5, 9, 3, 7, 4}으로 초기화합니다.
4. 코드는 중첩된 루프 구조로 진입합니다. 외부 루프 (for (i = 0; i < K; i++))는 5번 반복되며, 내부 루프 (for (j = 0; j < (K - i); j++))는 배열의 정렬되지 않은 요소 중 남은 부분에 대해 반복됩니다.
5. 내부 루프 내에서 코드는 num[j]가 num[j+1]보다 작은지 확인합니다. 이 조건이 참이면 요소가 정렬 순서에 맞지 않으므로 change 매크로를 사용하여 두 값을 교환합니다.
6. 내부 루프는 버블 정렬 알고리즘을 사용하여 배열을 내림차순으로 정렬합니다.
7. 두 루프가 모두 종료된 후, 배열에서 가장 큰 요소는 마지막 위치로 이동합니다.
8. 마지막으로 코드는 정렬된 배열에서 두 번째로 큰 요소인 num[1]을 출력합니다.

​

​

정렬 과정을 단계별로 살펴봅시다.

​

1. 첫 번째 패스 (i = 0):

• 내부 루프 (j = 0부터 K - i = 5 - 0 = 5까지):
• j = 0: num[0] = 5와 num[1] = 9를 비교하여 조건이 참이므로 두 값을 교환합니다. 배열: {9, 5, 3, 7, 4}
• j = 1: num[1] = 5와 num[2] = 3을 비교하여 num[1]<num[2]가 거짓이므로 두 값이 교환되지 않습니다. 배열: {9, 5, 3, 7, 4}
• j = 2: num[2] = 3와 num[3] = 7을 비교하여 조건이 참이므로 두 값을 교환합니다. 배열: {9, 5, 7, 3, 4}
• j = 3: num[3] = 3와 num[4] = 4를 비교하여 조건이 참이므로 두 값을 교환합니다. 배열: {9, 5, 7, 4, 3}

​

2. 두 번째 패스 (i = 1):

• 내부 루프 (j = 0부터 K - i = 5 - 1 = 4까지):
• j = 0: num[0] = 9와 num[1] = 5를 비교하여 num[1]<num[2]가 거짓이므로 두 값이 교환되지 않습니다. 배열: {9, 5, 7, 4, 3}
• j = 1: num[1] = 5와 num[2] = 7을 비교하여 조건이 참이므로 두 값을 교환합니다. 배열: {9, 7, 5, 4, 3} "사실상 정렬 끝남(버블정렬 내림차순)"
• j = 2: num[2] = 7와 num[3] = 4를 비교하여 num[1]<num[2]가 거짓이므로 두 값이 교환되지 않습니다. 배열: {9, 7, 5, 4, 3}
• j = 3: num[3] = 4와 num[4] = 3을 비교하여 num[1]<num[2]가 거짓이므로 두 값이 교환되지 않습니다. 배열: {9, 7, 5, 4, 3}

​

3. 세 번째 패스 (i = 2):

• 내부 루프 (j = 0부터 K - i = 5 - 2 = 3까지):
• j = 0: num[0] = 9와 num[1] = 5를 비교하여 num[1]<num[2]가 거짓이므로 두 값이 교환되지 않습니다. 배열: {9, 7, 5, 4, 3}
• j = 1: num[1] = 5와 num[2] = 7을 비교하여 num[1]<num[2]가 거짓이므로 두 값이 교환되지 않습니다. 배열: {9, 7, 5, 4, 3}
• j = 2: num[2] = 7와 num[3] = 4를 비교하여 num[1]<num[2]가 거짓이므로 두 값이 교환되지 않습니다. 배열: {9, 7, 5, 4, 3}

​

4. 네 번째 패스 (i = 3):

• 내부 루프 (j = 0부터 K - i = 5 - 3 = 2까지):
• j = 0: num[0] = 9와 num[1] = 5를 비교하여 num[1]<num[2]가 거짓이므로 두 값이 교환되지 않습니다. 배열: {9, 7, 5, 4, 3}
• j = 1: num[1] = 5와 num[2] = 7을 비교하여 num[1]<num[2]가 거짓이므로 두 값이 교환되지 않습니다. 배열: {9, 7, 5, 4, 3}

​

이제 num[1]은 7로, 정렬된 배열에서 두 번째로 큰 요소입니다. 따라서 코드는 최종 출력으로 7을 출력합니다.

​

​

​

20번 문제

순환함수(재귀호출, 되부름)

int foo(int a, int b) {
    if (a > b) return 0;
    else return b + foo(a + 1, b);
}

void main() {
    int a = 7, b = 10, y;
    y = foo(a, b);
    printf("%d\n", y);
}

주어진 코드는 재귀 함수인 foo를 사용하여 값을 계산하고, 그 결과를 main 함수에서 출력하는 프로그램입니다. 이를 단계별로 설명하겠습니다.

​

1. main 함수가 a = 7 및 b = 10으로 호출되며, 변수 y를 초기화합니다.
2. main 함수 내에서 foo 함수가 a와 b와 함께 호출됩니다. 초기값은 a = 7 및 b = 10입니다.
3. foo 함수 내에서: a > b를 확인하고, 이 조건이 거짓이므로 b + foo(a + 1, b)를 계산합니다. 따라서 현재 호출된 foo 함수는 10 + foo(8, 10)을 반환합니다.
4. 이제 foo 함수가 a = 8 및 b = 10으로 재귀적으로 호출됩니다. 다시, a > b를 확인하고, 이 조건이 거짓이므로 b + foo(a + 1, b)를 계산합니다. 따라서 현재 호출된 foo 함수는 10 + foo(9, 10)을 반환합니다.
5. 재귀 호출은 a = 9 및 b = 10으로 진행됩니다. 다시, a > b를 확인하고, 이 조건이 거짓이므로 b + foo(a + 1, b)를 계산합니다. 따라서 현재 호출된 foo 함수는 10 + foo(10, 10)을 반환합니다.
6. 재귀 호출은 a = 10 및 b = 10으로 진행됩니다. 다시, a > b를 확인하고, 이 조건이 거짓이므로 b + foo(a + 1, b)를 계산합니다. 따라서 현재 호출된 foo 함수는 10 + foo(11, 10)을 반환합니다.
7. 이제 foo 함수가 a = 11 및 b = 10으로 호출됩니다. 이 때 a > b 조건이 참이 되므로 0을 반환합니다.
8. 최종 결과로 10 + 10 + 10 + 10 + 0 = 40이 반환되고, 이 값이 변수 y에 저장되어 출력됩니다. 따라서 main 함수에서 출력되는 값은 y에 저장된 결과인 40입니다.

40

 

이는 재귀 호출을 통해 각 호출에서 b를 더한 값을 계속 누적하기 때문에 반환된 값들이 이전 호출로 역순으로 더해져서 40이 최종 결과로 반환되기 때문입니다.

​

​

​

21번 문제

f(5) {
    if (n > 0) f(n - 2);
    printf("%d", n);
}

1. 처음에 f(5) 함수가 호출됩니다.
2. f(5) 함수 내부에서 if (n > 0)을 확인합니다. 현재 n은 5이므로 조건은 참입니다.
3. 조건이 참이므로 f(5 - 2) 또는 f(3)이 호출됩니다.
4. 이제 f(3) 함수가 호출됩니다.
5. f(3) 함수 내부에서 다시 if (n > 0)을 확인합니다. 현재 n은 3이므로 조건은 참입니다.
6. 조건이 참이므로 f(3 - 2) 또는 f(1)이 호출됩니다.
7. 이제 f(1) 함수가 호출됩니다.
8. f(1) 함수 내부에서 다시 if (n > 0)을 확인합니다. 현재 n은 1이므로 조건은 참입니다.
9. 조건이 참이므로 f(1 - 2) 또는 f(-1)이 호출됩니다.
10. 이제 f(-1) 함수가 호출됩니다.
11. f(-1) 함수 내부에서 다시 if (n > 0)을 확인합니다. 이제 n은 -1이므로 조건은 거짓입니다.
12. 따라서 더 이상 재귀 호출을 수행하지 않고, printf("%d", n);이 실행됩니다. 현재 n은 -1이므로 "-1"이 출력됩니다.
13. 호출 스택을 거슬러 올라가면서, f(1) 함수는 이전 호출로 돌아갑니다.
14. f(1) 함수는 끝나고, printf("%d", n);이 실행됩니다. 이전 호출에서 n은 1이었으므로 "1"이 출력됩니다.
15. 호출 스택을 더 거슬러 올라가면서, f(3) 함수는 이전 호출로 돌아갑니다.
16. f(3) 함수는 끝나고, printf("%d", n);이 실행됩니다. 이전 호출에서 n은 3이었으므로 "3"이 출력됩니다.
17. 호출 스택을 더 거슬러 올라가면서, f(5) 함수는 이전 호출로 돌아갑니다.
18. f(5) 함수는 끝나고, printf("%d", n);이 실행됩니다. 이전 호출에서 n은 5이었으므로 "5"가 출력됩니다.

-1135

 

함수 내에서 자기 자신을 호출하는 것은

일반적으로 재귀 함수를 나타냅니다.

재귀 함수란 함수가 자기 자신을 직접 또는 간접적으로

호출하는 함수를 의미합니다.

이러한 호출은 함수 호출 스택을 사용하여 처리되며,

함수가 호출될 때마다 새로운 인스턴스가 스택에 푸시되고,

함수가 반환되면 스택에서 팝됩니다.

재귀 함수는 특정 종료 조건을 충족할 때까지 반복적으로

자신을 호출하여 문제를 해결합니다.

- 메모 -

​

​

​

22번 문제

#include <stdio.h>
void main() {
    int a, b = 2;
    while (++b <= 30) {
        a = 1;
        while (++a < b) {
            if (b % a == 0) break;
        }
        if (a == b) printf("%d, ", b);
    }
}

1. 처음에 b는 2이므로 while 루프가 실행됩니다.

• ++b가 실행되어 b가 2에서 3으로 증가하고, 3 <= 30이므로 조건이 참입니다. 따라서 a는 1로 초기화됩니다.
• ++a가 실행되어 a가 1에서 2로 증가하고, 2 < 3이므로 조건이 참입니다.
• if 문이 실행됩니다. b % a는 3 % 2로 계산되며 결과는 1입니다. 따라서 if 문은 거짓이고, 루프는 계속 실행됩니다.
• ++a가 다시 실행되어 a가 2에서 3으로 증가하고, 이제 3 < 3은 거짓이므로 내부 while 루프가 종료됩니다.
• if 문이 실행됩니다. a가 b와 같은 값인지 확인합니다. a가 3이고 b가 3이므로 if 문은 참이 되고, 3이 출력됩니다.

2. 이와 같은 방식으로 b가 4, 5, 6, 7, 8, 9, 10, ... 순서로 증가할 때까지 반복됩니다. 소수인 경우에만 해당 숫자가 출력됩니다.

3. 마지막으로 b가 30이 될 때까지 반복됩니다. 모든 b 값에 대해 a가 b로 나누어떨어지지 않는 경우만 출력됩니다. 따라서 출력 결과는 3, 5, 7, 11, 13, 17, 19, 23, 29가 됩니다.

3, 5, 7, 11, 13, 17, 19, 23, 29,

 

b=6이 될 때까지만 조금 더 진행해 보겠습니다. (살려주세요 ㅠㅠ)

​

(1) b가 2인 경우:

• ++b가 실행되어 b가 2에서 3으로 증가하고, 3 <= 30이므로 조건이 참입니다. 따라서 a는 1로 초기화됩니다.
• ++a가 실행되어 a가 1에서 2로 증가하고, 2 < 3이므로 조건이 참입니다.
• if 문이 실행됩니다. b % a는 3 % 2로 계산되며 결과는 1입니다. 따라서 if 문은 거짓이고, 루프는 계속 실행됩니다.
• ++a가 다시 실행되어 a가 2에서 3으로 증가하고, 이제 3 < 3은 거짓이므로 내부 while 루프가 종료됩니다.
• if 문이 실행됩니다. a가 b와 같은 값인지 확인합니다. a가 3이고 b가 3이므로 if 문은 참이 되고, 3이 출력됩니다.

​

(2) b가 3인 경우:

• ++b가 실행되어 b가 3에서 4로 증가하고, 4 <= 30이므로 조건이 참입니다. 따라서 a는 1로 초기화됩니다.
• ++a가 실행되어 a가 1에서 2로 증가하고, 2 < 4이므로 조건이 참입니다.
• if 문이 실행됩니다. b % a는 4 % 2로 계산되며 결과는 0입니다. 따라서 if 문은 참이 되고, 이때 break가 실행되어 첫 번째 while 루프로 돌아갑니다.

​

(3) b가 4인 경우:

• ++b가 실행되어 b가 4에서 5로 증가하고, 5 <= 30이므로 조건이 참입니다. 따라서 a는 1로 초기화됩니다.
• ++a가 실행되어 a가 1에서 2로 증가하고, 2 < 5이므로 조건이 참입니다.
• if 문이 실행됩니다. b % a는 5 % 2로 계산되며 결과는 1입니다. 따라서 if 문은 거짓이고, 루프는 계속 실행됩니다.
• ++a가 다시 실행되어 a가 2에서 3으로 증가하고, 3 < 5는 참입니다.
• if 문이 실행됩니다. b % a는 5 % 3으로 계산되며 결과는 2입니다. 따라서 if 문은 거짓이고, 루프는 계속 실행됩니다.
• ++a가 다시 실행되어 a가 3에서 4로 증가하고, 4 < 5는 참입니다.
• if 문이 실행됩니다. b % a는 5 % 4로 계산되며 결과는 1입니다. 따라서 if 문은 거짓이고, 루프는 계속 실행됩니다.
• ++a가 다시 실행되어 a가 4에서 5로 증가하고, 이제 5 < 5는 거짓이므로 내부 while 루프가 종료됩니다.
• if 문이 실행됩니다. a가 b와 같은 값인지 확인합니다. a가 5이고 b가 5이므로 if 문은 참이 되고, 5가 출력됩니다.

​

(4) b가 5인 경우:

• ++b가 실행되어 b가 5에서 6으로 증가하고, 6 <= 30이므로 조건이 참입니다. 따라서 a는 1로 초기화됩니다.
• ++a가 실행되어 a가 1에서 2로 증가하고, 2 < 6이므로 조건이 참입니다.
• if 문이 실행됩니다. b % a는 6 % 2로 계산되며 결과는 0입니다. 따라서 if 문은 참이 되고, 이때 break가 실행되어 첫 번째 while 루프로 돌아갑니다.

​

(5) b가 6인 경우:

• ++b가 실행되어 b가 6에서 7로 증가하고, 7 <= 30이므로 조건이 참입니다. 따라서 a는 1로 초기화됩니다.
• ++a가 실행되어 a가 1에서 2로 증가하고, 2 < 7이므로 조건이 참입니다.
• if 문이 실행됩니다. b % a는 7 % 2로 계산되며 결과는 1입니다. 따라서 if 문은 거짓이고, 루프는 계속 실행됩니다.
• ++a가 다시 실행되어 a가 2에서 3으로 증가하고, 3 < 7은 참입니다.
• if 문이 실행됩니다. b % a는 7 % 3으로 계산되며 결과는 1입니다. 따라서 if 문은 거짓이고, 루프는 계속 실행됩니다.
• ++a가 다시 실행되어 a가 3에서 4로 증가하고, 4 < 7은 참입니다.
• if 문이 실행됩니다. b % a는 7 % 4로 계산되며 결과는 3입니다. 따라서 if 문은 거짓이고, 루프는 계속 실행됩니다.
• ++a가 다시 실행되어 a가 4에서 5로 증가하고, 5 < 7은 참입니다.
• if 문이 실행됩니다. b % a는 7 % 5로 계산되며 결과는 2입니다. 따라서 if 문은 거짓이고, 루프는 계속 실행됩니다.
• ++a가 다시 실행되어 a가 5에서 6로 증가하고, 이제 6 < 7은 참입니다.
• if 문이 실행됩니다. b % a는 7 % 6으로 계산되며 결과는 1입니다. 따라서 if 문은 거짓이고, 루프는 계속 실행됩니다.
• ++a가 다시 실행되어 a가 6에서 7로 증가하고, 이제 7 < 7은 거짓이므로 내부 while 루프가 종료됩니다.
• if 문이 실행됩니다. a가 b와 같은 값인지 확인합니다. a가 7이고 b가 7이므로 if 문은 참이 되고, 7이 출력됩니다.

7

​

 

 

​

23번 문제

#include <stdio.h>

int getnext(int a) {
    return (a * 2 + 1);
}

void main() {
    int i, j, k = 0;
    for (i = 1; i < 10; i++)
        for (j = 1; j < getnext(i); j++)
            k++;
    printf("k = %d\n", k);
}

이 코드는 두 개의 중첩된 루프와 함수 호출을 통해 'k'의 값을 계산합니다.

​

1. 변수 초기화:

• 'i'를 0으로 초기화합니다.
• 'j'를 0으로 초기화합니다.
• 'k'를 0으로 초기화합니다.

​

2. 바깥쪽 루프 (제어 변수 'i'로 제어)는 1에서 9까지 실행됩니다.

따라서 'i'는 각 반복에서 1에서 9까지의 값을 가집니다.

​

3. 바깥쪽 루프 내에서, 'j'로 제어되는 안쪽 루프가 있으며 조건은 'j < getnext(i)'입니다.

이 안쪽 루프는 1에서 'getnext(i)'까지 실행됩니다.

​

4. 'getnext(i)' 함수는 현재 'i'의 값을 받아와서 'a * 2 + 1'을 반환합니다.

'i'가 1로 시작하므로, 'getnext(1)'은 3을 반환하고, 'getnext(2)'는 5를 반환하며, 'getnext(3)'은 7을 반환합니다. 이 값은 각 'i' 반복에서 안쪽 루프의 반복 횟수를 결정합니다.

​

5. 안쪽 루프에서 'k'는 각 반복에서 1씩 증가합니다.

따라서 각 'i' 반복에서 'getnext(i)'에 따라 'k'가 증가합니다.

​

6. 바깥쪽 루프는 'i'가 9가 될 때까지 계속되며, 안쪽 루프는 'getnext(i)'에 따라 'k'를 증가시킵니다.

​

7. 두 루프가 완료된 후 'k'에는 'k'가 증가된 총 횟수가 저장되며, 이것은 각 'i' 값에 대한 'getnext(i)'에 따른 반복 횟수의 합입니다.

​

이제 'k'를 단계별로 계산해 보겠습니다.

• 'i'가 1인 경우, 'getnext(i)'는 3입니다. 안쪽 루프에서 j는 'getnext(i)'보다 작을 때까지 실행되기 때문에 1에서 2까지 실행되며 'k'가 2 증가합니다. (k++가 2번 진행되기 때문)
• 'i'가 2인 경우, 'getnext(i)'는 5입니다. 안쪽 루프는 1에서 4까지 실행되며 'k'가 4 증가합니다.
• 'i'가 3인 경우, 'getnext(i)'는 7입니다. 안쪽 루프는 1에서 6까지 실행되며 'k'가 6 증가합니다.
• 이러한 패턴이 'i'가 9일 때까지 계속됩니다. 'getnext(i)'가 19인 경우, 안쪽 루프는 1에서 18까지 실행되며 'k'가 18 증가합니다.

​

각 'i' 값에 대한 증가값을 합산해 봅시다:

2 + 4 + 6 + 8 + 10 + 12 + 14 + 16 + 18 = 90

k = 90

따라서 루프가 완료되면 'k'는 90이 되며, 따라서 출력 결과는 "k = 90"입니다.

​

​

 

​

24번 문제

f() {
 int i = 1;
 static int j = 1; //정적변수 초기화를 반드시 한 번만!
 printf("%d %d", i++, j++);
}

main() {
 f(); f(); f();
}

이 코드는 함수 f와 main 함수를 정의하고, main 함수에서 f 함수를 세 번 호출하는 내용입니다.

f 함수 내에는 i와 j 두 변수가 있습니다. i는 지역 변수이고, j는 정적(static) 변수로 선언되어 있습니다.

f 함수는 i와 j의 값을 출력하고, 그 뒤에 두 변수를 증가시킵니다.

main 함수에서는 f 함수를 연속해서 세 번 호출합니다.

​

이 코드의 실행을 단계별로 설명하겠습니다.

(1) main 함수가 호출되며, 처음으로 f()를 호출합니다.

• f() 내부에서 i는 1로 초기화되고, j (정적 변수) 역시 1로 초기화됩니다.
• i와 j의 값을 출력하고, 두 변수를 2로 증가시킵니다.
• 출력 결과는 "1 1"입니다.

​

(2) main 함수가 두 번째로 f()를 호출합니다.

• f() 내부에서 i는 다시 1로 초기화되고, j (정적 변수)는 이전 호출에서의 값인 2를 유지합니다.
• i와 j의 값을 출력하고, 두 변수를 각각 2와 3으로 증가시킵니다.
• 출력 결과는 "1 2"입니다.

​

(3) main 함수가 세 번째로 f()를 호출합니다.

• f() 내부에서 i는 다시 1로 초기화되고, j (정적 변수)는 이전 호출에서의 값인 3을 유지합니다.
• i와 j의 값을 출력하고, 두 변수를 각각 2와 4로 증가시킵니다.
• 출력 결과는 "1 3"입니다.

​

(4) 세 번의 f() 호출이 모두 완료된 후, main 함수가 반환합니다.

프로그램의 최종 출력은 세 번의 f() 호출 결과가 이어진 것으로, "1 11 21 3"이라는 결과가 나타납니다.

1 11 21 3

각 f() 호출은 i가 항상 1부터 시작하며, 정적 변수인 j는 호출 사이에서 그 값이 유지되므로 j의 값이 증가하는 것을 볼 수 있습니다.

 

 

 

💡 이 게시글은 PC 환경에 최적화하여 작성되었습니다.

💡 위 내용은 에듀윌에서 무료로 제공한 '정보처리기사 비밀 언어 특강' 문제를 직접 풀고 정리한 것입니다.

틀린 부분이 있다면 언제든 댓글 남겨주세요 :)

💡정보처리기사 실기 시험을 준비하시는 분들께는 아래 링크에서 해당 강의를 먼저 듣는 것을 권장합니다.

​

IT 자격증 1위 에듀윌 (eduwill.net)