2025년 실기 복원 문제

1회차

C언어 아스키 코드

#include <stdio.h>
 
char Data[5] = {'B', 'A', 'D', 'E'};
char c;
 
int main(void) {
    int i;
    char temp, temp2;
 
    c = 'C';
    // 첫 번째 출력
    printf("%d\n", Data[3] - Data[1]);
 
    // 첫 번째 `for`
    for (i = 0; i < 4; ++i) {
        if (Data[i] > c)
            break;
    }
 
    // 배열 요소 교체
    temp = Data[i];
    Data[i] = c;
    ++i;
 
    // 두 번째 `for`
    for (; i < 5; ++i) {
        temp2 = Data[i];
        Data[i] = temp;
        temp = temp2;
    }
 
    for (i = 0; i < 5; ++i)
        printf("%c", Data[i]);
 
    return 0;
}

# 예상 출력
4
BACDE

첫 번째 출력
- "%d\n" → 정수형 출력 및 줄바꿈 문자
- Data[3] - Data[1] → 아스키 코드 연산으로 결과는 4(69('D') - 65('A'))
첫 번째 for 문
- 아스키 코드 비교 연산을 통해 i=2 일 때 'C' < 'D' 이므로 break 구문 실행
배열 요소 교체
- temp 에 'D' 를 할당하고 Data[2] 를 'C' 로 교체 후 i 는 3 으로 증가
두 번째 for
- temp2 에 Data[i](현재 순회 요소)를 저장하고 temp 를 해당 인덱스 요소로 교체하는 것을 반복

Java `try ... catch`

public class DivisionDemo {
    public static void main(String[] args) {
        try {
            int a = 5, b = 0;
            System.out.print(a / b);
        } catch (ArithmeticException e) {
            System.out.print("출력1");
        } catch (NullPointerException e) {
            System.out.print("출력2");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.print("출력3");
        } catch (Exception e) {
            System.out.print("출력4");
        } finally {
            System.out.print("출력5");
        }
    }
}

# 예상 출력
출력1출력5

java.lang.ArithmeticException

정수형(int) 연산에서 0 으로 나누면 발생하는 런타임 예외에 해당하며, 컴파일은 잘 되지만 실행 중에 프로그램이 중단된다.

# 오류 예시
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at DivisionDemo.main(DivisionDemo.java:3)

예외 클래스	설명
`ArithmeticException`	0으로 나누기
`NullPointerException`	`null` 객체 접근
`ArrayIndexOutOfBoundsException`	배열 인덱스 초과
`Exception`	모든 예외의 최상위 클래스

Java `static`

class Parent {
    static int total = 0;
    int v = 1;
 
    public Parent() {
        total += (++v);
        showValue();
    }
    public void showValue() {
        total += total;
    }
}
 
class Child extends Parent {
    int v = 10;
 
    public Child() {
        v += 2;
        total += (v++);
        showValue();
    }
    @Override
    public void showValue() {
        total += total * 2;
    }
}
 
class Main {
    public static void main(String[] args) {
        new Child();
        System.out.println(Parent.total);
    }
}

# 예상 출력
54

static

static 키워드는 자바에서 클래스 단위로 공유되는 멤버를 선언할 때 사용하며, 객체 생성과 관계 없이 메모리에 한 번 만들어지고 모든 객체가 공유한다. 자식 클래스도 동일.

클래스의 자동 호출 규칙

자바에서 자식 클래스 생성자가 호출되면 반드시 부모 생성자가 먼저 호출된다. 즉, 자식 생성자 첫 줄에서 암묵적으로 super() 가 삽입되어 실행되는 것과 같다.

만약 부모 생성자에 매개변수가 있다면, 자식 생성자에서 명시적으로 super(인자) 호출을 해야 한다. 명시적 호출이 없다면 컴파일 에러가 발생한다.

역순으로 코드 해석 진행
Child 기본 생성자 호출
- 부모 클래스인 Parent 의 생성자가 우선적으로 자동 호출
Parent 기본 생성자 호출
- total 에 2(++v)를 더해 total 은 2
- 이후 showValue() 를 실행하는데 자식 클래스인 Child 에서 재정의했으므로 자식 클래스의 showValue() 를 실행하여 2 += 2 * 2 가 되어 total 은 6
Child 생성자 진입
- v += 2 를 통해 v 는 12 가 됨
- total += (v++) 를 통해 total 에 12 가 더해져 18 이 되고 v 는 다음 줄에 13 이 됨
- 이후 showValue() 를 실행하여 total += total * 2 가 실행되어 18 = 18 * 2 이고 최종적으로 total 은 54
마지막으로 정적 변수를 출력하여 54 출력

