🔎 전북과학고 정보수업 정렬과 탐색 OOP코드 수행평가

🌈 학습 목표

정렬과 탐색은 데이터를 효율적으로 다루기 위한 핵심 알고리즘입니다. 이 자료는 기초 개념 5개, 개념 응용 5개, 실생활 심화 활용 5개로 나누어 객체지향 프로그래밍 방식으로 정리했습니다.

1. 숫자 리스트 오름차순·내림차순 정렬

class NumberSorter:
    def __init__(self, numbers):
        self.numbers = numbers

    def ascending(self):
        return sorted(self.numbers)

    def descending(self):
        return sorted(self.numbers, reverse=True)

sorter = NumberSorter([8, 3, 1, 9, 5])

print("오름차순:", sorter.ascending())
print("내림차순:", sorter.descending())

2. 문자열 알파벳순 정렬

class WordAlphabetSorter:
    def __init__(self, words):
        self.words = words

    def sort_words(self):
        return sorted(self.words)

    def reverse_words(self):
        return sorted(self.words, reverse=True)

words = WordAlphabetSorter(["banana", "apple", "cherry", "date"])

print(words.sort_words())
print(words.reverse_words())

3. 순차 탐색으로 값 찾기

class LinearSearch:
    def __init__(self, data):
        self.data = data

    def find(self, target):
        for index, value in enumerate(self.data):
            if value == target:
                return index
        return -1

searcher = LinearSearch([10, 20, 30, 40, 50])

print(searcher.find(30))
print(searcher.find(99))

4. 최댓값과 최솟값 찾기

class MinMaxFinder:
    def __init__(self, numbers):
        self.numbers = numbers

    def minimum(self):
        return min(self.numbers)

    def maximum(self):
        return max(self.numbers)

finder = MinMaxFinder([42, 17, 88, 23, 65])

print("최솟값:", finder.minimum())
print("최댓값:", finder.maximum())

5. 문자열 길이 기준 정렬

class WordLengthSorter:
    def __init__(self, words):
        self.words = words

    def sort_by_length(self):
        return sorted(self.words, key=len)

    def longest(self):
        return max(self.words, key=len)

words = WordLengthSorter(["AI", "Python", "Data", "Algorithm"])

print(words.sort_by_length())
print("가장 긴 단어:", words.longest())

6. 학생 점수 기준 순위 정렬

class StudentRanker:
    def __init__(self, students):
        self.students = students

    def rank(self):
        return sorted(self.students, key=lambda x: x["점수"], reverse=True)

    def top_student(self):
        return self.rank()[0]

students = [
    {"이름": "김민수", "점수": 88},
    {"이름": "이지은", "점수": 95},
    {"이름": "박서준", "점수": 76}
]

ranker = StudentRanker(students)

print(ranker.rank())
print("1등:", ranker.top_student())

7. 이진 탐색으로 빠르게 찾기

class BinarySearch:
    def __init__(self, sorted_data):
        self.data = sorted_data

    def find(self, target):
        left = 0
        right = len(self.data) - 1

        while left <= right:
            mid = (left + right) // 2

            if self.data[mid] == target:
                return mid
            elif self.data[mid] < target:
                left = mid + 1
            else:
                right = mid - 1

        return -1

searcher = BinarySearch([1, 3, 5, 7, 9, 11, 13])

print(searcher.find(9))
print(searcher.find(4))

8. 상품 가격 정렬과 최저가 탐색

class ProductAnalyzer:
    def __init__(self, products):
        self.products = products

    def sort_by_price(self):
        return sorted(self.products, key=lambda x: x["가격"])

    def cheapest(self):
        return self.sort_by_price()[0]

products = [
    {"상품": "노트북", "가격": 1200000},
    {"상품": "마우스", "가격": 25000},
    {"상품": "키보드", "가격": 70000}
]

analyzer = ProductAnalyzer(products)

print(analyzer.sort_by_price())
print("최저가 상품:", analyzer.cheapest())

9. 키워드 포함 도서 검색

class BookSearch:
    def __init__(self, books):
        self.books = books

    def search_keyword(self, keyword):
        return [book for book in self.books if keyword in book["제목"]]

    def sort_by_year(self):
        return sorted(self.books, key=lambda x: x["연도"])

books = [
    {"제목": "파이썬 알고리즘", "연도": 2021},
    {"제목": "자료구조 입문", "연도": 2019},
    {"제목": "알고리즘 심화", "연도": 2023}
]

library = BookSearch(books)

print(library.search_keyword("알고리즘"))
print(library.sort_by_year())

10. 중복 제거 후 정렬

class UniqueSorter:
    def __init__(self, data):
        self.data = data

    def unique_sorted(self):
        return sorted(set(self.data))

    def count_unique(self):
        return len(set(self.data))

