[2024년 1회]

< C++ >

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

[소스코드]

#include <stdio.h>

int main() 
{
    int v1 = 0, v2 = 35, v3 = 29;

    if (v1 > v2 ? v2 : v1) 
        v2 = v2 << 2;
    else
        v3 = v3 << 2;

    printf("%d", v2 + v3);

    return 0;
}

정수 v1, v2, v3를 0, 35, 29로 초기화

조건문 v1 > v2 ? v2 : v1는 삼항 연산자인데, 삼항 연산자란 → 조건식? 참일 때 값 : 거짓일 때 값

v1이 v2보다 작으므로 거짓이며 v1값을 사용

조건문은 거짓이 되므로, else문으로 넘어감

v3 = v3 << 2

v3값을 좌로 2비트 이동

29 = 0001 1101

0001 1101 << 2 → 0111 0100 // 10진수값으로 116

35 + 116 = 151

 

[출력결과]

151

 

# 2. 다음은 C언어에 대한 문제이다. 알맞는 출력 값을 작성하시오.

[소스코드]

#include <stdio.h>
#include <string.h>

void reverse(char* str) 
{
    int len = strlen(str);
    char* p1 = str;
    char* p2 = str + len - 1;

    while (p1 < p2) 
    {
        char t = *p1;
        *p1 = *p2;
        *p2 = t;
        p1++;
        p2--;
    }
}

int main()
{
    char str[100] = "ABCDEFGH";

    reverse(str);

    int len = strlen(str);

    for (int i = 1; i < len; i += 2)
    {
        printf("%c", str[i]);
    }
    printf("\n");

    return 0;
}

문자열 리터럴을 배열 str에 초기화

reverse(str)

정수 len은 배열의 길이

포인터 p1은 str배열의 첫 번째 문자의 주소

포인터 p2는 str배열의 마지막 문자의 주소

반복문을 통해 배열str의 문자열 리터럴 순서를 뒤집음

배열 str은 "HGFEDCBA"

 

메인함수의 반복문을 보면 인덱스 1번부터 시작해서 3 5 7처럼 2씩 커지는 인덱스를 출력

 

[출력결과]

GECA

 

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

[소스코드]

#include <stdio.h>

struct BankAcc
{
    int accNum;
    double bal;
};

double sim_pow(double base, int year) 
{
    int i;
    double r = 1.0;

    for (i = 0; i < year; i++) 
    {
        r = r * base;
    }

    return r;
}

void initAcc(BankAcc* acc, int x, double y) 
{
    acc->accNum = x;
    acc->bal = y;
}

void xxx(BankAcc* acc, double* en) 
{
    if (*en > 0 && *en < acc->bal) 
        acc->bal = acc->bal - *en;
    else 
        acc->bal = acc->bal + *en;
}

void yyy(BankAcc* acc) 
{
    acc->bal = acc->bal * sim_pow((1 + 0.1), 3);
}

int main() 
{
    BankAcc myAcc;
    initAcc(&myAcc, 9981, 2200.0);
    double amount = 100.0;
    xxx(&myAcc, &amount);
    yyy(&myAcc);
    printf("%d and %.2f", myAcc.accNum, myAcc.bal);

    return 0;
}

이 문제는 은행의 금리 계산 문제다

BankAcc myAcc // 구조체 BankAcc myAcc구조체 변수 선언

initAcc(&myAcc, 9981, 2200.0) // initAcc함수의 파라미터에 구조체 myAcc의 메모리주소, 정수 9981, 더블 2200.0을 전달

acc->accNum = x // myAcc 구조체의 accNum을 9981로 초기화

acc->bal = y // myAcc 구조체의 bal을 2200.0으로 초기화

amount를 100으로 초기화

xxx(&myAcc, &amount) // xxx함수의 파라미터에 구조체 myAcc의 메모리주소, amount의 메모리주소를 전달

if (*en > 0 && *en < acc->bal) // if ( 1 && 1)

acc->bal = acc->bal - *en // myAcc 구조체의 bal을 2200.0 - 100.0으로 초기화

yyy(&myAcc) // yyy함수의 파라미터에 구조체 myAcc의 메모리주소를 전달

acc->bal = acc->bal * sim_pow(1 + 0.1), 3)

myAcc 구조체의 bal을 2100.0 * (sim_pow((1 + 0.1), 3))으로 초기화

sim_pow(1 + 0.1), 3)

정수 i 선언

더블 r을 1.0으로 초기화

i = 0일 때

r = r * (1.1)

r = 1.1

 

i = 1일 때

r = r * (1.1)

r = 1.21

 

i = 2일 때

r = r * (1.1)

r = 1.331

 

2100.0 * 1.331 = 2795.1

 

[출력결과]

9981 and 2795.10

 

# 4. 다음 C언어 코드의 알맞은 출력 값을 작성하시오.

[소스코드]

#include<stdio.h>
#include<ctype.h>

int main() 
{
    const char* p = "It is 8";
    char result[100];
    int i;

    for (i = 0; p[i] != '\0'; i++) 
    {
        if (isupper(p[i]))
            result[i] = (p[i] - 'A' + 5) % 25 + 'A';
        else if (islower(p[i]))
            result[i] = (p[i] - 'a' + 10) % 26 + 'a';
        else if (isdigit(p[i]))
            result[i] = (p[i] - '0' + 3) % 10 + '0';
        else if (!(isupper(p[i]) || islower(p[i]) || isdigit(p[i])))
            result[i] = p[i];
    }
    result[i] = '\0';
    printf("%s\n", result);

    return 0;
}

위 문제는 시저암호 문제다

