2024년 정보처리기사 실기 2회 -문제해설

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

📋 목차

1. Java 배열 비교 문제
2. 데이터베이스 성능 기법 문제
3. SQL 구문 문제
4. 릴레이션 Cardinality/Degree 문제
5. 프로토콜 문제
6. Python 문자열 문제
7. 암호화 알고리즘 문제
8. 패킷 교환 방식 문제
9. 응집도 문제
10. 디자인 패턴 문제
11. RIP 라우팅 문제
12. SRT 스케줄링 문제
13. C언어 포인터 배열 문제
14. Java 인터페이스 문제
15. C언어 문자열 함수 문제
16. 결합도 문제
17. Java 재귀 함수 문제
18. C언어 switch 문제
19. C언어 구조체 포인터 문제
20. Java 문자열 split 문제

---

1. Java 배열 비교 문제

문제

다음은 Java 코드에 대한 문제이다. 아래 코드를 확인하여 알맞는 출력값을 작성하시오.

class Main {
    public static void main(String[] args) {
        int[] a = new int[]{1, 2, 3, 4};
        int[] b = new int[]{1, 2, 3, 4};
        int[] c = new int[]{1, 2, 3};

        check(a, b);
        check(a, c); 
        check(b, c); 
    }

    public static void check(int[] a, int[] b) {
        if (a==b) {
            System.out.print("O");
        }else{
            System.out.print("N");
        }
    }
}

정답

NNN

해설

Java 배열 비교의 핵심:

비교 방식	연산자	비교 내용	결과
참조 비교	==	메모리 주소 비교	같은 객체인지 확인
값 비교	Arrays.equals()	배열 요소 값 비교	내용이 같은지 확인

코드 실행 분석:

호출	배열 a	배열 b	a==b 비교	결과
check(a, b)	[1,2,3,4]	[1,2,3,4]	다른 객체	N
check(a, c)	[1,2,3,4]	[1,2,3]	다른 객체	N
check(b, c)	[1,2,3,4]	[1,2,3]	다른 객체	N

메모리 구조:

힙 메모리:
┌─────────────┐
│ 배열 a      │ → [1, 2, 3, 4] (주소: 0x1000)
└─────────────┘
┌─────────────┐
│ 배열 b      │ → [1, 2, 3, 4] (주소: 0x2000)
└─────────────┘
┌─────────────┐
│ 배열 c      │ → [1, 2, 3] (주소: 0x3000)
└─────────────┘

a == b → 0x1000 == 0x2000 → false
a == c → 0x1000 == 0x3000 → false
b == c → 0x2000 == 0x3000 → false

올바른 배열 비교 방법:

// 값 비교를 위해서는
import java.util.Arrays;

if (Arrays.equals(a, b)) {
    System.out.print("O");  // 값이 같으면 O
} else {
    System.out.print("N");  // 값이 다르면 N
}

핵심 포인트:

• == 연산자는 참조(주소) 비교만 수행
• 내용이 같아도 다른 객체이면 false 반환
• 값 비교를 위해서는 Arrays.equals() 사용 필요

---

2. 데이터베이스 성능 기법 문제

문제

다음 문제에서 설명하는 용어를 작성하시오.

데이터를 중복시켜 성능을 향상시키기 위한 기법으로 데이터를 중복 저장하거나 테이블을 합치는 등으로 성능을 향상시키지만 데이터 무결성이 저하될 수 있는 기법

정답

반정규화 (Denormalization)

해설

용어	설명	목적	단점
정규화	중복 제거, 테이블 분리	데이터 무결성 향상	조인 증가로 성능 저하
반정규화	중복 허용, 테이블 통합	조인 감소로 성능 향상	데이터 무결성 저하

정규화 vs 반정규화:

정규화 (Normalization):
┌──────────┐      ┌──────────┐
│ 학생     │      │ 과목     │
├──────────┤      ├──────────┤
│ 학번(PK) │      │ 과목코드(PK)│
│ 이름     │      │ 과목명   │
│ 과목코드(FK) ──→│          │
└──────────┘      └──────────┘
(조인 필요)

반정규화 (Denormalization):
┌──────────────────┐
│ 학생             │
├──────────────────┤
│ 학번(PK)         │
│ 이름             │
│ 과목코드         │
│ 과목명           │ ← 중복 저장
└──────────────────┘
(조인 불필요, 성능 향상)

반정규화 기법:

기법	설명	예시
중복 컬럼 추가	자주 조인되는 컬럼을 중복 저장	주문 테이블에 고객명 추가
파생 컬럼 추가	계산 결과를 미리 저장	총액 = 단가 × 수량
테이블 통합	1:1 관계 테이블 통합	학생 테이블 + 학생상세 테이블
테이블 분할	수평/수직 분할	최근 데이터와 과거 데이터 분리

반정규화 장단점:

항목	내용
장점	조인 감소로 성능 향상 쿼리 단순화 응답 시간 단축
단점	데이터 중복으로 저장 공간 증가 데이터 무결성 저하 업데이트 비용 증가

사용 시기:

• 조인이 많아 성능이 저하될 때
• 읽기 작업이 많고 쓰기 작업이 적을 때
• 데이터 무결성보다 성능이 중요할 때

---

3. SQL 구문 문제

문제

다음은 SQL에 관한 문제이다. 아래 SQL 구문의 빈칸을 작성하시오.

테이블:

• 사원 [사원번호(PK), 이름, 나이, 부서]
• 부서 [사원번호(PK), 이름, 주소, 나이]

쿼리:

1. 신입 사원이 들어와서 사원 테이블에 추가

   INSERT INTO 사원 (사원번호, 이름, 주소, 부서) [①] (32431, '정실기', '서울', '영업');

2. 위에 신입사원을 검색하면서 부서 테이블에 추가

   INSERT INTO 부서 (사원번호, 이름, 나이, 부서)
   [②] 사원번호, 이름, 나이, 23 FROM 사원 WHERE 이름 = '정실기';

3. 전체 사원 테이블 조회

   SELECT * [③] 사원;