numbers = UniqueSorter([3, 1, 2, 3, 2, 5, 1, 4])

print(numbers.unique_sorted())
print("고유값 개수:", numbers.count_unique())

11. 택배 배송 우선순위 정렬

class DeliveryScheduler:
    def __init__(self, orders):
        self.orders = orders

    def sort_by_priority(self):
        return sorted(
            self.orders,
            key=lambda x: (x["긴급도"], x["거리"]),
            reverse=False
        )

    def next_delivery(self):
        return self.sort_by_priority()[0]

orders = [
    {"주문번호": "A01", "긴급도": 2, "거리": 5},
    {"주문번호": "B02", "긴급도": 1, "거리": 8},
    {"주문번호": "C03", "긴급도": 1, "거리": 3}
]

scheduler = DeliveryScheduler(orders)

print(scheduler.sort_by_priority())
print("다음 배송:", scheduler.next_delivery())

12. 병원 환자 대기열 정렬

class PatientQueue:
    def __init__(self, patients):
        self.patients = patients

    def sort_by_severity(self):
        return sorted(
            self.patients,
            key=lambda x: (-x["위급도"], x["도착순서"])
        )

    def next_patient(self):
        return self.sort_by_severity()[0]

patients = [
    {"이름": "환자A", "위급도": 3, "도착순서": 1},
    {"이름": "환자B", "위급도": 5, "도착순서": 2},
    {"이름": "환자C", "위급도": 5, "도착순서": 1}
]

queue = PatientQueue(patients)

print(queue.sort_by_severity())
print("다음 진료:", queue.next_patient())

13. 검색 엔진 결과 정렬

class SearchEngine:
    def __init__(self, pages):
        self.pages = pages

    def search(self, keyword):
        result = []
        for page in self.pages:
            if keyword in page["제목"] or keyword in page["내용"]:
                result.append(page)
        return sorted(result, key=lambda x: x["점수"], reverse=True)

pages = [
    {"제목": "파이썬 기초", "내용": "정렬과 탐색 설명", "점수": 80},
    {"제목": "알고리즘 심화", "내용": "이진 탐색과 정렬", "점수": 95},
    {"제목": "웹 디자인", "내용": "HTML CSS", "점수": 70}
]

engine = SearchEngine(pages)

print(engine.search("탐색"))

14. 성적 데이터에서 등급별 탐색과 정렬

class GradeAnalyzer:
    def __init__(self, students):
        self.students = students

    def add_grade(self):
        for student in self.students:
            score = student["점수"]
            if score >= 90:
                student["등급"] = "A"
            elif score >= 80:
                student["등급"] = "B"
            else:
                student["등급"] = "C"
        return self.students

    def search_grade(self, grade):
        return [s for s in self.students if s.get("등급") == grade]

    def sort_by_score(self):
        return sorted(self.students, key=lambda x: x["점수"], reverse=True)

students = [
    {"이름": "김", "점수": 95},
    {"이름": "이", "점수": 84},
    {"이름": "박", "점수": 76},
    {"이름": "최", "점수": 91}
]

analyzer = GradeAnalyzer(students)
analyzer.add_grade()

print("A등급:", analyzer.search_grade("A"))
print("점수순:", analyzer.sort_by_score())

15. 로그 데이터 오류 탐색과 시간 정렬

class LogAnalyzer:
    def __init__(self, logs):
        self.logs = logs

    def search_error(self):
        return [log for log in self.logs if log["상태"] == "ERROR"]

    def sort_by_time(self):
        return sorted(self.logs, key=lambda x: x["시간"])

    def latest_error(self):
        errors = self.search_error()
        if not errors:
            return None
        return sorted(errors, key=lambda x: x["시간"], reverse=True)[0]

logs = [
    {"시간": "09:10", "상태": "OK", "메시지": "start"},
    {"시간": "09:15", "상태": "ERROR", "메시지": "file missing"},
    {"시간": "09:12", "상태": "OK", "메시지": "load"},
    {"시간": "09:20", "상태": "ERROR", "메시지": "timeout"}
]

analyzer = LogAnalyzer(logs)

print("오류 로그:", analyzer.search_error())
print("시간순:", analyzer.sort_by_time())
print("최근 오류:", analyzer.latest_error())

🧭 전체 예제 요약표

🎯 심화 탐구 과제

1. 이진 탐색 코드에 탐색 과정 출력 기능을 추가하라.
2. 학생 점수 정렬에서 동점자는 이름순으로 정렬하도록 바꾸어라.
3. 택배 배송 우선순위에 배송 마감 시간을 추가하라.
4. 검색 엔진 예제에 키워드 등장 횟수 기반 점수 계산을 추가하라.
5. 로그 분석 클래스에 WARNING 탐색과 시간 구간 필터링을 추가하라.