[2022년 2회]

< C++ >

# 1. 다음 소스코드에 대한 출력값을 작성하시오.

[소스코드]

#include <stdio.h>

struct A 
{
    int n;
    int g;
};

int main() 
{
    A a[2];
    for (int i = 0; i < 2; i++) 
    {
        a[i].n = i;
        a[i].g = i + 1;
    }
    printf("%d\n", a[0].n + a[1].g);

    return 0;
}

구조체 A  정의

 

A a[2]; // 구조체 A 타입의 크기가 2인 배열 a를 생성

반복문 루프를 타면서 구조체 배열 a의 첫 번째 인덱스부터 두 번째 인덱스까지 요소를 채움

a[0].n = 0, a[0].g = 1

a[1].n = 1, a[1].g = 2

 

[출력결과]

2

 

# 2. 다음 C언어에서 출력에 대한 알맞은 답을 작성하시오.

[소스코드]

#include <stdio.h>

int len(const char* p)
{
    int r = 0;
    while (*p != '\0')
    {
        p++;
        r++;
    }
    return r;
}

int main() 
{
    const char* p1 = "2022";
    const char* p2 = "202207";

    printf("%d", len(p1) + len(p2));

    return 0;
}

p1, p2는 각각 문자열 리터럴을 가리키는 포인터다

 

len(const char* p) 함수는 파라미터로 포인터 p를 할당받아 문자열 리터럴의 길이를 카운트하여 리턴하는 함수이다

포인터 p가 가리키는 값이 null 문자가 나오기 전까지 계속 반복하는 구조를 띄고 있다

 

[출력결과]

10

 

# 3. 다음 C언어 코드에서 알맞는 출력값을 작성하시오.

[소스코드]

#include <stdio.h>

int main() 
{
    int a[4] = {0, 2, 4, 8};
    int b[3] = {};
    int i = 1;
    int sum = 0;
    int* p1;

    for (i; i < 4; i++) 
    {
        p1 = a + i;
        b[i - 1] = *p1 - a[i - 1];
        sum = sum + b[i - 1] + a[i];
    }

    printf("%d", sum);

    return 0;
}

크기가 4인 배열 a를 생성하고, 요소 {0, 2, 4, 8}로 초기화

크기가 3인 배열 b를 생성하고, 요소 {}로 초기화

정수 i, sum을 각각 1, 0으로 초기화

포인터 p1 정의

 

p1 = a + 1 // 포인터 p1은 a + 1의 주소를 가리킨다

b[0] = *(a + 1) - a[0] // b[0] = 2 - 0 = 2

sum = sum + b[0] + a[1] // sum = 0 + 2 + 2 = 4

 

p1 = a + 2 // 포인터 p1은 a + 2의 주소를 가리킨다

b[1] = *(a + 2) - a[1] // b[1] = 4 - 2 = 2

sum = sum + b[1] + a[2] // sum = 4 + 2 + 4 = 10

 

p1 = a + 3 // 포인터 p1은 a + 3의 주소를 가리킨다

b[2] = *(a + 3) - a[2] // b[2] = 8 - 4 = 4

sum = sum + b[1] + a[2] // sum = 10 + 4 + 8 = 22

 

Index	0	1	2
b	2	2	4

 

[출력결과]

22

 

---

 

< Java >

# 1. 다음 자바 코드에 알맞는 출력값을 작성하시오.

[소스코드]

public class good 
{
    public void execute() 
    {
        int i = 3;
        int k = 1;

        switch (i) 
        {
            case 1:
                k += 1;
            case 2:
                k++;
            case 3:
                k = 0;
            case 4:
                k += 3;
            case 5:
                k -= 10;
            default:
                k--;
        }
        System.out.print(k);
    }

    public static void main(String[] args) 
    {
        good a = new good();
        a.execute();
    }
}

good 클래스 생성자를 호출해 새로운 객체 a를 생성

 execute 함수를 호출

 

정수 i, k를 각각 3, 1로 초기화

switch(3) 이므로 case3부터 시작

case 3:

    k = 0으로 초기화

case 4:

    k = 3으로 초기화

case 5:

    k = -7로 초기화

default:

    k--(후위 연산)

k = -8로 초기화

 

[출력결과]

-8

 

# 2. 다음 자바코드에서 알맞는 출력값을 작성하시오.

[소스코드]

public class good 
{
    int a;
    
    public good(int a) 
    {
        this.a = a;
    }
    
    int func() 
    {
        int b = 1;
        for (int i = 1; i < a; i++) 
        {
            b = a * i + b;
        }
        return a + b;
    }

    public static void main(String[] args) 
    {
        good obj = new good(3);
        obj.a = 5;
        int b = obj.func();
        System.out.print(obj.a + b);
    }
}

good 클래스의 생성자를 호출해 새로운 객체 생성하고 파라미터에 3을 전달

obj.a = 5; // good 클래스의 정수 a를 5로 초기화

정수 b를 func() 함수를 호출해 56으로 초기화

obj.a + b = 61

 

[출력결과]

61

 

---

 

< Python >

# 1. 다음은 파이썬 코드이다. 알맞는 출력값을 작성하시오.

[소스코드]

a = "REMEMBER NOVEMBER"
b = a[:3] + a[12:16];
c = "R AND %s" % "STR";
print(b+c);

이 문제는 인덱스 슬라이싱 관련 문제이다

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
R	E	M	E	M	B	E	R		N	O	V	E	M	B	E	R

a[ : 3]은 0번 인덱스부터 2번 인덱스까지 요소를 추출 // REM

a[12 : 16]은 12번 인덱스부터 15번 인덱스까지 요소를 추출 // EMBE

b = "REMEMBE"

c는 "R AND %s" % "STR" 문자열 포맷팅 형식이다

b+c 결과를 출력

 

[출력결과]

REMEMBER AND STR