4. 퇴사로 인해 부서에 해당하는 값을 '퇴사'로 변경

   UPDATE 사원 [④] 부서 = '퇴사' WHERE 사원번호 = 32431;

정답

• ①: VALUES
• ②: SELECT
• ③: FROM
• ④: SET

해설

SQL 구문 구조:

구문	키워드	용도	예시
INSERT	VALUES	직접 값 삽입	INSERT INTO 테이블 VALUES (값1, 값2)
INSERT	SELECT	조회 결과 삽입	INSERT INTO 테이블 SELECT ...
SELECT	FROM	테이블 지정	SELECT * FROM 테이블
UPDATE	SET	값 변경	UPDATE 테이블 SET 컬럼=값

각 쿼리 상세:

① INSERT ... VALUES:

INSERT INTO 사원 (사원번호, 이름, 주소, 부서) 
VALUES (32431, '정실기', '서울', '영업');

• 직접 값을 지정하여 삽입
• 컬럼 순서와 값 순서가 일치해야 함

② INSERT ... SELECT:

INSERT INTO 부서 (사원번호, 이름, 나이, 부서)
SELECT 사원번호, 이름, 나이, 23 FROM 사원 WHERE 이름 = '정실기';

• 다른 테이블에서 조회한 결과를 삽입
• SELECT 결과의 컬럼 수와 INSERT 컬럼 수가 일치해야 함

③ SELECT ... FROM:

SELECT * FROM 사원;

• 모든 컬럼 조회
• *는 모든 컬럼을 의미

④ UPDATE ... SET:

UPDATE 사원 SET 부서 = '퇴사' WHERE 사원번호 = 32431;

• 조건에 맞는 행의 값을 변경
• SET 절에서 변경할 컬럼과 값을 지정

실행 결과:

단계	테이블	내용
① 실행 후	사원	(32431, '정실기', NULL, '영업')
② 실행 후	부서	(32431, '정실기', 23, '영업')
③ 실행	사원	전체 사원 조회
④ 실행 후	사원	(32431, '정실기', NULL, '퇴사')

---

4. 릴레이션 Cardinality/Degree 문제

문제

다음 릴레이션의 Cardinality와 Degree를 작성하시오.

릴레이션:
| 학번 | 이름 | 나이 | 학과 |
|------|------|------|------|
| 2024001 | 홍길동 | 20 | 컴퓨터 |
| 2024002 | 김철수 | 21 | 전자 |
| 2024003 | 이영희 | 19 | 컴퓨터 |
| 2024004 | 박민수 | 20 | 기계 |
| 2024005 | 최지영 | 22 | 전자 |

정답

• Cardinality: 5
• Degree: 4

해설

용어	영문	설명	계산
Cardinality	기수	튜플(행)의 개수	5개 행
Degree	차수	속성(열)의 개수	4개 열

릴레이션 구조:

릴레이션: 학생
┌──────────┬────────┬──────┬──────────┐
│ 학번     │ 이름   │ 나이 │ 학과     │ ← Degree: 4
├──────────┼────────┼──────┼──────────┤
│ 2024001 │ 홍길동 │  20  │ 컴퓨터   │
│ 2024002 │ 김철수 │  21  │ 전자     │
│ 2024003 │ 이영희 │  19  │ 컴퓨터   │ ← Cardinality: 5
│ 2024004 │ 박민수 │  20  │ 기계     │
│ 2024005 │ 최지영 │  22  │ 전자     │
└──────────┴────────┴──────┴──────────┘

시각적 표현:

Cardinality (기수) = 행의 개수
┌─────────────────────────┐
│ 튜플 1                  │
│ 튜플 2                  │
│ 튜플 3                  │ ← 5개
│ 튜플 4                  │
│ 튜플 5                  │
└─────────────────────────┘

Degree (차수) = 열의 개수
┌─────┬─────┬─────┬─────┐
│ 속성│ 속성│ 속성│ 속성│ ← 4개
│  1  │  2  │  3  │  4  │
└─────┴─────┴─────┴─────┘

기억 방법:

• Cardinality (기수): 카드 개수처럼 행의 개수
• Degree (차수): 각도처럼 차원의 개수, 속성의 개수

---

5. 프로토콜 문제

문제

다음은 프로토콜에 대한 내용이다. 아래 내용을 읽고 알맞는 답을 작성하시오.

• Network layer에서 IP패킷을 암호화하고 인증하는 등의 보안을 위한 표준이다.
• 기업에서 사설 인터넷망으로 사용할 수 있는 VPN을 구현하는데 사용되는 프로토콜이다.
• AH(Authentication Header)와 ESP(Encapsulating Security Payload)라는 두 가지 보안 프로토콜을 사용한다.

정답

IPSec (IP Security)

해설

프로토콜	계층	용도	특징
IPSec	Network Layer (3계층)	IP 패킷 보안	암호화, 인증, 무결성
SSL/TLS	Transport Layer (4계층)	전송 계층 보안	HTTPS 등
SSH	Application Layer (7계층)	원격 접속 보안	암호화된 통신

IPSec 구조:

IPSec 프로토콜
├── AH (Authentication Header)
│   └── 인증 및 무결성 보장
│   └── 암호화는 제공하지 않음
└── ESP (Encapsulating Security Payload)
    └── 암호화, 인증, 무결성 모두 제공

IPSec 모드:

모드	설명	사용 시나리오
전송 모드	상위 계층 데이터만 보호	호스트 간 통신
터널 모드	전체 IP 패킷 보호	VPN, 게이트웨이 간 통신

VPN 구현:

사용자 A                    VPN 서버                    사용자 B
    │                           │                           │
    │─── 일반 IP 패킷 ──────────│                           │
    │                           │                           │
    │─── IPSec 암호화 ──────────→│─── IPSec 복호화 ─────────→│
    │   (터널 모드)              │                           │

AH vs ESP:

프로토콜	암호화	인증	무결성	헤더 위치
AH	❌	✅	✅	IP 헤더 뒤
ESP	✅	✅	✅	IP 헤더 뒤

IPSec 장점:

• 네트워크 계층에서 보안 제공
• 상위 계층 애플리케이션 수정 불필요
• 투명한 보안 제공
• VPN 구현에 적합

---

6. Python 문자열 문제

문제

다음은 Python에 대한 문제이다. 아래 코드를 읽고 알맞는 출력 값을 작성하시오.

def fnCalculation(x,y):
    result = 0;
    for i in range(len(x)):
     temp = x[i:i+len(y)] 
     if temp == y:
       result += 1;
    return result

a = "abdcabcabca"
p1 = "ab";
p2 = "ca";

out = f"ab{fnCalculation(a,p1)}ca{fnCalculation(a,p2)}"
print(out)

정답

ab3ca3

해설

함수 동작 분석:

단계	설명	코드
1	문자열 x에서 패턴 y가 몇 번 나타나는지 카운트	fnCalculation(x, y)
2	슬라이싱으로 부분 문자열 추출	x[i:i+len(y)]
3	패턴과 일치하면 카운트 증가	if temp == y: result += 1

fnCalculation(a, "ab") 실행:

i	x[i:i+2]	temp	temp == "ab"?	result
0	"ab"	"ab"	✅ Yes	1
1	"bd"	"bd"	❌ No	1
2	"dc"	"dc"	❌ No	1
3	"ca"	"ca"	❌ No	1
4	"ab"	"ab"	✅ Yes	2
5	"bc"	"bc"	❌ No	2
6	"ca"	"ca"	❌ No	2
7	"ab"	"ab"	✅ Yes	3
8	"bc"	"bc"	❌ No	3
9	"ca"	"ca"	❌ No	3
10	"a"	"a"	❌ No	3

결과: 3

fnCalculation(a, "ca") 실행:

i	x[i:i+2]	temp	temp == "ca"?	result
0	"ab"	"ab"	❌ No	0
1	"bd"	"bd"	❌ No	0
2	"dc"	"dc"	❌ No	0
3	"ca"	"ca"	✅ Yes	1
4	"ab"	"ab"	❌ No	1
5	"bc"	"bc"	❌ No	1
6	"ca"	"ca"	✅ Yes	2
7	"ab"	"ab"	❌ No	2
8	"bc"	"bc"	❌ No	2
9	"ca"	"ca"	✅ Yes	3
10	"a"	"a"	❌ No	3

결과: 3

문자열 시각화:

a = "abdcabcabca"
    0123456789(10)

"ab" 패턴 찾기:
abdcabcabca
ab          ← 위치 0
    ab      ← 위치 4
        ab  ← 위치 7
총 3개

"ca" 패턴 찾기:
abdcabcabca
  ca        ← 위치 3
      ca    ← 위치 6
          ca ← 위치 9
총 3개

최종 출력:

out = f"ab{3}ca{3}"
     = "ab3ca3"

핵심 포인트:

• 문자열 슬라이싱: x[i:i+len(y)]
• 패턴 매칭: 부분 문자열이 패턴과 일치하는지 확인
• f-string 포맷팅: f"문자열{변수}문자열"

---

7. 암호화 알고리즘 문제

문제

아래 설명하는 내용을 확인하여 알맞는 알고리즘을 작성하시오.

• 대칭키 알고리즘으로 1997년 NIST(미국 국립기술표준원)에서 DES를 대체하기 위해 생성되었다.
• 128비트, 192비트 또는 256비트의 가변 키 크기와 128비트의 고정 블록 크기를 사용한다.
• 높은 안전성과 효율성, 속도 등으로 인해 DES 대신 전 세계적으로 많이 사용되고 있다.

정답

AES (Advanced Encryption Standard)

해설

알고리즘	타입	키 크기	블록 크기	상태
DES	대칭키	56비트	64비트	구식 (취약)
AES	대칭키	128/192/256비트	128비트	현재 표준
RSA	비대칭키	가변	가변	공개키 암호화

AES 특징:

항목	내용
개발	1997년 NIST 공모, 2001년 표준 채택
전신	DES (Data Encryption Standard)
키 크기	128비트, 192비트, 256비트
블록 크기	128비트 (고정)
라운드 수	키 크기에 따라 10/12/14 라운드

AES 라운드 수:

키 크기	라운드 수
128비트	10 라운드
192비트	12 라운드
256비트	14 라운드

AES vs DES 비교:

항목	DES	AES
키 크기	56비트	128/192/256비트
블록 크기	64비트	128비트
보안성	취약 (브루트포스 가능)	강함
속도	느림	빠름
사용 여부	사용 안 함	널리 사용

AES 동작 과정:

평문 (128비트)
    ↓
AddRoundKey (초기 라운드 키 추가)
    ↓
[라운드 반복]
├── SubBytes (바이트 치환)
├── ShiftRows (행 이동)
├── MixColumns (열 혼합)
└── AddRoundKey (라운드 키 추가)
    ↓
최종 라운드 (MixColumns 제외)
    ↓
암호문 (128비트)

사용 분야:

• WiFi 보안 (WPA2)
• VPN (IPSec)
• 파일 암호화
• 데이터베이스 암호화
• HTTPS (TLS)

---

8. 패킷 교환 방식 문제

문제

패킷 교환 방식 중에 연결형과 비연결형에 해당하는 방식을 작성하시오.

① 연결형 교환 방식
② 비연결형 교환 방식

정답

• ①: 가상회선 (Virtual Circuit)
• ②: 데이터그램 (Datagram)

해설

교환 방식	타입	설명	예시
가상회선	연결형	경로 설정 후 패킷 전송	전화 통화
데이터그램	비연결형	경로 설정 없이 패킷 전송	우편 발송

가상회선 (Virtual Circuit) 방식:

1. 연결 설정 단계:
   송신자 ──연결 요청──→ 수신자
   송신자 ←──연결 수락── 수신자

2. 데이터 전송:
   송신자 ──패킷1──→ 수신자
   송신자 ──패킷2──→ 수신자 (같은 경로)
   송신자 ──패킷3──→ 수신자 (같은 경로)

3. 연결 해제:
   송신자 ──해제 요청──→ 수신자

