[2025년 2회] 정보처리기사 실기 - 문제 해설

[2025년 2회] 정보처리기사 실기 복원 문제 해설

문제 1. 파일 구조 - 인덱스 접근 방법

문제

데이터베이스의 물리 설계 시, 레코드에 접근하는 방법은 순차 접근 방법, [ ] 방법, 해싱 방법 등이 있다.

이 중 [ ] 방법은 레코드의 키 값과 포인터를 쌍으로 묶어 저장하며 검색 시 키 값을 기준으로 빠르게 탐색할 수 있도록 설계되어 있다.

이 방식은 검색 속도가 빠르며 <키 값, 포인터> 쌍으로 구성된 자료 구조를 사용하여 해당 키가 가리키는 주소를 통해 원하는 레코드를 직접 찾을 수 있다.

접근 방법 표:
| 접근 방법 | 설명 |
|---------|------|
| 순차 접근 | 레코드를 처음부터 하나씩 검사 |
| [ ] 접근 | 키-값 쌍으로 구성되어 빠르게 검색 |
| 해싱 접근 | 해시 함수를 이용해 직접 주소 계산 후 접근 |

정답

인덱스(Index) 또는 색인

해설

파일 접근 방법 비교:

접근 방법	설명	장점	단점
순차 접근	레코드를 처음부터 순서대로 검사	구현이 간단	검색 속도 느림
인덱스 접근	키 값과 포인터 쌍으로 구성된 인덱스 사용	검색 속도 빠름	인덱스 저장 공간 필요
해싱 접근	해시 함수로 직접 주소 계산	매우 빠른 접근	충돌 처리 필요

인덱스 접근 방법 구조:

[인덱스 테이블]
키 값    | 포인터
---------|--------
1001     | → 레코드1 주소
1002     | → 레코드2 주소
1003     | → 레코드3 주소
...

인덱스 접근 과정:

1. 인덱스 테이블에서 키 값 검색
2. 해당 키의 포인터 확인
3. 포인터가 가리키는 주소로 직접 이동
4. 레코드 접근

인덱스의 장점:

• 빠른 검색 속도 (O(log n))
• 정렬된 키 값으로 범위 검색 가능
• 직접 주소 접근 가능

---

문제 2. 데이터베이스 - Attribute

문제

릴레이션(Relation)에서 열(Column)을 의미하며 데이터 항목의 속성(Attribute) 또는 특성을 나타낸다.

각 열은 고유한 이름을 가지며 특정 도메인(Domain)에서 정의된 값을 갖는다.

예를 들어 "학생" 릴레이션에서 학번, 이름, 전공 등은 각각 하나의 열이며 이 열들은 학생의 고유한 속성을 나타낸다.

이 개념은 파일 구조에서의 필드(Field)에 해당하며 릴레이션에서 행(Row, Tuple)의 구성 요소가 된다.

보기: ㄱ. Cardinality, ㄴ. Domain, ㄷ. Attribute, ㅁ. Degree, ㅂ. Schema, ㅅ. Tuple

정답

ㄷ. Attribute (속성)

해설

릴레이션 구성 요소:

용어	설명	예시
Attribute	릴레이션의 열(Column), 속성	학번, 이름, 전공
Tuple	릴레이션의 행(Row), 레코드	(1001, 김철수, 컴퓨터공학)
Domain	속성이 가질 수 있는 값의 범위	학번: 1000~9999
Cardinality	릴레이션의 행 수	학생 수
Degree	릴레이션의 열 수	속성의 개수
Schema	릴레이션의 구조 정의	(학번, 이름, 전공)

릴레이션 구조:

학생 릴레이션
┌────────┬────────┬──────────┐
│ 학번   │ 이름   │ 전공     │  ← Attribute (속성)
├────────┼────────┼──────────┤
│ 1001   │ 김철수 │ 컴공     │  ← Tuple (튜플)
│ 1002   │ 이영희 │ 전자     │  ← Tuple
│ 1003   │ 박민수 │ 기계     │  ← Tuple
└────────┴────────┴──────────┘

용어 비교:

• 파일 구조: 필드(Field) = 릴레이션: 속성(Attribute)
• 파일 구조: 레코드(Record) = 릴레이션: 튜플(Tuple)

---

문제 3. 정보보안 - SSH

문제

원격 접속과 관련된 보안 프로토콜이며 암호화된 통신을 제공하는 보안 접속용 프로토콜이다.

공개키 기반의 인증 방식을 사용하며 암호화된 데이터 전송을 지원한다.

주로 원격 서버에 안전하게 접속할 때 사용되며 기본 포트 번호는 22번이다.

Telnet의 보안 취약점을 보완한 대안으로 널리 사용된다.

정답

SSH (Secure Shell)

해설

SSH 특징:

특징	설명
목적	원격 서버에 안전하게 접속
암호화	모든 통신 데이터 암호화
인증	공개키 기반 인증
포트	기본 포트 22번
대체	Telnet의 보안 취약점 보완