Java 재귀함수

public class Maximal {
    static int func(int[] a, int st, int end) {
        if (st >= end) return 0;
        int mid = (st + end) / 2;
        return a[mid] + Math.max(func(a, st, mid), func(a, mid + 1, end));
    }
 
    public static void main(String[] args) {
        int[] values = {3, 5, 8, 12, 17};
        System.out.println(func(values, 0, values.length -1));
    }
}

# 예상 호출
20

재귀함수는 호출 구조와 탈출 조건을 명확히 파악해야 한다.
a[2] + Math.max(a[1] + Math.max(a[0], 0), a[3]) (탈출 처리된 Math.max 제외)
각 인덱스 요소로 변환하면 8 + Math.max(5 + 3, 12)
최종적으로 반환 값은 20

Java 오버로딩

public class Weekendcode {
    public static void main(String[] args) {
        System.out.println(calc("5"));
    }
 
    static int calc(int value) {
        if (value <= 1) return value;
        return calc(value - 1) + calc(value - 2);
    }
 
    static int calc(String str) {
        int value = Integer.valueOf(str);
        if (value <= 1) return value;
        return calc(value - 1) + calc(value - 3);
    }
}

# 예상 출력
4

오버로딩(Overloading)

같은 이름의 여러 메서드를 매개변수의 타입이나 개수로 구분하여 정의하는 것

String 타입의 인자를 받는 두 번째 calc 메서드 실행 → calc("5") = calc(4) + calc(2)
다음부터는 인자 타입이 숫자이기에 첫 번째 calc 메서드 실행
- 두 번째 calc() 재귀 규칙은 최종적으로 인자인 value - 1 반환
최종적으로 반환값은 4

Python Tree

class Node:
    def __init__(self, value):
        self.value = value
        self.children = []
 
def tree(li):
    nodes = [Node(i) for i in li]
    for i in range(1, len(li)):
        nodes[(i - 1) // 2].children.append(nodes[i])
    return nodes[0]
 
def calc(node, level=0):
    return node.value if level % 2 else 0 + sum(calc(n, level +1) for n in node.children) if node else 0
 
li = [3, 5, 8, 12, 15, 17, 21]
root = tree(li)
print(calc(root))

# 예상 출력
13

파이썬 삼항연산자

[참인_경우_반환] if [조건] else [거짓인_경우_반환]

각 노드로 구성된 트리 객체를 만드는 함수 tree
tree(li) 의 반환값은 Node(3) 이다
calc 함수는 삼항연산자를 포함하며, 아래와 같이 해석된다.
- level 이 짝수인 경우 0 + sum(calc(n, level +1) for n in node.children) 를 실행하라
  - children 배열의 노드들로 level 을 증가시켜 재귀 실행
  - 0 + 는 단순 숫자로 만들기 위함
- level 이 홀수인 경우 node.value 반환
- 뒤에 있는 if node else 0 은 node 가 거짓인 경우이기에 노드가 있으면 무조건 반환
이후 흐름은 다음과 같다.
- calc(Node(3), 0) 는 level 이 짝수이기에 calc(Node(5), 1) + calc(Node(8), 1) 이다.
- 이때 level 은 홀수기에 각 node.value 를 더하면 13

C언어 구조체와 연결리스트

#include <stdio.h>
#include <stdlib.h>
 
typedef struct Data {
    int value;
    struct Data *next;
} Data;
 
Data* insert(Data* head, int value) {
    Data *new_node = (Data*)malloc(sizeof(Data));
    if (!new_node) return head;
    new_node -> value = value;
    new_node -> next = head;
    return new_node;
}
 
Data* reconnect(Data* head, int disconnect_count) {
    if (head == NULL || head -> value == disconnect_count)
        return head;
 
    Data *prev = head;
    Data *curr = head -> next;
 
    while (curr && curr -> value != disconnect_count) {
        prev = curr;
        curr = curr -> next;
    }
    if (curr == NULL) return head;
 
    prev -> next = curr -> next;
    curr -> next = head;
    return curr;
}
 
int main(void) {
    Data *head = NULL;
    for (int i = 1; i <= 5; ++i)
    head = insert(head, i);
 
    head = reconnect(head, 3);
 
    for (Data *curr = head; curr; curr = curr -> next)
    printf("%d", curr -> value);
    printf("\n");
 
    while (head) {
        Data *tmp = head;
        head = head -> next;
        free(tmp);
    }
    return 0;
}

2025년 실기 복원 문제

On this page