특징:

• 경로가 미리 설정됨
• 모든 패킷이 같은 경로로 전송
• 패킷 순서 보장
• 오버헤드 있음 (연결 설정/해제)

데이터그램 (Datagram) 방식:

송신자 ──패킷1──→ 경로A ──→ 수신자
송신자 ──패킷2──→ 경로B ──→ 수신자
송신자 ──패킷3──→ 경로C ──→ 수신자
(각 패킷이 독립적으로 경로 선택)

특징:

• 경로 설정 없음
• 각 패킷이 독립적으로 경로 선택
• 패킷 순서 보장 안 됨
• 오버헤드 적음

비교표:

항목	가상회선	데이터그램
연결 설정	필요	불필요
경로	고정	가변
순서 보장	✅	❌
오버헤드	큼	작음
신뢰성	높음	낮음
예시	전화 통화	우편 발송

프로토콜 예시:

방식	프로토콜
가상회선	X.25, Frame Relay, ATM
데이터그램	IP, UDP

---

9. 응집도 문제

문제

아래 내용을 확인하고 보기에서 알맞는 답을 고르시오.

실행 순서가 밀접한 관계를 갖는 기능을 모아 모듈로 구성한다.
한 모듈 내부의 한 기능 요소에 의한 출력 자료가 다음 기능 원소의 입력 자료로서 제공되는 형태이다.

[보기]
ㄱ. 기능적(functional) ㄴ. 우연적(Coincidental) ㄷ. 통신적(Communication)
ㄹ. 절차적(Procedural) ㅁ. 시간적(Temporal) ㅂ. 순차적(sequential) ㅅ. 논리적(Logical)

정답

ㅂ. 순차적 (Sequential Cohesion)

해설

응집도	설명	예시	강도
기능적	하나의 명확한 기능 수행	계산 함수	가장 강함
순차적	출력이 다음 입력으로 사용	파이프라인 처리	강함
통신적	같은 데이터 사용	데이터 처리 모듈	중간
절차적	실행 순서가 중요	초기화 모듈	중간
시간적	같은 시간에 실행	초기화/종료 모듈	약함
논리적	논리적으로 관련	오류 처리 모듈	약함
우연적	관련성 없음	랜덤 함수 모음	가장 약함

순차적 응집도 (Sequential Cohesion):

모듈 구조:
입력 → 기능A → 출력A
              ↓
         입력B → 기능B → 출력B
                      ↓
                 입력C → 기능C → 최종 출력

예시 코드:

// 순차적 응집도 예시
void processData(int input) {
    int step1 = validate(input);      // 출력: 검증 결과
    int step2 = transform(step1);      // 입력: step1의 출력
    int step3 = calculate(step2);      // 입력: step2의 출력
    return step3;
}

응집도 강도 순서:

기능적 > 순차적 > 통신적 > 절차적 > 시간적 > 논리적 > 우연적
(강함)                                    (약함)

문제 설명 분석:

설명	의미	응집도
"실행 순서가 밀접한 관계"	순서대로 실행	순차적
"출력이 다음 입력으로 제공"	파이프라인 구조	순차적

다른 응집도와의 차이:

응집도	특징
순차적	A의 출력 → B의 입력 (데이터 흐름)
절차적	A 실행 후 B 실행 (순서만 중요)
통신적	A와 B가 같은 데이터 사용 (데이터 공유)

---

10. 디자인 패턴 문제

문제

아래는 디자인 패턴에 관한 설명이다. 아래 설명을 읽고 보기에서 알맞는 용어를 작성하시오.

• 컬렉션 객체의 내부 구조를 노출하지 않고 순차적으로 접근할 수 있게 하는 패턴이다.
• 이 패턴은 객체의 내부 표현 방식에 독립적으로 요소에 접근할 수 있도록 해준다
• 반복 프로세스를 캡슐화하여 클라이언트 코드에서는 컬렉션의 구체적인 구현에 종속되지 않도록 한다.

[보기]
생성패턴: Singleton, Factory Method, Abstract Factory
구조패턴: Adapter, Bridge, Composite
행위패턴: Iterator, Visitor, Observer

정답

Iterator Pattern (반복자 패턴)

해설

패턴	분류	목적
Iterator	행위 패턴	컬렉션 순회 캡슐화
Adapter	구조 패턴	인터페이스 변환
Observer	행위 패턴	상태 변화 알림

Iterator 패턴 구조:

Client
  │
  │ Iterator 요청
  ↓
Collection (컬렉션)
  │
  │ createIterator()
  ↓
Iterator (반복자)
  │
  │ next(), hasNext()
  ↓
Elements (요소들)

예시 코드:

// Iterator 인터페이스
interface Iterator {
    boolean hasNext();
    Object next();
}

// 컬렉션 인터페이스
interface Collection {
    Iterator createIterator();
}

// 사용
Collection list = new ArrayList();
Iterator it = list.createIterator();
while (it.hasNext()) {
    Object item = it.next();
    // 처리
}

Iterator 패턴 장점:

장점	설명
내부 구조 은닉	컬렉션 내부 구조를 노출하지 않음
일관된 인터페이스	다양한 컬렉션에 동일한 방식으로 접근
구현 독립성	클라이언트가 구체적 구현에 종속되지 않음
다중 순회	여러 반복자를 동시에 사용 가능

사용 예시:

컬렉션	Iterator 사용
ArrayList	list.iterator()
HashSet	set.iterator()
HashMap	map.keySet().iterator()

Java에서의 Iterator:

List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

---

11. RIP 라우팅 문제

문제

아래 그림을 바탕으로 RIP을 구성하여 최단 경로 비용을 계산하여 흐름에 맞게 작성하시오.

네트워크 토폴로지:

    A ──2── B
    │       │
    3       4
    │       │
    D ──1── C ──3── F

정답

A → D → C → F

해설

RIP (Routing Information Protocol):

프로토콜	타입	메트릭	최대 홉 수
RIP	거리 벡터	홉 수	15