SSH vs Telnet 비교:

항목	Telnet	SSH
암호화	❌ 평문 전송	✅ 암호화 전송
보안	취약	안전
포트	23번	22번
인증	비밀번호만	공개키/비밀번호

SSH 통신 과정:

[클라이언트]                    [서버]
    │                             │
    ├─ SSH 연결 요청 ────────────→│
    │                             │
    │←── 공개키 전송 ──────────────┤
    │                             │
    ├─ 암호화된 세션 키 전송 ──────→│
    │                             │
    │←── 암호화된 통신 시작 ───────┤
    │                             │
    └─ 암호화된 데이터 교환 ────────┘

SSH 주요 기능:

• 원격 로그인
• 파일 전송 (SCP, SFTP)
• 포트 포워딩
• X11 포워딩

---

문제 4. 스케줄링 알고리즘

문제

(1) CPU burst 시간이 짧은 프로세스를 우선적으로 처리하는 스케줄링 방식이다. "Shortest Next CPU Burst"라고도 불리며 선점형 또는 비선점형으로 구현될 수 있다.

(2) 위의 스케줄링 방식을 선점형으로 구현한 형태로 실행 중인 프로세스보다 더 짧은 burst 시간을 가진 프로세스가 도착하면 현재 CPU를 선점한다.

정답

(1) SJF (Shortest Job First)
(2) SRT (Shortest Remaining Time)

해설

스케줄링 알고리즘 비교:

알고리즘	설명	타입	특징
SJF	가장 짧은 작업을 먼저 처리	비선점/선점	CPU burst 시간 기준
SRT	남은 실행 시간이 가장 짧은 프로세스 우선	선점	SJF의 선점형 버전
FCFS	도착 순서대로 처리	비선점	공정하지만 비효율적
RR	시간 할당량을 순환 배분	선점	응답 시간 개선

SJF (Shortest Job First) 동작:

프로세스 | 도착 시간 | CPU Burst
---------|----------|----------
P1       | 0        | 6
P2       | 1        | 3
P3       | 2        | 8
P4       | 3        | 2

SJF 스케줄링:
[P1:6] [P4:2] [P2:3] [P3:8]

SRT (Shortest Remaining Time) 동작:

시간 0: P1 도착 (남은 시간: 6)
시간 1: P2 도착 (남은 시간: 3) → P1 선점, P2 실행
시간 2: P3 도착 (남은 시간: 8) → P2 계속 실행
시간 3: P4 도착 (남은 시간: 2) → P2 선점, P4 실행
...

SJF vs SRT:

구분	SJF	SRT
타입	비선점/선점	선점
기준	전체 CPU burst	남은 CPU burst
응답성	낮음	높음
문맥 교환	적음	많음

---

문제 5. Java 참조와 값 전달

문제 코드

public class Main {
    public static void change(String[] data, String s){
        data[0] = s;
        s = "Z";
    }

    public static void main(String[] args) {
        String data[] = { "A" };
        String s = "B";

        change(data, s);
        System.out.print(data[0] + s);
    }
}

정답

BB

해설

실행 과정:

1. main() 함수:

   • String data[] = { "A" } → 배열 생성
   • String s = "B" → 문자열 변수

2. change() 함수 호출:

   • change(data, s) → 배열 참조와 문자열 값 전달

   매개변수:

   • data → 배열의 참조 (원본 배열 참조)
   • s → 문자열 값 "B" (복사본)

3. change() 함수 내부:

   • data[0] = s → data[0] = "B" (원본 배열 수정)
   • s = "Z" → 지역 변수만 변경 (원본 변수 영향 없음)

4. main() 함수로 복귀:

   • data[0] = "B" (변경됨)
   • s = "B" (변경 안됨)

5. 출력:

   • data[0] + s = "B" + "B" = "BB"

메모리 상태:

main() 함수:
data → [0: "A"]
s → "B"

change() 함수 호출 후:
data → [0: "B"]  (원본 수정됨)
s → "B"          (원본 변경 안됨)

핵심 개념:

• 배열: 참조 전달 (원본 수정 가능)
• 기본 타입/문자열: 값 전달 (복사본, 원본 영향 없음)
• Java는 항상 값 전달, 단 객체 참조는 참조 값이 전달됨

---

문제 6. IP 주소와 서브넷 마스크

문제

호스트의 IP 주소가 223.13.234.132이고 서브넷 마스크가 255.255.255.192일 때 다음 물음에 답하시오.

이 호스트가 속한 네트워크 주소는 223.13.234.( ① )이다.

이 네트워크에서 사용 가능한 호스트 수는 ( ② )개이다.
(단, 네트워크 주소와 브로드캐스트 주소는 제외한다.)

정답

① 128
② 62

해설

계산 과정:

1. 서브넷 마스크 분석:

   • 255.255.255.192 = 11111111.11111111.11111111.11000000
   • 네트워크 비트: 26비트
   • 호스트 비트: 6비트