문제를 풀기에 앞서 알아야 할 것은 각 알파벳의 ASCII값을 알아야 한다

 

포인터 p를 "It is 8"로 초기화

배열 result 선언

정수 i 선언

 

ctype.h의 isupper, islower, isdigit은 순서대로 대문자, 소문자, 숫자인지를 확인하는 함수다

p[0]은 대문자 I이므로 첫 번째 조건문에 해당

result배열 0번 인덱스를 ('I' - 'A' + 5) % 25 + 'A'로 초기화 // ('I' - 'A' + 5) % 25 + 'A' = N

p[1]은 소문자 t이므로 두 번째 조건문에 해당

result배열 1번 인덱스를 ('t' - 'a' + 10) % 26 + 'a'로 초기화 // ('t' - 'a' + 10) % 26 + 'a' = d

p[2]는 공백이므로 네 번째 조건문에 해당

result[2] = p[2]

p[3]은 소문자 i이므로 두 번째 조건문에 해당

result배열 3번 인덱스를 ('i' - 'a' + 10) % 26 + 'a'로 초기화 // ('i' - 'a' + 10) % 26 + 'a' = s

p[4]는 소문자 s이므로 두 번째 조건문에 해당

result배열 4번 인덱스를 ('s' - 'a' + 10) % 26 + 'a'로 초기화 // ('s' - 'a' + 10) % 26 + 'a' = c

p[5]는 공백이므로 네 번째 조건문에 해당

result[5] = p[5]

p[6]는 숫자 8이므로 세 번째 조건문에 해당

result배열 6번 인덱스를 ('8' - '0' + 3) % 10 + '0'으로 초기화 // ('8' - '0' + 3) % 10 + '0' = 1

 

[출력결과]

Nd sc 1

 

---

 

< Java >

# 1. 다음 Java 코드에서 알맞은 출력 값을 작성하시오.

[소스코드]

class Connection
{
    private static Connection _inst = null;
    private int count = 0;
    static public Connection get() 
    {
        if (_inst == null) 
        {
            _inst = new Connection();
            return _inst;
        }
        return _inst;
    }
    public void count() 
    {
        count++;
    }
    public int getCount() 
    {
        return count;
    }
}
public class good 
{
    public static void main(String[] args) 
    {
        Connection conn1 = Connection.get();
        conn1.count();
        Connection conn2 = Connection.get();
        conn2.count();
        Connection conn3 = Connection.get();
        conn3.count();
        conn1.count();
        System.out.print(conn1.getCount());
    }
}

싱글톤 패턴을 사용해 Connection.get()으로 접근해서 생성자를 생성하는 방식이다

conn1을 생성할 때 새로운 객체가 생성되고 count++

conn2를 생성할 때 Connection클래스의 인스턴스에 null이 아닌 형태로 존재하므로 _inst를 그대로 리턴하여 동일한 객체를 가지게 되고, count++

conn3도 마찬가지로 동일한 객체를 갖게 되므로, count++

마지막으로 conn1.count()를 호출하므로, count++

 

[출력결과]

4

 

# 2. 아래 JAVA언어 코드의 실행 순서를 중복 번호 없이 작성하시오.

[소스코드]

class Parent
{
    int x, y;

    Parent(int x, int y)
    {
    // 1
        this.x = x;
        this.y = y;
    }

    int getT()
    {
    // 2
        return x * y;
    }
}

class Child extends Parent
{
    int x;

    Child(int x) {
    // 3
        super(x + 1, x);
        this.x = x;
    }

    int getT(int n)
    {
    // 4
        return super.getT() + n;
    }
}

class good
{
    public static void main(String[] args)
    {
    // 5
        Parent parent = new Child(3); // 6
        System.out.println(parent.getT()); // 7
    }
}

실행 순서 : 5 → ( ) → ( ) → ( ) → ( ) → ( )

 

먼저 main을 먼저 실행하기 때문에 5가 처음으로 실행

그다음 6을 실행하여 Child클래스의 생성자를 호출하고, 파라미터에 3을 전달하여 새로운 객체 생성

생성자가 호출되었으므로 3이 실행됨

super(x + 1, x)로 Parent 생성자 호출

7이 실행되고, parent.getT()를 호출

2가 실행됨

 

최종 실행 순서

5 → 6 → 1 → 3 → 7 → 2

 

# 3. 다음 Java 코드를 보고 알맞은 출력 값을 작성하시오.

[소스코드]

class classOne
{
    int a, b;

    public classOne(int a, int b)
    {
        this.a = a;
        this.b = b;
    }

    public void print()
    {
        System.out.println(a + b);
    }

}
class classTwo extends classOne
{
    int po = 3;

    public classTwo(int i)
    {
        super(i, i + 1);
    }

    public void print()
    {
        System.out.println(po * po);
    }
}

public class good
{
    public static void main(String[] args)
    {
        classOne one = new classTwo(10);
        one.print();
    }
}

classOne타입 one을 classTwo클래스 생성자를 호출하고 파라미터에 10을 전달하여 새로운 객체 생성

super(10, 11) // 부모 클래스인 classOne의 생성자를 호출하여 a, b를 10, 11로 초기화

one.print() // classTwo 변수인 정수 po를 po * po

 

[출력결과]

9

 

---

 

< Python >

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

[소스코드]

a = ["Seoul", "Kyeonggi", "Incheon", "Daejun", "Daegu", "Busan"]
str = "S"

for i in a:
  str = str + i[1]

print(str)

str을 S로 초기화

 

반복문을 순회하면서 배열 a의 요소들의 1번째 인덱스 문자를 str에 추가

"Seynaau"

 

[출력결과]

Seynaau