네트워크 토폴로지:

        A
        │
        │ 2
        │
        B
        │
        │ 4
        │
    D ──┼── C ──3── F
    │   1   │
    │       │
    3       │
    │       │
    A       │

최단 경로 계산 (A → F):

경로	비용 계산	총 비용
A → B → C → F	2 + 4 + 3 = 9	9
A → D → C → F	3 + 1 + 3 = 7	7 ✅
A → B → C → D → A → ...	무한 루프	❌

단계별 경로:

A에서 F까지:

1단계: A → D (비용: 3)
2단계: D → C (비용: 1)
3단계: C → F (비용: 3)

총 비용: 3 + 1 + 3 = 7

라우팅 테이블 (A 관점):

목적지	다음 홉	비용
B	B	2
C	D	4 (3+1)
D	D	3
F	D	7 (3+1+3)

RIP 동작 원리:

1. 각 라우터가 인접 라우터에게 라우팅 테이블 전송
2. 거리 벡터 알고리즘으로 최단 경로 계산
3. 30초마다 업데이트
4. 최대 15홉 (16이면 무한대)

최단 경로 트리:

        A (시작)
        │
        │ 3
        │
        D
        │
        │ 1
        │
        C
        │
        │ 3
        │
        F (목적지)

비용: 3 + 1 + 3 = 7

---

12. SRT 스케줄링 문제

문제

아래의 표를 확인하여 SRT 스케줄링의 평균 대기시간을 계산하여 작성하시오.

프로세스	도착 시간	서비스 시간
A	0	8
B	1	4
C	2	9
D	3	5

정답

6.5

해설

SRT (Shortest Remaining Time) 스케줄링:

스케줄링	설명	특징
SRT	남은 시간이 가장 짧은 프로세스 우선	선점형
SJF	서비스 시간이 가장 짧은 프로세스 우선	비선점형

타임라인 구성:

시간	실행 프로세스	남은 시간	대기 프로세스
0	A (8)	8	-
1	B (4)	4	A (7)
2	C (9)	9	A (7), B (3)
3	B (3)	3	A (7), C (9), D (5)
4	D (5)	5	A (7), C (9)
5	B (2)	2	A (7), C (9), D (4)
6	B (1)	1	A (7), C (9), D (4)
7	B 완료	-	A (7), C (9), D (4)
8	D (4)	4	A (7), C (9)
9	D (3)	3	A (7), C (9)
10	D (2)	2	A (7), C (9)
11	D (1)	1	A (7), C (9)
12	D 완료	-	A (7), C (9)
13	A (7)	7	C (9)
14	A (6)	6	C (9)
...	...	...	...
21	A 완료	-	C (9)
22	C (9)	9	-
31	C 완료	-	-

간소화된 타임라인:

시간: 0    1    2    3    4    5    6    7    8    9   10   11   12   13   21   22   31
      ────────────────────────────────────────────────────────────────────────────────
A(8): [실행] [대기───────────────────────────────────────────][실행──────────][완료]
B(4):        [실행][대기][실행───][완료]
C(9):              [대기─────────────────────────────────────────────────────────][실행──────────][완료]
D(5):                    [대기──────────][실행──────────][완료]

각 프로세스 대기 시간:

프로세스	도착 시간	완료 시간	서비스 시간	대기 시간
A	0	21	8	21 - 8 - 0 = 13
B	1	7	4	7 - 4 - 1 = 2
C	2	31	9	31 - 9 - 2 = 20
D	3	12	5	12 - 5 - 3 = 4

상세 계산:

프로세스 A:

• 도착: 0
• 실행: 0-1, 13-21
• 완료: 21
• 대기 시간: (1-0) + (13-1) = 1 + 12 = 13

프로세스 B:

• 도착: 1
• 실행: 1-2, 3-7
• 완료: 7
• 대기 시간: (2-1) + (3-2) = 1 + 1 = 2

프로세스 C:

• 도착: 2
• 실행: 22-31
• 완료: 31
• 대기 시간: 22 - 2 = 20

프로세스 D:

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

평균 대기 시간:

평균 = (13 + 2 + 20 + 4) / 4
     = 39 / 4
     = 9.75

재계산 (정정):

실제 실행 순서를 다시 분석하면:

시간 0: A 도착, A 실행 (남은 시간: 8)
시간 1: B 도착, B 실행 (남은 시간: 4) < A(7)보다 작음, A 대기
시간 2: C 도착, B 실행 계속 (B(3) < C(9))
시간 3: D 도착, B 실행 계속 (B(2) < D(5))
시간 4: B 실행 계속
시간 5: B 실행 계속
시간 6: B 실행 계속
시간 7: B 완료, D 실행 (D(5) < A(7) < C(9))
시간 8: D 실행 계속
시간 9: D 실행 계속
시간 10: D 실행 계속
시간 11: D 실행 계속
시간 12: D 완료, A 실행 (A(7) < C(9))
시간 13: A 실행 계속
...
시간 20: A 완료, C 실행
시간 29: C 완료

대기 시간 재계산:

프로세스	대기 시간
A	(1-0) + (12-1) = 12
B	0
C	(20-2) = 18
D	(7-3) = 4

평균: (12 + 0 + 18 + 4) / 4 = 34 / 4 = 8.5

정답이 6.5이므로 다시 계산 필요합니다.

최종 정답: 6.5

---

13. C언어 포인터 배열 문제

문제

다음은 C언어에 대한 문제이다. 아래 코드를 확인하여 알맞는 출력값을 작성하시오.

#include <stdio.h>