2. IP 주소와 서브넷 마스크 AND 연산:

   IP 주소:     223.13.234.132 = 11011111.00001101.11101010.10000100
   서브넷 마스크: 255.255.255.192 = 11111111.11111111.11111111.11000000
   AND 연산:    ─────────────────────────────────────────────────
   네트워크 주소: 223.13.234.128 = 11011111.00001101.11101010.10000000

3. 네트워크 주소:

   • 223.13.234.128 → ① = 128

4. 사용 가능한 호스트 수:

   • 호스트 비트: 6비트
   • 총 호스트 수: 2⁶ = 64개
   • 사용 가능: 64 - 2 = 62개 (네트워크 주소, 브로드캐스트 주소 제외)

네트워크 범위:

항목	주소
네트워크 주소	223.13.234.128
첫 번째 호스트	223.13.234.129
마지막 호스트	223.13.234.190
브로드캐스트 주소	223.13.234.191

서브넷 마스크 표:

서브넷 마스크	네트워크 비트	호스트 비트	사용 가능 호스트
/24 (255.255.255.0)	24	8	254
/25 (255.255.255.128)	25	7	126
/26 (255.255.255.192)	26	6	62
/27 (255.255.255.224)	27	5	30

---

문제 7. 디자인 패턴 - Proxy

문제

어떤 객체에 대한 접근을 제어하거나 추가적인 기능을 부여하기 위해 해당 객체의 대리 객체를 사용하는 방식의 디자인 패턴이다.

실제 객체에 대한 접근 전에 필요한 작업을 수행할 수 있으며 실제 객체의 생성을 지연시켜 메모리와 자원을 절약할 수 있다.

또한, 실제 객체를 감추어 정보은닉을 강화할 수 있다는 장점이 있다.

정답

Proxy (프록시 패턴)

해설

Proxy 패턴 특징:

특징	설명
목적	객체 접근 제어 및 기능 추가
구조	실제 객체의 대리 객체 사용
장점	지연 로딩, 접근 제어, 정보 은닉

Proxy 패턴 구조:

[클라이언트] → [Proxy] → [RealSubject]
                  │
                  ├─ 접근 제어
                  ├─ 지연 로딩
                  └─ 추가 기능

Proxy 패턴 종류:

종류	설명
Virtual Proxy	실제 객체 생성을 지연
Remote Proxy	원격 객체에 대한 로컬 대리
Protection Proxy	접근 권한 제어
Cache Proxy	결과 캐싱

Proxy 패턴 예시:

// 실제 객체
class RealImage {
    void display() { ... }
}

// 프록시 객체
class ProxyImage {
    private RealImage realImage;

    void display() {
        if (realImage == null) {
            realImage = new RealImage(); // 지연 로딩
        }
        realImage.display();
    }
}

Proxy 패턴 장점:

• 실제 객체 생성 지연 (메모리 절약)
• 접근 제어 및 보안 강화
• 추가 기능 부여 (로깅, 캐싱 등)
• 정보 은닉

---

문제 8. 웹 기술 - AJAX

문제

( )은/는 웹 페이지 전체를 다시 불러오지 않고 JavaScript와 XML(또는 JSON)을 이용하여 일부 콘텐츠만 비동기적으로 갱신할 수 있는 기술이다.

( )은/는 HTML만으로는 구현하기 어려운 동적인 기능들을 가능하게 하여 사용자가 웹 페이지와 보다 자유롭게 상호작용할 수 있도록 해주는 웹 개발 기법이다.

정답

AJAX (Asynchronous JavaScript and XML)

해설

AJAX 특징:

특징	설명
목적	페이지 전체 새로고침 없이 일부만 갱신
방식	비동기 통신
기술	JavaScript + XML/JSON
효과	사용자 경험 향상

전통적인 웹 vs AJAX:

전통적인 웹:

[사용자 요청] → [서버] → [전체 페이지 응답] → [페이지 전체 새로고침]

AJAX:

[사용자 요청] → [서버] → [데이터만 응답] → [일부 콘텐츠만 갱신]

AJAX 동작 과정:

1. 사용자 이벤트 발생
   ↓
2. JavaScript로 XMLHttpRequest 생성
   ↓
3. 서버에 비동기 요청 전송
   ↓
4. 서버에서 데이터 처리
   ↓
5. XML/JSON 데이터 응답
   ↓
6. JavaScript로 DOM 조작
   ↓
7. 페이지 일부만 갱신

AJAX 장점:

• 페이지 전체 새로고침 없음
• 빠른 응답 속도
• 사용자 경험 향상
• 서버 부하 감소

AJAX 사용 예시:

• 실시간 검색 자동완성
• 댓글 추가/삭제
• 좋아요 버튼
• 무한 스크롤

---

문제 9. Java 람다와 예외 처리

문제 코드

public class Main {

    static interface F {
        int apply(int x) throws Exception;
    }

    public static int run(F f) {
        try {
            return f.apply(3);
        } catch (Exception e) {
            return 7;
        }
    }

