정보처리기사 실기시험 해설

정보처리기사 실기시험 해설

---

문제 1 해설: 배열 처리 알고리즘 (20점)

전체 코드

public class ArrayProblem {
    public static void main(String[] args) {
        int[] arr = {3, 7, 2, 9, 1, 5, 8, 4, 6};

        // 1. 최댓값과 최솟값 찾기
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        System.out.println("최댓값: " + max);
        System.out.println("최솟값: " + min);

        // 2. 평균값 계산
        int sum = 0;
        for (int num : arr) {
            sum += num;
        }
        double average = (double) sum / arr.length;
        System.out.printf("평균값: %.2f\n", average);

        // 3. 짝수만 필터링
        int evenCount = 0;
        for (int num : arr) {
            if (num % 2 == 0) {
                evenCount++;
            }
        }
        int[] evenArr = new int[evenCount];
        int index = 0;
        for (int num : arr) {
            if (num % 2 == 0) {
                evenArr[index++] = num;
            }
        }
        System.out.print("짝수 배열: [");
        for (int i = 0; i < evenArr.length; i++) {
            System.out.print(evenArr[i]);
            if (i < evenArr.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");

        // 4. 오름차순 정렬 (버블 정렬)
        int[] sortedArr = arr.clone(); // 원본 배열 복사
        for (int i = 0; i < sortedArr.length - 1; i++) {
            for (int j = 0; j < sortedArr.length - 1 - i; j++) {
                if (sortedArr[j] > sortedArr[j + 1]) {
                    int temp = sortedArr[j];
                    sortedArr[j] = sortedArr[j + 1];
                    sortedArr[j + 1] = temp;
                }
            }
        }
        System.out.print("정렬된 배열: [");
        for (int i = 0; i < sortedArr.length; i++) {
            System.out.print(sortedArr[i]);
            if (i < sortedArr.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }
}

더 간단한 방법 (Java API 사용)

import java.util.Arrays;

public class ArrayProblemSimple {
    public static void main(String[] args) {
        int[] arr = {3, 7, 2, 9, 1, 5, 8, 4, 6};

        // 1. 최댓값과 최솟값
        int max = Arrays.stream(arr).max().orElse(0);
        int min = Arrays.stream(arr).min().orElse(0);
        System.out.println("최댓값: " + max);
        System.out.println("최솟값: " + min);

        // 2. 평균값
        double average = Arrays.stream(arr).average().orElse(0.0);
        System.out.printf("평균값: %.2f\n", average);

        // 3. 짝수 필터링
        int[] evenArr = Arrays.stream(arr)
            .filter(n -> n % 2 == 0)
            .toArray();
        System.out.println("짝수 배열: " + Arrays.toString(evenArr));

        // 4. 정렬
        int[] sortedArr = arr.clone();
        Arrays.sort(sortedArr);
        System.out.println("정렬된 배열: " + Arrays.toString(sortedArr));
    }
}

핵심 포인트

1. 최댓값/최솟값: 첫 번째 요소를 초기값으로 설정하고 배열을 순회하며 비교
2. 평균값: 합계를 배열 길이로 나눔 (정수 나눗셈 주의)
3. 짝수 필터링: % 2 == 0 조건 사용
4. 정렬: 버블 정렬 또는 Arrays.sort() 사용

---

문제 2 해설: 문자열 처리 알고리즘 (20점)

전체 코드

public class StringProblem {
    public static void main(String[] args) {
        String text = "Hello World Java Programming";

        // 1. 공백 기준으로 단어 분리
        String[] words = text.split(" ");
        System.out.print("단어 배열: [");
        for (int i = 0; i < words.length; i++) {
            System.out.print(words[i]);
            if (i < words.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");

        // 2. 각 단어의 길이 계산
        int[] lengths = new int[words.length];
        for (int i = 0; i < words.length; i++) {
            lengths[i] = words[i].length();
        }
        System.out.print("각 단어의 길이: [");
        for (int i = 0; i < lengths.length; i++) {
            System.out.print(lengths[i]);
            if (i < lengths.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");

        // 3. 대문자로 시작하는 단어 필터링
        System.out.print("대문자로 시작하는 단어: [");
        boolean first = true;
        for (String word : words) {
            if (word.length() > 0 && Character.isUpperCase(word.charAt(0))) {
                if (!first) {
                    System.out.print(", ");
                }
                System.out.print(word);
                first = false;
            }
        }
        System.out.println("]");

        // 4. 모든 단어를 역순으로 출력
        System.out.print("역순 문자열: ");
        for (int i = 0; i < words.length; i++) {
            String reversed = reverseString(words[i]);
            System.out.print(reversed);
            if (i < words.length - 1) {
                System.out.print(" ");
            }
        }
        System.out.println();
    }

    // 문자열을 역순으로 만드는 메서드
    private static String reverseString(String str) {
        char[] chars = str.toCharArray();
        int left = 0;
        int right = chars.length - 1;
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
        return new String(chars);
    }
}

더 간단한 방법

public class StringProblemSimple {
    public static void main(String[] args) {
        String text = "Hello World Java Programming";

        // 1. 단어 분리
        String[] words = text.split(" ");
        System.out.println("단어 배열: " + java.util.Arrays.toString(words));

        // 2. 길이 계산
        int[] lengths = java.util.Arrays.stream(words)
            .mapToInt(String::length)
            .toArray();
        System.out.println("각 단어의 길이: " + java.util.Arrays.toString(lengths));

        // 3. 대문자로 시작하는 단어
        String[] upperWords = java.util.Arrays.stream(words)
            .filter(w -> w.length() > 0 && Character.isUpperCase(w.charAt(0)))
            .toArray(String[]::new);
        System.out.println("대문자로 시작하는 단어: " + java.util.Arrays.toString(upperWords));

        // 4. 역순 출력
        String reversed = java.util.Arrays.stream(words)
            .map(w -> new StringBuilder(w).reverse().toString())
            .reduce((a, b) -> a + " " + b)
            .orElse("");
        System.out.println("역순 문자열: " + reversed);
    }
}

핵심 포인트

1. 단어 분리: split(" ") 메서드 사용
2. 문자열 길이: length() 메서드 사용
3. 대문자 확인: Character.isUpperCase(char) 사용
4. 문자열 역순: 문자 배열로 변환 후 인덱스 교환 또는 StringBuilder.reverse() 사용

---

문제 3 해설: 반복문과 조건문 활용 (20점)

전체 코드

import java.util.ArrayList;
import java.util.List;

public class LoopProblem {
    public static void main(String[] args) {
        // 1. 3과 5의 공배수
        List<Integer> commonMultiples = new ArrayList<>();
        for (int i = 1; i <= 100; i++) {
            if (i % 3 == 0 && i % 5 == 0) {
                commonMultiples.add(i);
            }
        }
        System.out.println("3과 5의 공배수: " + commonMultiples);

        // 2. 소수 찾기
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= 100; i++) {
            if (isPrime(i)) {
                primes.add(i);
            }
        }
        System.out.println("소수: " + primes);

        // 3. 자릿수 합이 10 이상인 수
        List<Integer> digitSum10 = new ArrayList<>();
        for (int i = 1; i <= 100; i++) {
            if (sumOfDigits(i) >= 10) {
                digitSum10.add(i);
            }
        }
        System.out.println("자릿수 합이 10 이상인 수: " + digitSum10);
    }

    // 소수 판별 메서드
    private static boolean isPrime(int n) {
        if (n < 2) {
            return false;
        }
        if (n == 2) {
            return true;
        }
        if (n % 2 == 0) {
            return false;
        }
        // 3부터 √n까지 홀수만 확인
        for (int i = 3; i * i <= n; i += 2) {
            if (n % i == 0) {
                return false;
            }
        }
        return true;
    }

    // 자릿수 합 계산 메서드
    private static int sumOfDigits(int n) {
        int sum = 0;
        while (n > 0) {
            sum += n % 10;  // 일의 자리 추출
            n /= 10;        // 일의 자리 제거
        }
        return sum;
    }
}

핵심 포인트

1. 공배수: i % 3 == 0 && i % 5 == 0 조건 사용
2. 소수 판별:
   • 2는 소수
   • 짝수는 소수가 아님 (2 제외)
   • 3부터 √n까지 홀수만 확인하여 효율성 향상
3. 자릿수 합:
   • n % 10으로 일의 자리 추출
   • n /= 10으로 일의 자리 제거
   • 반복하여 모든 자릿수 합 계산

---

문제 4 해설: 데이터베이스 SQL 작성 (20점)

1. 컴퓨터공학과 학생들의 평균 점수

SELECT AVG(SCORE) AS 평균점수
FROM STUDENT
WHERE DEPARTMENT = '컴퓨터공학';

결과:

평균점수
87.0

2. 각 학과별 학생 수와 평균 점수

SELECT 
    DEPARTMENT AS 학과,
    COUNT(*) AS 학생수,
    AVG(SCORE) AS 평균점수
FROM STUDENT
GROUP BY DEPARTMENT;

결과:

학과          학생수  평균점수
컴퓨터공학    4      87.0
전자공학      3      89.0
기계공학      1      82.0

3. 점수가 85점 이상인 학생의 이름과 점수

SELECT NAME, SCORE
FROM STUDENT
WHERE SCORE >= 85
ORDER BY SCORE DESC;

결과:

NAME    SCORE
정수진  95
이영희  92
송미영  90
최지영  88
윤태호  87
김철수  85

4. 나이가 21세 이상인 학생 중 점수가 가장 높은 학생

SELECT *
FROM STUDENT
WHERE AGE >= 21
ORDER BY SCORE DESC
LIMIT 1;

또는 서브쿼리 사용:

SELECT *
FROM STUDENT
WHERE AGE >= 21
  AND SCORE = (
      SELECT MAX(SCORE)
      FROM STUDENT
      WHERE AGE >= 21
  );

결과:

STUDENT_ID  NAME    AGE  DEPARTMENT  SCORE
5           정수진   21   컴퓨터공학   95

SQL 핵심 포인트

1. 집계 함수: AVG(), COUNT(), MAX(), MIN(), SUM()
2. GROUP BY: 그룹별 집계 시 사용
3. WHERE: 조건 필터링
4. ORDER BY: 정렬 (ASC: 오름차순, DESC: 내림차순)
5. LIMIT: 결과 개수 제한
6. 서브쿼리: 복잡한 조건 처리 시 사용

---

문제 5 해설: 업무 프로세스 및 신기술 용어 (20점)

5-1. 업무 프로세스 (10점)

[주문 접수] → [①재고 확인] → [②결제 확인] → [배송 준비] → [배송] → [③배송 완료]

해설:

• 온라인 쇼핑몰의 주문 처리 프로세스는 다음과 같은 순서로 진행됩니다:
  1. 주문 접수: 고객이 주문을 요청
  2. 재고 확인: 주문한 상품의 재고 확인
  3. 결제 확인: 결제가 완료되었는지 확인
  4. 배송 준비: 상품 포장 및 배송 준비
  5. 배송: 물류 시스템을 통한 배송
  6. 배송 완료: 고객이 상품을 수령

5-2. 신기술 용어 설명 (10점)

1. DevOps

답: 개발(Development)과 운영(Operations)을 결합한 문화 및 방법론으로, 개발팀과 운영팀 간의 협업을 강화하여 소프트웨어 개발과 배포 프로세스를 자동화하고 효율화하는 것을 목표로 합니다.

2. CI/CD

답:

• CI (Continuous Integration): 개발자들이 코드 변경사항을 공유 저장소에 자주 병합하고, 자동화된 빌드 및 테스트를 통해 통합 오류를 조기에 발견하는 개발 방법론입니다.
• CD (Continuous Deployment/Delivery): CI를 통해 통합된 코드를 자동으로 테스트, 빌드, 배포하는 프로세스입니다.

3. 마이크로서비스 아키텍처(Microservices Architecture)

답: 하나의 큰 애플리케이션을 작은 독립적인 서비스들로 분해하여 개발하고 배포하는 아키텍처 패턴입니다. 각 서비스는 독립적으로 개발, 배포, 확장이 가능하며, API를 통해 통신합니다.

4. 컨테이너화(Containerization)

답: 애플리케이션과 그 실행 환경을 하나의 패키지로 묶어 어느 환경에서든 동일하게 실행할 수 있도록 하는 기술입니다. Docker가 대표적인 컨테이너 기술이며, 가상머신보다 가볍고 빠르게 동작합니다.

5. API Gateway

답: 클라이언트와 백엔드 서비스 사이에서 모든 API 요청을 중앙에서 관리하는 단일 진입점 역할을 하는 서버입니다. 라우팅, 인증/인가, 로드 밸런싱, 모니터링 등의 기능을 제공합니다.

---

문제 6 해설: 종합 알고리즘 문제 (20점)

전체 코드

public class StudentManagement {
    public static void main(String[] args) {
        String[] names = {"김철수", "이영희", "박민수", "최지영", "정수진"};
        int[] scores = {85, 92, 78, 88, 95};

        // 1. 평균 점수 계산
        int sum = 0;
        for (int score : scores) {
            sum += score;
        }
        double average = (double) sum / scores.length;
        System.out.printf("평균 점수: %.1f\n", average);

        // 2. 평균 이상 학생 출력
        System.out.println("평균 이상 학생:");
        for (int i = 0; i < names.length; i++) {
            if (scores[i] >= average) {
                System.out.println("  " + names[i] + ": " + scores[i] + "점");
            }
        }

        // 3. 등급 부여 및 집계
        int[] gradeCount = new int[4]; // A, B, C, D
        String[] grades = new String[names.length];

        for (int i = 0; i < scores.length; i++) {
            if (scores[i] >= 90) {
                grades[i] = "A";
                gradeCount[0]++;
            } else if (scores[i] >= 80) {
                grades[i] = "B";
                gradeCount[1]++;
            } else if (scores[i] >= 70) {
                grades[i] = "C";
                gradeCount[2]++;
            } else {
                grades[i] = "D";
                gradeCount[3]++;
            }
        }

        // 4. 등급별 학생 수 출력
        System.out.println("\n등급별 학생 수:");
        System.out.println("  A등급: " + gradeCount[0] + "명");
        System.out.println("  B등급: " + gradeCount[1] + "명");
        System.out.println("  C등급: " + gradeCount[2] + "명");
        System.out.println("  D등급: " + gradeCount[3] + "명");
    }
}

더 객체지향적인 방법

class Student {
    String name;
    int score;
    String grade;

    Student(String name, int score) {
        this.name = name;
        this.score = score;
        this.grade = calculateGrade(score);
    }

    private String calculateGrade(int score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        return "D";
    }
}

public class StudentManagementOOP {
    public static void main(String[] args) {
        Student[] students = {
            new Student("김철수", 85),
            new Student("이영희", 92),
            new Student("박민수", 78),
            new Student("최지영", 88),
            new Student("정수진", 95)
        };

        // 평균 계산
        double average = java.util.Arrays.stream(students)
            .mapToInt(s -> s.score)
            .average()
            .orElse(0.0);
        System.out.printf("평균 점수: %.1f\n", average);

        // 평균 이상 학생
        System.out.println("평균 이상 학생:");
        java.util.Arrays.stream(students)
            .filter(s -> s.score >= average)
            .forEach(s -> System.out.println("  " + s.name + ": " + s.score + "점"));

        // 등급별 집계
        long aCount = java.util.Arrays.stream(students).filter(s -> s.grade.equals("A")).count();
        long bCount = java.util.Arrays.stream(students).filter(s -> s.grade.equals("B")).count();
        long cCount = java.util.Arrays.stream(students).filter(s -> s.grade.equals("C")).count();
        long dCount = java.util.Arrays.stream(students).filter(s -> s.grade.equals("D")).count();

        System.out.println("\n등급별 학생 수:");
        System.out.println("  A등급: " + aCount + "명");
        System.out.println("  B등급: " + bCount + "명");
        System.out.println("  C등급: " + cCount + "명");
        System.out.println("  D등급: " + dCount + "명");
    }
}

핵심 포인트

1. 평균 계산: 합계를 학생 수로 나눔
2. 조건 필터링: 평균 이상 학생만 출력
3. 등급 부여: if-else if 문으로 점수 범위에 따라 등급 결정
4. 집계: 등급별로 카운트하여 출력

---

전체 문제 해설 요약

공통 주의사항

1. 변수 초기화: 반복문에서 사용하는 변수는 적절히 초기화
2. 배열 인덱스: 배열 범위를 벗어나지 않도록 주의
3. 타입 변환: 정수 나눗셈 시 실수 결과가 필요하면 형변환 필요
4. 출력 형식: 문제에서 요구한 출력 형식을 정확히 맞춤
5. 예외 처리: 배열이 비어있거나 null인 경우 처리

실기 시험 팁

1. 시간 관리: 각 문제당 약 25분 할당
2. 코드 구조: 명확한 변수명과 주석 사용
3. 부분 점수: 완전하지 않아도 부분적으로 맞으면 점수 획득 가능
4. 디버깅: 간단한 테스트 케이스로 검증
5. SQL 문법: 표준 SQL 문법 사용 (DBMS별 차이 주의)