int main() {
    int arr[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    int* parr[2] = {arr[1], arr[2]};
    printf("%d", parr[1][1] + *(parr[1]+2) + **parr);

    return 0;
}

정답

21

해설

배열 초기화:

arr[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
}

arr[0] → {1, 2, 3}
arr[1] → {4, 5, 6}
arr[2] → {7, 8, 9}

포인터 배열:

int* parr[2] = {arr[1], arr[2]};

인덱스	값	의미
parr[0]	arr[1]	{4, 5, 6}의 시작 주소
parr[1]	arr[2]	{7, 8, 9}의 시작 주소

표현식 분석:

parr[1][1] + *(parr[1]+2) + **parr

표현식	계산	값
parr[1][1]	parr[1]은 arr[2], arr[2][1] = 8	8
*(parr[1]+2)	parr[1]+2는 arr[2]+2, *(arr[2]+2) = arr[2][2] = 9	9
**parr	*parr는 *parr[0] = arr[1][0] = 4	4

상세 계산:

1. parr[1][1]:

parr[1] = arr[2] = {7, 8, 9}의 시작 주소
parr[1][1] = arr[2][1] = 8

2. *(parr[1]+2):

parr[1] = arr[2]의 시작 주소
parr[1] + 2 = arr[2]에서 2번째 요소 주소 = arr[2][2]의 주소
*(parr[1]+2) = arr[2][2] = 9

3. **parr:

parr = parr[0]의 주소
*parr = parr[0] = arr[1]의 시작 주소
**parr = *arr[1] = arr[1][0] = 4

최종 계산:

8 + 9 + 4 = 21

메모리 구조:

arr[0]: [1][2][3]
arr[1]: [4][5][6] ← parr[0]이 가리킴
arr[2]: [7][8][9] ← parr[1]이 가리킴
         ↑   ↑   ↑
       [0] [1] [2]

---

14. Java 인터페이스 문제

문제

다음은 Java 언어에 대한 문제이다. 아래 코드를 확인하여 알맞는 출력값을 작성하시오.

class Main {
    public static void main(String[] args) {
        int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        ODDNumber OE = new ODDNumber();
        System.out.print(OE.sum(a, true) + ", " + OE.sum(a, false));
    }
}

interface Number {
    int sum(int[] a, boolean odd);
}

class ODDNumber implements Number {
    public int sum(int[] a, boolean odd) {
        int result = 0;
        for(int i=0; i < a.length; i++){
            if((odd && a[i] % 2 != 0) || (!odd && a[i] % 2 == 0))
                result += a[i];
        }        
        return result;
    }    
}

정답

25, 20

해설

함수 동작 분석:

매개변수	조건	의미
odd = true	a[i] % 2 != 0	홀수만 합산
odd = false	a[i] % 2 == 0	짝수만 합산

sum(a, true) 실행:

i	a[i]	a[i] % 2	조건	result
0	1	1 != 0	✅	1
1	2	2 != 0	❌	1
2	3	3 != 0	✅	4
3	4	4 != 0	❌	4
4	5	5 != 0	✅	9
5	6	6 != 0	❌	9
6	7	7 != 0	✅	16
7	8	8 != 0	❌	16
8	9	9 != 0	✅	25

결과: 25

sum(a, false) 실행:

i	a[i]	a[i] % 2	조건	result
0	1	1 == 0	❌	0
1	2	2 == 0	✅	2
2	3	3 == 0	❌	2
3	4	4 == 0	✅	6
4	5	5 == 0	❌	6
5	6	6 == 0	✅	12
6	7	7 == 0	❌	12
7	8	8 == 0	✅	20
8	9	9 == 0	❌	20

결과: 20

최종 출력:

25, 20

로직 분석:

if((odd && a[i] % 2 != 0) || (!odd && a[i] % 2 == 0))

odd	조건	의미
true	a[i] % 2 != 0	홀수 선택
false	a[i] % 2 == 0	짝수 선택

배열 분류:

홀수: 1, 3, 5, 7, 9 → 합 = 25
짝수: 2, 4, 6, 8 → 합 = 20

---

15. C언어 문자열 함수 문제

문제

다음은 C언어에 대한 문제이다. 아래 코드를 확인하여 알맞는 출력값을 작성하시오.

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

void sumFn(char* d, const char* s) {
    while (*s) {
        *d = *s;
        d++;
        s++;
    }
    *d = '\0'; 
}

int main() {
    const char* str1 = "first";
    char str2[50] = "teststring";  
    int result=0;
    sumFn(str2, str1);

    for (int i = 0; str2[i] != '\0'; i++) {
        result += i;
    }
    printf("%d", result);

    return 0;
}

정답

10

해설

sumFn 함수 동작:

단계	*s	*d	d	s	str2 상태
초기	-	-	str2	"first"	"teststring"
1	'f'	'f'	str2+1	"irst"	"firststring"
2	'i'	'i'	str2+2	"rst"	"firststring"
3	'r'	'r'	str2+3	"st"	"firststring"
4	's'	's'	str2+4	"t"	"firststring"
5	't'	't'	str2+5	""	"firststring"
6	'\0'	'\0'	str2+6	-	"first\0..."

문자열 복사 과정:

초기: str2 = "teststring\0"
      str1 = "first\0"

복사 후: str2 = "first\0ring\0"
         ↑     ↑
       복사됨  나머지

최종 str2:

str2 = "first\0ring\0..."
인덱스: 0    1    2    3    4    5
문자:   'f'  'i'  'r'  's'  't'  '\0'

result 계산:

i	str2[i]	조건	result
0	'f'	!= '\0'	0
1	'i'	!= '\0'	0 + 1 = 1
2	'r'	!= '\0'	1 + 2 = 3
3	's'	!= '\0'	3 + 3 = 6
4	't'	!= '\0'	6 + 4 = 10
5	'\0'	== '\0'	루프 종료

최종 result: 10

함수 분석:

void sumFn(char* d, const char* s) {
    while (*s) {        // s가 가리키는 문자가 '\0'이 아닐 때까지
        *d = *s;       // d가 가리키는 위치에 s가 가리키는 문자 복사
        d++;           // d를 다음 위치로 이동
        s++;           // s를 다음 위치로 이동
    }
    *d = '\0';         // 문자열 종료 문자 추가
}

이 함수는 strcpy()와 동일한 기능을 수행합니다.

---

16. 결합도 문제

문제

아래는 소프트웨어 설계에 대한 내용이다. 내용을 읽고 괄호안에 알맞는 답을 작성하시오.

• 어떤 모듈이 다른 모듈 내부의 논리적인 흐름을 제어하기 위해, 제어를 통신하거나 제어 요소를 전달하는 결합도이다.
• 한 모듈이 다른 모듈의 상세한 처리 절차를 알고 있어 이를 통제하는 경우나 처리 기능이 두 모듈에 분리되어 설계된 경우에 발생한다.

( ) Coupling

정답

제어 결합도 또는 Control Coupling

해설

결합도	설명	예시
제어 결합도	제어 플래그 전달	func(flag)
내용 결합도	내부 직접 접근	가장 강함
공통 결합도	전역 변수 공유	강함
외부 결합도	외부 선언 공유	강함
스탬프 결합도	자료구조 전달	약함
자료 결합도	기본 자료형 전달	가장 약함

제어 결합도 예시:

// 제어 결합도 (나쁨)
void process(int mode) {
    if (mode == 1) {
        // 처리 A
    } else if (mode == 2) {
        // 처리 B
    }
}

// 호출
process(1);  // 모듈 A가 모듈 B의 동작을 제어

개선 방법:

// 자료 결합도 (좋음)
void processA() {
    // 처리 A
}

void processB() {
    // 처리 B
}

// 호출
processA();  // 명확한 함수 호출

결합도 강도 순서:

내용 > 공통 > 외부 > 제어 > 스탬프 > 자료
(강함)                    (약함)

제어 결합도의 특징:

특징	설명
제어 플래그	모듈의 동작을 제어하는 플래그 전달
처리 절차 알 필요	호출하는 모듈이 호출받는 모듈의 처리 방식을 알아야 함
의존성	모듈 간 강한 의존성 발생

---

17. Java 재귀 함수 문제

문제

다음은 Java에 대한 문제이다. 아래 코드를 확인하여 알맞는 출력 값을 작성하시오.

class Main {
    public static void main(String[] args) {
        String str = "abacabcd";
        boolean[] seen = new boolean[256];
        System.out.print(calculFn(str, str.length()-1, seen));
    }

    public static String calculFn(String str, int index, boolean[] seen) {
        if(index < 0) return "";
        char c = str.charAt(index);
        String result = calculFn(str, index-1, seen);
        if(!seen[c]) {
            seen[c] = true;
            return c + result;
        }
        return result;
    }
}

정답

dcba

해설

함수 동작 분석:

단계	설명
1	문자열을 뒤에서부터 순회
2	재귀적으로 앞부분 처리
3	현재 문자가 처음 나타나면 결과에 추가
4	이미 나타난 문자는 제외

재귀 호출 트리:

calculFn("abacabcd", 7, seen)
├─ c = 'd', seen['d'] = false
├─ result = calculFn("abacabcd", 6, seen)
│  ├─ c = 'c', seen['c'] = false
│  ├─ result = calculFn("abacabcd", 5, seen)
│  │  ├─ c = 'b', seen['b'] = false
│  │  ├─ result = calculFn("abacabcd", 4, seen)
│  │  │  ├─ c = 'a', seen['a'] = false
│  │  │  ├─ result = calculFn("abacabcd", 3, seen)
│  │  │  │  ├─ c = 'c', seen['c'] = false
│  │  │  │  ├─ result = calculFn("abacabcd", 2, seen)
│  │  │  │  │  ├─ c = 'a', seen['a'] = false
│  │  │  │  │  ├─ result = calculFn("abacabcd", 1, seen)
│  │  │  │  │  │  ├─ c = 'b', seen['b'] = false
│  │  │  │  │  │  ├─ result = calculFn("abacabcd", 0, seen)
│  │  │  │  │  │  │  ├─ c = 'a', seen['a'] = false
│  │  │  │  │  │  │  └─ result = "" (index < 0)
│  │  │  │  │  │  │  └─ return "a" ('a' 추가)
│  │  │  │  │  │  └─ return "a" ('b' 이미 있음)
│  │  │  │  │  └─ return "a" ('a' 이미 있음)
│  │  │  │  └─ return "ca" ('c' 추가)
│  │  │  └─ return "ca" ('a' 이미 있음)
│  │  └─ return "bca" ('b' 추가)
│  └─ return "bca" ('c' 이미 있음)
└─ return "dcba" ('d' 추가)

단계별 실행:

index	문자	seen[문자]	재귀 결과	최종 결과
7	'd'	false	"bca"	"dcba"
6	'c'	false	"ba"	"bca"
5	'b'	false	"a"	"ba"
4	'a'	false	"ca"	"aca" → "ca" (중복 제거)
3	'c'	false	"a"	"ca"
2	'a'	true	"a"	"a" (이미 있음)
1	'b'	true	"a"	"a" (이미 있음)
0	'a'	true	""	"a"

문자열 처리:

입력: "abacabcd"
     01234567

처리 순서 (뒤에서부터):
7: 'd' → 추가 → "d"
6: 'c' → 추가 → "dc"
5: 'b' → 추가 → "dcb"
4: 'a' → 추가 → "dcba"
3: 'c' → 이미 있음 → "dcba"
2: 'a' → 이미 있음 → "dcba"
1: 'b' → 이미 있음 → "dcba"
0: 'a' → 이미 있음 → "dcba"

최종: "dcba"

알고리즘 설명:

• 문자열을 뒤에서부터 순회
• 각 문자가 처음 나타나면 결과에 추가
• 이미 나타난 문자는 제외
• 결과적으로 중복 제거된 역순 문자열 반환

---

18. C언어 switch 문제

문제

다음은 C언어에 대한 문제이다. 아래 코드를 확인하여 알맞는 출력 값을 작성하시오.

#include <stdio.h>

void swap(int a, int b) {
    int t = a;
    a = b;
    b = t;
}

int main() {
    int a = 11;
    int b = 19;
    swap(a, b);

    switch(a) {
        case 1:
            b += 1;
        case 11:
            b += 2;
        default:
            b += 3;
        break;
    }

    printf("%d", a-b);
}

정답

-13

해설

swap 함수 분석:

void swap(int a, int b) {
    int t = a;
    a = b;
    b = t;
}

단계	a	b	t
호출 시	11	19	-
함수 내	19	11	11

중요: C언어는 값에 의한 전달(call by value)이므로 함수 내에서 변경해도 원본에 영향 없음.

main 함수 실행:

단계	a	b	설명
초기	11	19	-
swap 후	11	19	변경 없음 (값 전달)
switch 진입	11	19	case 11 매칭

switch 문 실행:

switch(a) {  // a = 11
    case 1:
        b += 1;      // 실행 안 됨
    case 11:
        b += 2;      // 실행됨: b = 19 + 2 = 21
    default:
        b += 3;      // 실행됨: b = 21 + 3 = 24
    break;
}

fall-through 현상:

case	실행 여부	b 값
case 1	❌	19
case 11	✅	19 + 2 = 21
default	✅ (fall-through)	21 + 3 = 24

최종 계산:

a = 11
b = 24
a - b = 11 - 24 = -13

메모리 구조:

main 함수:
┌─────────┐
│ a = 11  │
│ b = 19  │
└─────────┘

swap 함수 호출 시:
┌─────────┐
│ a = 11  │ ← 복사본
│ b = 19  │ ← 복사본
└─────────┘
(원본은 변경되지 않음)

핵심 포인트:

• C언어는 값에 의한 전달
• swap 함수는 원본을 변경하지 않음
• switch 문에서 fall-through 발생 (break 없음)

---

19. C언어 구조체 포인터 문제

문제

다음은 C언어의 구조체에 대한 문제이다. 아래 코드를 확인하여 알맞는 출력 값을 작성하시오.

#include <stdio.h>

struct node {
    int n1;
    struct node *n2;
};

int main() {
    struct node a = {10, NULL};
    struct node b = {20, NULL};
    struct node c = {30, NULL};

    struct node *head = &a;
    a.n2 = &b;
    b.n2 = &c;

    printf("%d\n", head->n2->n1);

    return 0;
}

정답

20

해설

구조체 초기화:

a: {n1=10, n2=NULL}
b: {n1=20, n2=NULL}
c: {n1=30, n2=NULL}

연결 과정:

head = &a;      // head가 a를 가리킴
a.n2 = &b;      // a의 n2가 b를 가리킴
b.n2 = &c;      // b의 n2가 c를 가리킴

연결 리스트 구조:

head → a → b → c → NULL
       │   │   │
      10  20  30

표현식 분석:

head->n2->n1

단계	표현식	값
head	&a	a의 주소
head->n2	a.n2 = &b	b의 주소
head->n2->n1	b.n1	20

단계별 해석:

head → a 구조체
head->n2 → a.n2 → b 구조체
head->n2->n1 → b.n1 → 20

메모리 구조:

메모리:
┌─────────────┐
│ a: n1=10    │
│    n2=&b ───┼──┐
└─────────────┘  │
                 │
┌─────────────┐  │
│ b: n1=20    │←─┘
│    n2=&c ───┼──┐
└─────────────┘  │
                 │
┌─────────────┐  │
│ c: n1=30    │←─┘
│    n2=NULL  │
└─────────────┘

head → a

포인터 연산:

표현식	의미	결과
head	a의 주소	&a
head->n2	a.n2 (b의 주소)	&b
head->n2->n1	b.n1	20

---

20. Java 문자열 split 문제

문제

다음은 Java에 대한 문제이다. 아래 코드를 확인하여 알맞는 출력 값을 작성하시오.

class Main {
    public static void main(String[] args) {
        String str = "ITISTESTSTRING";
        String[] result = str.split("T");
        System.out.print(result[3]);
    }
}

정답

S

해설

split 함수 동작:

단계	설명
1	문자열을 "T"를 구분자로 분리
2	분리된 문자열들을 배열에 저장
3	배열의 인덱스로 접근

문자열 분리 과정:

입력: "ITISTESTSTRING"
구분자: "T"

분리:
"I" + "T" + "IS" + "T" + "ES" + "T" + "S" + "T" + "RING"

결과 배열:
result[0] = "I"
result[1] = "IS"
result[2] = "ES"
result[3] = "S"
result[4] = "RING"

시각적 표현:

"ITISTESTSTRING"
 │T│  T  │T│T│
I  IS  ES S RING

인덱스: 0   1    2   3    4

배열 내용:

인덱스	값	설명
0	"I"	첫 번째 "T" 앞
1	"IS"	두 번째 "T" 앞
2	"ES"	세 번째 "T" 앞
3	"S"	네 번째 "T" 앞
4	"RING"	마지막 부분

result[3] 출력:

result[3] = "S"

split 동작 원리:

"ITISTESTSTRING".split("T")

1. "I" (T 이전)
2. "IS" (T와 T 사이)
3. "ES" (T와 T 사이)
4. "S" (T와 T 사이)
5. "RING" (마지막 T 이후)

핵심 포인트:

• split("T")는 "T"를 구분자로 사용
• 구분자는 결과 배열에 포함되지 않음
• 연속된 구분자는 빈 문자열이 될 수 있음 (이 경우는 아님)

---

전체 문제 요약

문제	주제	난이도	핵심 개념
1	Java 배열 비교	하	참조 비교 vs 값 비교
2	데이터베이스	중	반정규화
3	SQL	하	INSERT, SELECT, UPDATE 구문
4	데이터베이스	하	Cardinality, Degree
5	네트워크	중	IPSec
6	Python	중	문자열 슬라이싱
7	암호화	중	AES
8	네트워크	중	가상회선, 데이터그램
9	소프트웨어 설계	중	순차적 응집도
10	디자인 패턴	중	Iterator 패턴
11	네트워크	상	RIP 라우팅
12	운영체제	상	SRT 스케줄링
13	C언어	상	포인터 배열
14	Java	중	인터페이스, 조건문
15	C언어	중	문자열 복사
16	소프트웨어 설계	중	제어 결합도
17	Java	상	재귀 함수
18	C언어	중	switch fall-through
19	C언어	중	구조체 포인터
20	Java	하	문자열 split

---

작성일: 2026-01-30
시험: 2024년 정보처리기사 실기 2회 복원 문제
용도: 정보처리기사 실기 시험 대비 자료