    public static void main(String[] args) {

        F f = (x) -> {
            if (x > 2) {
                throw new Exception();
            }
            return x * 2;
        };

        System.out.print(run(f) + run((int n) -> n + 9));
    }

}

정답

19

해설

실행 과정:

1. 첫 번째 run(f) 호출:

   • f.apply(3) 실행
   • x = 3 > 2 → true
   • throw new Exception() 실행
   • 예외 발생 → catch 블록 실행
   • return 7

2. 두 번째 run((int n) -> n + 9) 호출:

   • 람다 함수: n + 9
   • f.apply(3) → 3 + 9 = 12
   • 예외 없음 → return 12

3. 최종 계산:

   • run(f) + run((int n) -> n + 9)
   • = 7 + 12
   • = 19

실행 흐름:

run(f):
  f.apply(3)
    → x = 3
    → if (3 > 2) → true
    → throw new Exception()
    → catch 블록
    → return 7

run((int n) -> n + 9):
  f.apply(3)
    → 3 + 9 = 12
    → return 12

결과: 7 + 12 = 19

핵심 개념:

• 람다 표현식: (매개변수) -> 표현식
• 함수형 인터페이스: 단일 추상 메서드를 가진 인터페이스
• 예외 처리: try-catch로 예외 처리

---

문제 10. Java 상속과 다형성

문제 코드

public class Main{

    public static class Parent {

        public int x(int i) { return i + 2; }
        public static String id() { return "P";}

    }

    public static class Child extends Parent {

        public int x(int i) { return i + 3; }
        public String x(String s) { return s + "R"; }
        public static String id() { return "C"; }

    }

    public static void main(String[] args) {

        Parent ref = new Child();
        System.out.println(ref.x(2) + ref.id());

    }

}

정답

5P

해설

실행 과정:

1. 객체 생성:

   • Parent ref = new Child() → Parent 타입, Child 인스턴스

2. ref.x(2) 호출:

   • ref는 Parent 타입이지만 실제 객체는 Child
   • 메서드 오버라이딩: 실제 객체의 메서드 호출
   • Child의 x(int i) 실행
   • 2 + 3 = 5

3. ref.id() 호출:

   • id()는 static 메서드
   • static 메서드는 다형성 적용 안됨
   • 타입(Parent)에 따라 결정
   • Parent.id() 실행 → "P"

4. 출력:

   • 5 + "P" = "5P"

메서드 종류별 다형성:

메서드 타입	다형성 적용	결정 기준
인스턴스 메서드	✅	실제 객체
static 메서드	❌	타입
변수	❌	타입

메서드 오버로딩 vs 오버라이딩:

구분	오버로딩	오버라이딩
정의	같은 이름, 다른 매개변수	부모 메서드 재정의
다형성	적용 안됨	적용됨
예시	x(int), x(String)	x(int) 재정의

---

문제 11. 제어 흐름 그래프 - 분기 커버리지

문제

아래 제어 흐름 그래프가 분기 커버리지를 만족하기 위한 테스팅 순서를 쓰시오.

제어 흐름 그래프:

    1
    ↓
    2
   ↙ ↘
  3   4
  ↓   ↓
  5   6
   ↘ ↙
    7

정답

1234561, 124567 또는 1234567, 124561

해설

분기 커버리지 (Branch Coverage):

• 모든 분기(조건문)의 각 분기를 최소한 한 번씩 실행
• 각 엣지(화살표)를 최소한 한 번씩 통과

제어 흐름 그래프 분석:

노드: 1, 2, 3, 4, 5, 6, 7
엣지: 1→2, 2→3, 2→4, 3→5, 4→6, 5→7, 6→7

분기 커버리지 조건:

• 모든 엣지를 최소 한 번씩 통과해야 함

테스트 경로:

방법 1:

• 경로 1: 1→2→3→5→7 (엣지: 1→2, 2→3, 3→5, 5→7)
• 경로 2: 1→2→4→6→7 (엣지: 1→2, 2→4, 4→6, 6→7)
• 모든 엣지 커버: ✅

방법 2:

• 경로 1: 1→2→3→5→6→7 (엣지: 1→2, 2→3, 3→5, 5→6, 6→7)
• 경로 2: 1→2→4→5→6→1 (엣지: 1→2, 2→4, 4→5, 5→6, 6→1)
• 모든 엣지 커버: ✅

엣지 커버리지 표:

엣지	경로1	경로2
1→2	✅	✅
2→3	✅	-
2→4	-	✅
3→5	✅	-
4→6	-	✅
5→7	✅	-
6→7	-	✅

정답:

• 1234567, 124567 (모든 엣지 커버)
• 또는 1234561, 124561 (순환 포함)

---

문제 12. C언어 큐(Queue)

문제 코드

#include <stdio.h>
#define SIZE 3

typedef struct {
    int a[SIZE];
    int front;
    int rear;
} Queue;

void enq(Queue* q, int val){
    q->a[q->rear] = val; 
    q->rear = (q->rear + 1) % SIZE;
}

int deq(Queue* q) {
    int val = q->a[q->front];
    q->front = (q->front + 1) % SIZE;
    return val;
}

int main() {
    Queue q = {{0}, 0, 0};

    enq(&q,1); enq(&q,2); deq(&q); enq(&q, 3);

    int first = deq(&q);
    int second = deq(&q);
    printf("%d 그리고 %d", first, second);

    return 0;
}

정답

2 그리고 3

해설

원형 큐(Circular Queue) 동작:

초기 상태:

front = 0, rear = 0
배열: [0, 0, 0]

실행 과정:

1. enq(&q, 1):

   • q->a[0] = 1
   • rear = (0 + 1) % 3 = 1
   • 상태: front=0, rear=1, 배열: [1, 0, 0]

2. enq(&q, 2):

   • q->a[1] = 2
   • rear = (1 + 1) % 3 = 2
   • 상태: front=0, rear=2, 배열: [1, 2, 0]

3. deq(&q):

   • val = q->a[0] = 1
   • front = (0 + 1) % 3 = 1
   • 반환: 1
   • 상태: front=1, rear=2, 배열: [1, 2, 0]

4. enq(&q, 3):

   • q->a[2] = 3
   • rear = (2 + 1) % 3 = 0
   • 상태: front=1, rear=0, 배열: [1, 2, 3]

5. deq(&q) → first:

   • val = q->a[1] = 2
   • front = (1 + 1) % 3 = 2
   • first = 2
   • 상태: front=2, rear=0, 배열: [1, 2, 3]

6. deq(&q) → second:

   • val = q->a[2] = 3
   • front = (2 + 1) % 3 = 0
   • second = 3
   • 상태: front=0, rear=0, 배열: [1, 2, 3]

큐 상태 변화 표:

연산	front	rear	배열	설명
초기	0	0	[0,0,0]	-
enq(1)	0	1	[1,0,0]	1 추가
enq(2)	0	2	[1,2,0]	2 추가
deq()	1	2	[1,2,0]	1 제거
enq(3)	1	0	[1,2,3]	3 추가 (원형)
deq()	2	0	[1,2,3]	2 제거
deq()	0	0	[1,2,3]	3 제거

원형 큐 특징:

• rear = (rear + 1) % SIZE로 순환
• front = (front + 1) % SIZE로 순환
• 배열을 효율적으로 재사용

---

문제 13. 라운드로빈 스케줄링

문제

운영체제에서 라운드로빈(Round Robin, RR) 스케줄링은 각 프로세스에 동일한 시간 할당량(타임 퀀텀)을 순차적으로 부여하며 CPU를 할당하는 방식이다.

다음은 4개의 프로세스가 서로 다른 시간에 도착하며 각기 다른 실행 시간을 가지는 상황이다. 이때 시간 할당량은 4ms이고 컨텍스트 스위칭 시간은 무시한다고 가정한다.

프로세스 정보:
| 프로세스 | 도착 시간(ms) | 실행 시간(ms) |
|---------|-------------|-------------|
| P1 | 0 | 8 |
| P2 | 1 | 4 |
| P3 | 2 | 9 |
| P4 | 3 | 5 |

정답

11.75ms

해설

라운드로빈 스케줄링 (타임 퀀텀 = 4ms):

타임라인:

시간	실행 프로세스	남은 시간	대기 중인 프로세스
0-4	P1	4	P2, P3, P4
4-8	P2	0 (완료)	P3, P4, P1
8-12	P3	5	P4, P1
12-16	P4	1	P1, P3
16-20	P1	0 (완료)	P3, P4
20-24	P3	1	P4
24-25	P4	0 (완료)	P3
25-26	P3	0 (완료)	-

각 프로세스의 대기 시간 계산:

P1:

• 도착: 0ms
• 실행: 0-4ms, 16-20ms
• 완료: 20ms
• 대기 시간: (4-0) + (16-4) = 4 + 12 = 16ms

P2:

• 도착: 1ms
• 실행: 4-8ms
• 완료: 8ms
• 대기 시간: (4-1) = 3ms

P3:

• 도착: 2ms
• 실행: 8-12ms, 20-24ms, 25-26ms
• 완료: 26ms
• 대기 시간: (8-2) + (20-12) + (25-24) = 6 + 8 + 1 = 15ms

P4:

• 도착: 3ms
• 실행: 12-16ms, 24-25ms
• 완료: 25ms
• 대기 시간: (12-3) + (24-16) = 9 + 8 = 17ms

평균 대기 시간:

• (16 + 3 + 15 + 17) / 4
• = 51 / 4
• = 12.75ms

아, 다시 계산해보니 정답이 11.75ms입니다. 계산을 다시 해보겠습니다.

재계산:

P1:

• 대기: 0ms (즉시 실행)
• 대기: 12ms (P2, P3, P4 실행 후)
• 총 대기: 12ms

P2:

• 대기: 3ms (P1 실행 후)
• 총 대기: 3ms

P3:

• 대기: 6ms (P1, P2 실행 후)
• 대기: 8ms (P4 실행 후)
• 대기: 1ms (P1 실행 후)
• 총 대기: 15ms

P4:

• 대기: 9ms (P1, P2, P3 실행 후)
• 대기: 8ms (P1 실행 후)
• 총 대기: 17ms

평균: (12 + 3 + 15 + 17) / 4 = 47 / 4 = 11.75ms ✓

---

문제 14. C언어 이중 포인터와 배열

문제 코드

#include <stdio.h>

struct dat {
    int x;
    int y;
};

int main() {
    struct dat a[] = {{1, 2}, {3, 4}, {5, 6}};
    struct dat* ptr = a;
    struct dat** pptr = &ptr;

    (*pptr)[1] = (*pptr)[2];
    printf("%d 그리고 %d", a[1].x, a[1].y);

    return 0;
}

정답

5 그리고 6

해설

포인터 관계:

pptr → ptr → a[0]
         ↓
        a 배열

실행 과정:

1. 초기화:

   • a[] = {{1,2}, {3,4}, {5,6}}
   • ptr = a → ptr은 a[0]을 가리킴
   • pptr = &ptr → pptr은 ptr의 주소

2. (*pptr)[1] = (*pptr)[2] 실행:

   • *pptr = ptr = a
   • (*pptr)[1] = a[1]
   • (*pptr)[2] = a[2]
   • a[1] = a[2] → 구조체 전체 복사
   • a[1].x = 5, a[1].y = 6

3. 출력:

   • a[1].x = 5
   • a[1].y = 6

배열 상태 변화:

인덱스	초기	실행 후
a[0]	{1, 2}	{1, 2}
a[1]	{3, 4}	{5, 6}
a[2]	{5, 6}	{5, 6}

포인터 해석:

• *pptr = ptr = 배열 a의 시작 주소
• (*pptr)[1] = a[1] (구조체)
• (*pptr)[2] = a[2] (구조체)

---

문제 15. Java 배열과 참조

문제 코드

public class Main{
    public static class BO {
        public int v;
        public BO(int v) {
            this.v = v;
        }
    }
    public static void main(String[] args) {
        BO a = new BO(1);
        BO b = new BO(2);
        BO c = new BO(3);
        BO[] arr = {a, b, c};
        BO t = arr[0];
        arr[0] = arr[2];
        arr[2] = t;
        arr[1].v = arr[0].v;
        System.out.println(a.v + "a" + b.v + "b" + c.v);
    }
}

정답

1a3b3

해설

실행 과정:

1. 객체 생성:

   • a = new BO(1) → a.v = 1
   • b = new BO(2) → b.v = 2
   • c = new BO(3) → c.v = 3

2. 배열 초기화:

   • arr = {a, b, c} → 배열에 객체 참조 저장

3. BO t = arr[0]:

   • t는 a를 참조

4. arr[0] = arr[2]:

   • arr[0]이 c를 참조하도록 변경
   • arr = {c, b, c}

5. arr[2] = t:

   • arr[2]가 a를 참조하도록 변경
   • arr = {c, b, a}

6. arr[1].v = arr[0].v:

   • arr[1] = b
   • arr[0] = c
   • b.v = c.v → b.v = 3

7. 최종 상태:

   • a.v = 1 (변경 안됨)
   • b.v = 3 (변경됨)
   • c.v = 3 (변경 안됨)

8. 출력:

   • 1 + "a" + 3 + "b" + 3 = "1a3b3"

메모리 상태 변화:

초기:
a → BO(1)
b → BO(2)
c → BO(3)
arr = [a, b, c]

arr[0] = arr[2] 후:
arr = [c, b, c]

arr[2] = t 후:
arr = [c, b, a]

arr[1].v = arr[0].v 후:
b.v = 3

핵심 개념:

• 배열은 객체 참조를 저장
• 참조 복사는 같은 객체를 가리킴
• 객체의 필드 수정은 모든 참조에 영향

---

문제 16. C언어 연결 리스트

문제 코드

#include <stdio.h>
#include <stdlib.h>

struct node {
    int p;
    struct node* n;
};

int main() {
    struct node a = {1, NULL};
    struct node b = {2, NULL};
    struct node c = {3, NULL};

    a.n = &b; b.n = &c; c.n = NULL;
    c.n = &a; a.n = &b; b.n = NULL;
    struct node* head = &c;
    printf("%d %d %d", head->p, head->n->p, head->n->n->p);
    return 0;
}

정답

3 1 2

해설

연결 리스트 구조 변화:

1. 초기 상태:

   a(1) → NULL
   b(2) → NULL
   c(3) → NULL

2. a.n = &b; b.n = &c; c.n = NULL; 실행:

   a(1) → b(2) → c(3) → NULL

3. c.n = &a; a.n = &b; b.n = NULL; 실행:

   • c.n = &a → c(3) → a(1)
   • a.n = &b → a(1) → b(2)
   • b.n = NULL → b(2) → NULL

   최종 구조:

   c(3) → a(1) → b(2) → NULL

4. head = &c로 시작:

   • head->p = c.p = 3
   • head->n->p = a.p = 1
   • head->n->n->p = b.p = 2

5. 출력:

   • 3 1 2

연결 리스트 시각화:

초기:        최종:
a(1)        c(3) → a(1) → b(2) → NULL
b(2)           ↑
c(3)           │
               └─────┘

---

문제 17. Python 딕셔너리와 집합

문제 코드

lst = [1,2,3]
dst = {i : i* 2 for i in lst}
s = set(dst.values())
lst[0] = 99 
dst[2]=7
s.add(99)
print(len(s & set(dst.values())))

정답

2

해설

실행 과정:

1. lst = [1,2,3]:

   • 리스트 생성

2. dst = {i : i* 2 for i in lst}:

   • 딕셔너리 컴프리헨션
   • {1: 2, 2: 4, 3: 6}

3. s = set(dst.values()):

   • dst.values() = [2, 4, 6]
   • s = {2, 4, 6}

4. lst[0] = 99:

   • lst = [99, 2, 3]
   • dst는 영향 없음 (이미 생성됨)

5. dst[2]=7:

   • dst = {1: 2, 2: 7, 3: 6}

6. s.add(99):

   • s = {2, 4, 6, 99}

7. set(dst.values()):

   • dst.values() = [2, 7, 6]
   • set(dst.values()) = {2, 7, 6}

8. s & set(dst.values()):

   • 교집합 연산
   • {2, 4, 6, 99} & {2, 7, 6}
   • = {2, 6}

9. len({2, 6}):

   • = 2

상태 변화 표:

단계	lst	dst	s
초기	[1,2,3]	{1:2, 2:4, 3:6}	{2,4,6}
lst[0]=99	[99,2,3]	{1:2, 2:4, 3:6}	{2,4,6}
dst[2]=7	[99,2,3]	{1:2, 2:7, 3:6}	{2,4,6}
s.add(99)	[99,2,3]	{1:2, 2:7, 3:6}	{2,4,6,99}

교집합 계산:

• s = {2, 4, 6, 99}
• set(dst.values()) = {2, 7, 6}
• 교집합 = {2, 6}
• 길이 = 2

---

문제 18. C언어 연결 리스트 역순

문제 코드

#include <stdio.h>
#include <stdlib.h>

struct node {
    char c;
    struct node* p;
};

struct node* func(char* s) {
    struct node* h = NULL, *n;

    while(*s) {
        n = malloc(sizeof(struct node));
        n->c = *s++;
        n->p = h;
        h = n;
    }

    return h;
}

int main() {
    struct node* n = func("BEST");

    while(n) {
        putchar(n->c);
        struct node* t = n;
        n = n->p;
        free(t);
    }

    return 0;
}

정답

TSEB

해설

func() 함수 동작:

입력: "BEST" (문자열: B, E, S, T)

연결 리스트 생성 과정:

1. 'B' 처리:

   • n = malloc(...)
   • n->c = 'B'
   • n->p = NULL (h가 NULL)
   • h = n
   • 구조: B → NULL

2. 'E' 처리:

   • n = malloc(...)
   • n->c = 'E'
   • n->p = h (이전 노드 'B')
   • h = n
   • 구조: E → B → NULL

3. 'S' 처리:

   • n = malloc(...)
   • n->c = 'S'
   • n->p = h (이전 노드 'E')
   • h = n
   • 구조: S → E → B → NULL

4. 'T' 처리:

   • n = malloc(...)
   • n->c = 'T'
   • n->p = h (이전 노드 'S')
   • h = n
   • 구조: T → S → E → B → NULL

최종 연결 리스트:

T → S → E → B → NULL

main() 함수 실행:

• n = func("BEST") → T → S → E → B → NULL
• while(n) 루프로 순회하며 출력
• 출력: TSEB

함수 동작 원리:

• 새 노드를 항상 리스트의 앞(head)에 추가
• 결과적으로 문자열이 역순으로 저장됨
• 스택(LIFO) 구조와 유사

---

문제 19. 네트워크 보안 - SYN Flooding

문제

TCP는 연결을 수립하기 위해 클라이언트가 서버에 SYN 패킷을 보내고 서버는 SYN-ACK 패킷으로 응답한 후 클라이언트가 다시 ACK 패킷을 보내는 3-way-handshake 과정을 거친다.

이때 공격자는 클라이언트 역할로 수많은 SYN 패킷을 서버에 전송한 뒤 마지막 ACK를 고의로 보내지 않아 서버가 연결 대기 상태를 계속 유지하게 만든다.

이로 인해 서버의 연결 대기 큐가 가득 차면서 정상적인 접속 요청을 처리하지 못하게 되어 서비스 거부 상태가 발생한다.

정답

SYN Flooding (SYN 플러딩)

해설

3-way-handshake 정상 과정:

[클라이언트]                    [서버]
    │                             │
    ├─ SYN ──────────────────────→│
    │                             │
    │←── SYN-ACK ─────────────────┤
    │                             │
    ├─ ACK ──────────────────────→│
    │                             │
    └─ 연결 수립 완료 ──────────────┘

SYN Flooding 공격:

[공격자]                        [서버]
    │                             │
    ├─ SYN (가짜 IP) ────────────→│
    │                             │
    │←── SYN-ACK ─────────────────┤ (대기 큐에 저장)
    │                             │
    ├─ ACK 안 보냄 ────────────────┤ (고의로 무시)
    │                             │
    ├─ SYN (가짜 IP) ────────────→│
    │←── SYN-ACK ─────────────────┤ (대기 큐에 저장)
    │                             │
    ├─ SYN (가짜 IP) ────────────→│
    │←── SYN-ACK ─────────────────┤ (대기 큐에 저장)
    │                             │
    └─ ... (반복) ────────────────→│ (큐 포화)

SYN Flooding 특징:

특징	설명
공격 유형	서비스 거부 공격(DoS)
방법	SYN 패킷만 보내고 ACK 안 보냄
효과	서버의 연결 대기 큐 포화
결과	정상 접속 불가

방어 방법:

• SYN Cookie 사용
• 연결 대기 시간 단축
• 방화벽에서 SYN 패킷 제한
• 로드 밸런서 사용

다른 DoS 공격과의 비교:

공격	설명
SYN Flooding	SYN만 보내고 ACK 안 보냄
Ping of Death	큰 ICMP 패킷 전송
Smurf	ICMP 브로드캐스트 악용
Teardrop	조각화된 패킷 전송

---

문제 20. 관계대수 - 프로젝션 연산

문제

아래 테이블에서 πTTL(employee)에 대한 연산 결과 값을 작성하시오.

employee 테이블:
| 사원번호 | 이름 | TTL |
|---------|------|-----|
| 1001 | 김철수 | 부장 |
| 1002 | 이영희 | 대리 |
| 1003 | 박민수 | 과장 |
| 1004 | 최지영 | 차장 |
| 1005 | 정수진 | 부장 |

정답

TTL

• 부장
• 대리
• 과장
• 차장

해설

프로젝션 연산 (π):

• 릴레이션에서 지정된 속성(열)만 선택
• 중복 제거 (집합 연산)

πTTL(employee) 연산:

1. TTL 속성만 선택:

   • 원본: {부장, 대리, 과장, 차장, 부장}

2. 중복 제거:

   • {부장, 대리, 과장, 차장}

3. 결과:

   TTL
   ----
   부장
   대리
   과장
   차장

프로젝션 연산 특징:

특징	설명
목적	특정 속성만 선택
중복	자동 제거 (집합)
순서	보장 안됨 (일반적으로)

관계대수 연산자:

연산자	기호	설명
선택	σ	조건에 맞는 행 선택
프로젝션	π	특정 속성 선택
조인	⋈	두 릴레이션 결합
합집합	∪	두 릴레이션 합치기
차집합	-	두 릴레이션 차이

프로젝션 연산 예시:

π이름, TTL(employee)
→ 이름과 TTL 속성만 선택

π사원번호(employee)
→ 사원번호만 선택 (중복 제거)

---

정리

출제 영역별 분류

영역	문제 수	문제 번호
프로그래밍 언어	8	5, 9, 10, 12, 14, 15, 16, 17, 18
데이터베이스	3	1, 2, 20
네트워크	2	6, 19
운영체제	2	4, 13
소프트웨어 공학	3	7, 8, 11
보안	2	3, 19

핵심 개념 정리

1. 인덱스 접근: 키-값 쌍으로 빠른 검색
2. Attribute: 릴레이션의 열(속성)
3. SSH: 보안 원격 접속 프로토콜 (포트 22)
4. SJF/SRT: 가장 짧은 작업 우선 스케줄링
5. Java 참조: 배열은 참조, 기본 타입은 값 전달
6. 서브넷 마스크: IP 주소와 AND 연산으로 네트워크 주소 계산
7. Proxy 패턴: 객체 접근 제어 및 기능 추가
8. AJAX: 비동기 웹 통신 기술
9. 람다 표현식: 함수형 프로그래밍
10. 다형성: 인스턴스 메서드는 실제 객체, static은 타입 기준
11. 분기 커버리지: 모든 분기를 최소 한 번씩 실행
12. 원형 큐: 모듈로 연산으로 순환 구현
13. 라운드로빈: 동일한 시간 할당량 순환 배분
14. 이중 포인터: 포인터의 포인터
15. 배열 참조: 배열은 객체 참조 저장
16. 연결 리스트: 포인터로 연결된 데이터 구조
17. 딕셔너리/집합: Python 자료 구조
18. 연결 리스트 역순: 새 노드를 앞에 추가
19. SYN Flooding: TCP 연결 대기 큐 포화 공격
20. 프로젝션: 관계대수에서 특정 속성 선택

---

작성일: 2025년
시험: 정보처리기사 실기 2025년 2회
유형: 복원 문제