from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ 주어진 숫자 리스트에서 임계값보다 더 가까운 두 숫자가 있는지 확인합니다.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ 주어진 숫자 목록에서 주어진 임계값보다 서로 더 가까운 두 숫자가 있는지 확인합니다.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ 주어진 숫자 리스트에서 주어진 임계값보다 더 가까운 두 숫자가
    있는지 확인합니다.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ 이 함수의 입력은 중첩된 괄호의 여러 그룹을 포함하는 문자열입니다. 목표는
    이러한 그룹을 별도의 문자열로 분리하고 그 목록을 반환하는 것입니다.
    분리된 그룹은 균형이 맞으며(각 여는 괄호가 올바르게 닫힘) 서로 중첩되지 않습니다
    입력 문자열의 모든 공백은 무시합니다.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ 이 함수에 대한 입력은 중첩된 괄호의 여러 그룹을 포함하는 문자열입니다. 목표는
    해당 그룹을 별도의 문자열로 분리하고 해당 그룹의 목록을 반환하는 것입니다.
    별도의 그룹은 균형을 이루고(각 열린 중괄호가 제대로 닫힘) 서로 중첩되지 않습니다.
    입력 문자열의 공백은 무시합니다.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ 이 함수의 입력은 중첩된 괄호의 여러 그룹을 포함하는 문자열입니다. 당신의 목표는
    이러한 그룹을 개별 문자열로 분리하고 그 목록을 반환하는 것입니다.
    분리된 그룹은 균형이 맞으며(각 여는 괄호가 올바르게 닫힘) 서로 중첩되지 않습니다
    입력 문자열의 모든 공백은 무시합니다.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ 양의 부동 소수점 숫자가 주어지면, 이는 정수 부분(주어진 숫자보다 작은 가장 큰 정수)과
    소수 부분(항상 1보다 작은 나머지 부분)으로 분해될 수 있습니다.

    숫자의 소수 부분을 반환합니다.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ 양의 부동 소수점 숫자가 주어지면,
    정수 부분(주어진 숫자보다 작은 가장 큰 정수)과 소수
    (나머지 부분은 항상 1보다 작음)으로 분해할 수 있습니다.

    숫자의 소수 부분을 반환합니다.
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ 잔액이 0인 은행 계좌에서 입금과 출금 작업 목록이 주어집니다.
    계좌의 잔액이 0 미만으로 떨어지는 시점이 있다면 True를 반환하고,
    그렇지 않다면 False를 반환하는 것이 당신의 임무입니다.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ 잔액이 0인 은행 계좌에 대한 입금 및 출금 작업 목록이 제공됩니다. 귀하의 작업은 어느 시점에서 계좌 잔액이 0보다 낮아지는지 감지하는 것이며,
    그 시점에서 함수는 True를 반환해야 합니다. 그렇지 않으면 False를 반환해야 합니다.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ 은행 계좌에 대한 입금 및 출금 작업 목록이 주어집니다. 계좌는 0의 잔액으로 시작합니다.
    계좌 잔액이 0보다 아래로 떨어지는 시점을 감지하는 것이 과제이며,
    그 시점에 함수는 True를 반환해야 합니다. 그렇지 않으면 False를 반환해야 합니다.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ 주어진 입력 숫자 리스트에 대해, 이 데이터셋의 평균에 대한
    평균 절대 편차를 계산합니다.
    평균 절대 편차는 각 요소와 중심점(이 경우 평균) 사이의
    절대적 차이의 평균입니다:
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ 주어진 입력 숫자 리스트에 대해 평균에 대한 평균 절대 편차를 계산합니다.
    평균 절대 편차는 각 요소와 중심점(이 경우 평균) 사이의
    절대 차이의 평균입니다:
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ 주어진 입력 숫자 목록에 대해 이 데이터 세트의 평균을 중심으로 평균 절대 편차를 계산합니다.
    평균 절대 편차는 각 요소와 중심점(이 경우 평균) 간의 평균 절대 차이입니다.
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ 입력 리스트 `numbers`의 연속된 두 요소 사이에 숫자 'delimeter'를 삽입합니다
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ 입력 목록 `numbers'의 모든 두 연속 요소 사이에 숫자 '구분 기호'를 삽입합니다.
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ 이 함수의 입력은 공백으로 구분된 중첩 괄호의 여러 그룹을 나타내는 문자열입니다.
    각 그룹에 대해 괄호의 가장 깊은 중첩 수준을 출력합니다.
    예를 들어 (()())는 최대 두 단계의 중첩이 있고 ((())) 는 세 단계가 있습니다.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ 이 함수의 입력은 공백으로 구분된 여러 그룹의 중첩된 괄호로 표현된 문자열입니다.
    각  그룹에 대해 괄호의 가장 깊은 중첩 수준을 출력합니다.
    예: (()())는 최대 두 단계의 중첩을 가지며 ((()))는 세 단계의 중첩을 가집니다.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ 이 함수의 입력은 공백으로 구분된 중첩 괄호의 여러 그룹으로 표현된 문자열입니다.
    각 그룹에 대해 괄호의 가장 깊은 중첩 수준을 출력합니다.
    예를 들어 (()())는 최대 2단계의 중첩을 갖는 반면 ((()))는 3단계의 중첩을 갖습니다.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ 주어진 부분 문자열을 포함하는 문자열만 입력 목록에서 필터링
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ 입력된 문자열 리스트에서 주어진 부분 문자열을 포함하는 항목만 필터링하세요.
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ 주어진 하위 문자열을 포함하는 문자열만 입력된 문자열 목록에서 필터링
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """주어진 정수 목록에 대해, 목록에 있는 모든 정수의 합과 곱으로 구성된 튜플을 반환합니다.
    빈 합은 0과 같아야 하고 빈 곱은 1과 같아야 합니다.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """주어진 정수 리스트에 대해 모든 정수의 합과 곱으로 구성된 튜플을 반환합니다.
    빈 합계는 0이어야 하고 빈 곱은 1이어야 합니다.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ 주어진 정수 목록에 대해, 목록에 있는 모든 정수의 합과 곱으로 구성된 튜플을 반환합니다.
    빈 합은 0과 같아야 하고 빈 곱은 1과 같아야 합니다.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ 주어진 정수 리스트에서 시퀀스의 주어진 순간까지 발견된 롤링 최대값 요소의 리스트를 생성합니다.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ 주어진 정수 목록에서 시퀀스에서 주어진 순간까지 발견된 롤링 최대값 요소의 목록을 생성합니다.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ 주어진 문자열이 회문인지 테스트 """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ 주어진 문자열로 시작하는 가장 짧은 회문을 찾습니다.
    알고리즘 아이디어는 간단합니다:
    - 주어진 문자열의 가장 긴 접미사가 회문인지 찾습니다.
    - 회문 접미사 앞에 오는 문자열 접두사의 역순을 문자열 끝에 추가합니다.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ 주어진 문자열이 회문인지 테스트 """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ 제공된 문자열로 시작하는 가장 짧은 회문을 찾습니다.
    알고리즘 아이디어는 간단합니다:
    - 제공된 문자열에서 회문인 가장 긴 접미사를 찾습니다.
    - 회문 접미사 앞에 오는 문자열 접두사의 역순을 문자열 끝에 추가합니다.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ 주어진 문자열이 팰린드롬인지 테스트 """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ 제공된 문자열로 시작하는 가장 짧은 팰린드롬을 찾습니다.
    알고리즘 아이디어는 간단합니다:
    - 제공된 문자열 중 팰린드롬인 가장 긴 접미사를 찾습니다.
    - 팰린드롬 접미사 앞에 오는 문자열 접두사의 역순을 문자열 끝에 추가합니다.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ 입력은 1과 0으로만 구성된 두 문자열 a와 b입니다.
    이 입력들에 대해 이진 XOR 연산을 수행하고 결과를 문자열로 반환합니다.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ 입력은 1과 0으로만 구성된 두 개의 문자열 a와 b입니다.
    이러한 입력에 대해 이진 XOR을 수행하고 결과도 문자열로 반환합니다.
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ 문자열 목록 중에서 가장 긴 문자열을 반환합니다. 동일한 길이의 문자열이 여러 개 있는 경우
    첫 번째 문자열을 반환합니다. 입력 목록이 비어 있는 경우 None을 반환합니다.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ 문자열 리스트에서 가장 긴 문자열을 반환합니다. 같은 길이의 문자열이 여러 개인 경우
    첫 번째 문자열을 반환합니다. 입력 리스트가 비어있는 경우 None을 반환합니다.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ 문자열 목록에서 가장 긴 문자열을 반환합니다. 길이가 같은 여러 문자열이 있는 경우 첫 번째 문자열을 반환합니다. 입력 목록이 비어 있는 경우 None을 반환합니다.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """


def greatest_common_divisor(a: int, b: int) -> int:
    """ 두 정수 a와 b의 최대 공약수를 반환합니다.
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """두 정수 a와 b의 최대공약수를 반환합니다
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ 입력 문자열의 가장 짧은 것부터 가장 긴 것까지 모든 접두사 목록을 반환합니다.
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ 입력 문자열의 모든 접두사를 가장 짧은 것부터 가장 긴 것 순으로 반환합니다
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ 0부터 n까지 포함하여 공백으로 구분된 숫자를 포함하는 문자열을 반환합니다.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ 0부터 n까지의 숫자를 공백으로 구분하여 포함하는 문자열을 반환합니다.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ 0부터 n까지 공백으로 구분된 숫자를 포함하는 문자열을 반환합니다.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ 주어진 문자열에서 대소문자 구분 없이 서로 다른 문자가 몇 개 있는지 찾습니다
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ 문자열이 주어졌을 때, 대소문자에 관계없이 몇 개의 고유한 문자로 구성되어 있는지 알아보세요
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ 이 함수의 입력은 특수 ASCII 형식으로 된 음악 노트를 나타내는 문자열입니다.
    이 문자열을 파싱하여 각 노트가 몇 박자 지속되는지를 나타내는 정수 리스트를 반환하는 것이 과제입니다.

    전설은 다음과 같습니다:
    'o' - 온음표, 4박자 지속
    'o|' - 2분음표, 2박자 지속
    '.|' - 4분음표, 1박자 지속

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ 이 함수의 입력은 특별한 ASCII 형식으로 표현된 음악 노트를 나타내는 문자열입니다.
    당신의 과제는 이 문자열을 파싱하여 각 음표가 지속되는 박자 수에 해당하는 정수 리스트를 반환하는 것입니다.

    다음은 범례입니다:
    'o' - 온음표, 4박자 지속
    'o|' - 2분음표, 2박자 지속
    '.|' - 4분음표, 1박자 지속

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ 이 함수에 대한 입력은 특수 ASCII 형식의 음표를 나타내는 문자열입니다.
    여러분의 작업은 이 문자열을 구문 분석하고 각 음표가 몇 박자 동안 지속되는지에 해당하는 정수 목록을 반환하는 것입니다.

    다음은 범례입니다.
    'o' - 온음표, 4박자 동안 지속
    'o|' - 2분음표, 2박자 동안 지속
    '.|' - 4분음표, 1박자 동안 지속

    >>> parse_music('o o| .| o| o| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 4, 4]
    """


def how_many_times(string: str, substring: str) -> int:
    """ 주어진 하위 문자열이 원래 문자열에서 몇 번 발견될 수 있는지 찾습니다. 겹치는 경우를 세어보세요.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ 주어진 부분 문자열이 원래 문자열에서 몇 번 발견되는지 찾습니다. 중복되는 경우도 계산합니다.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ 입력은 'zero'에서 'nine'까지의 숫자로 구성된 공백으로 구분된 문자열입니다.
    유효한 선택은 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' 및 'nine'입니다.
    가장 작은 것부터 가장 큰 것까지 숫자가 정렬된 문자열을 반환합니다.
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ 입력은 'zero'에서 'nine'까지의 숫자를 공백으로 구분한 문자열입니다.
    유효한 선택지는 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'입니다.
    숫자를 가장 작은 것부터 가장 큰 것까지 정렬한 문자열을 반환합니다.
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ 입력은 'zero'부터 'nine'까지의 공백으로 구분된 숫자 문자열입니다.
    유효한 선택은 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine' 입니다.
    가장 작은 수부터 가장 큰 수까지 정렬된 문자열을 반환합니다
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ 제공된 숫자 리스트(길이가 최소 2 이상)에서 서로 가장 가까운 두 숫자를 선택하여
    순서대로(작은 숫자, 큰 숫자) 반환합니다.
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ 제공된 숫자 목록(길이가 2 이상)에서 서로 가장 가까운 두 개를 선택하여 반환하고
    순서대로 반환합니다(숫자가 작을수록, 숫자가 클수록).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ 숫자 목록(최소 2개 요소)이 주어지면 해당 목록에 선형 변환을 적용합니다.
    가장 작은 숫자는 0이 되고 가장 큰 숫자는 1이 됩니다.
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ 숫자 리스트가 주어질 때(최소 두 개의 요소), 해당 리스트에 선형 변환을 적용하여
    가장 작은 숫자는 0이 되고 가장 큰 숫자는 1이 되도록 합니다
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ 숫자 리스트가 주어졌을 때(최소 두 개의 요소), 해당 리스트에 선형 변환을 적용하여
    가장 작은 숫자는 0이 되고 가장 큰 숫자는 1이 되도록 합니다
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ 주어진 파이썬 값 리스트에서 정수만 필터링
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ 주어진 파이썬 값 목록에서 정수만 필터링
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ 정수만 필터링하여 주어진 Python 값 목록을 반환
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ 주어진 문자열의 길이를 반환합니다.
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ 주어진 문자열의 길이를 반환
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ 주어진 숫자 n에 대해, n보다 작으면서 n을 균등하게 나눌 수 있는 가장 큰 수를 찾으세요
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ 주어진 숫자 n에 대해, n을 나누어 떨어지는 가장 큰 숫자를 찾으세요. n보다 작고
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ 주어진 수 n에 대해, n을 균등하게 나누는 가장 큰 수, n보다 작은 수를 찾으세요.
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ 주어진 정수의 소인수를 가장 작은 것부터 큰 순서대로 리스트로 반환합니다.
    각 인수는 소인수분해에서 나타나는 횟수만큼 리스트에 포함되어야 합니다.
    입력된 숫자는 모든 인수들의 곱과 같아야 합니다.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ 주어진 정수의 소인수 목록을 가장 작은 것부터 가장 큰 것 순으로 반환합니다.
    각 인수는 인수분해에 나타나는 횟수에 해당하는 횟수만큼 나열되어야 합니다.
    입력 숫자는 모든 인수의 곱과 같아야 합니다.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ 주어진 정수의 소인수를 가장 작은 것부터 큰 순서로 리스트로 반환합니다.
    각 인수는 소인수분해에서 나타나는 횟수만큼 리스트에 포함되어야 합니다.
    입력된 숫자는 모든 인수들의 곱과 같아야 합니다.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ 정수 리스트에서 두 번 이상 나타나는 모든 요소를 제거합니다.
    입력된 순서대로 남은 요소들의 순서를 유지합니다.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ 정수 목록에서 두 번 이상 나타나는 모든 요소를 제거합니다.
    입력과 동일한 요소 순서를 유지합니다.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ 정수 목록에서 두 번 이상 나타나는 모든 요소를 제거하고.
    남은 요소들의 순서는 입력과 동일하게 유지합니다.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ 주어진 문자열에 대해 소문자는 대문자로, 대문자는 소문자로 변환합니다.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ 주어진 문자열에서 소문자는 대문자로, 대문자는 소문자로 변환합니다.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ 주어진 문자열에 대해 소문자를 대문자로, 대문자를 소문자로 뒤집습니다.
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ 문자열 목록을 단일 문자열로 연결
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ 문자열 리스트를 단일 문자열로 연결
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ 주어진 접두사로 시작하는 문자열만 입력 리스트에서 필터링합니다.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ 주어진 접두사로 시작하는 문자열만 입력된 문자열 목록을 필터링합니다.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """리스트에서 양수만 반환합니다.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """주어진 숫자가 소수이면 true를 반환하고, 그렇지 않으면 false를 반환합니다.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Return true if a given number is prime, and false otherwise.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    계수가 xs인 다항식을 점 x에서 평가합니다.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs는 다항식의 계수입니다.
    find_zero는 poly(x) = 0이 되는 x를 찾습니다.
    find_zero는 여러 개의 해가 있더라도 하나의 해만 반환합니다.
    또한, find_zero는 짝수 개의 계수를 가지며
    가장 큰 비영 계수를 가지는 리스트 xs만을 받아들입니다.
    이는 해를 보장합니다.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    점 x에서 계수가 xs인 다항식을 계산합니다.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs는 다항식의 계수입니다.
    find_zero는 poly(x) = 0이 되는 x를 찾습니다.
    find_zero는 여러 개의 해가 있더라도 하나의 해만 반환합니다.
    또한 find_zero는 해의 존재를 보장하기 위해
    짝수 개의 계수와 0이 아닌 최고차항 계수를 가진
    xs 리스트만 처리합니다.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    x점에서 계수 xs를 갖는 다항식을 평가합니다.
    return xs[0] + xs[1] * x + xs[2] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs는 다항식의 계수입니다.
    find_zero poly(x) = 0인 x를 찾습니다.
    find_zero는 많은 점이 있어도 0점만 반환합니다.
    게다가 find_zero는 짝수 개의 계수와 가장 큰 0이 아닌 계수를 갖는 리스트 xs만 취합니다.
    이는 솔루션을 보장하기 때문입니다.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """이 함수는 리스트 l을 받아서 리스트 l'을 반환합니다.
    l'은 3으로 나누어 떨어지지 않는 인덱스에서는 l과 동일하며, 3으로 나누어 떨어지는 인덱스의 값은
    l의 해당 인덱스의 값들을 정렬한 것입니다.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """이 함수는 리스트 l을 받아 리스트 l'을 반환합니다. 여기서
    l'은 3으로 나눌 수 없는 인덱스에서는 l과 동일하며, 3으로 나눌 수 있는 인덱스에서는
    l의 해당 인덱스 값들을 정렬한 값을 가집니다.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """리스트에서 중복되지 않는 요소들을 정렬하여 반환합니다
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """리스트에서 정렬된 고유한 요소를 반환합니다.
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """리스트의 최대 요소를 반환합니다.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """리스트에서 최대 요소를 반환합니다.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """11 또는 13으로 나누어 떨어지는 n보다 작은 정수에서 숫자 7이 나타나는 횟수를 반환합니다.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """11이나 13으로 나눌 수 있는 n보다 작은 정수들 중에서 숫자 7이 나타나는 횟수를 반환합니다.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """이 함수는 리스트 l을 받아 리스트 l'을 반환합니다.
    l'은 홀수 인덱스에서는 l과 동일하며, 짝수 인덱스에서는
    l의 짝수 인덱스 값들을 정렬한 값을 가집니다.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """이 함수는 리스트 l을 받아 리스트 l'을 반환합니다.
    l'은 홀수 인덱스에서는 l과 동일하며, 짝수 인덱스에서는
    l의 짝수 인덱스 값들을 정렬한 값과 같습니다.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """이 함수는 리스트 l을 받아서 리스트 l'을 반환합니다.
    l'은 홀수 인덱스에서는 l과 동일하며, 짝수 인덱스의 값은
    l의 짝수 인덱스 값들을 정렬한 것입니다.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    세 문자 그룹을 순환하여 인코딩된 문자열을 반환합니다.
    """
    # 문자열을 그룹으로 나눕니다. 각 그룹의 길이는 3입니다.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # 각 그룹의 요소를 순환합니다. 그룹의 요소가 3개 미만인 경우는 제외합니다.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    encode_cyclic 함수로 인코딩된 문자열을 입력으로 받아 디코딩된 문자열을 반환합니다.
    """

def encode_cyclic(s: str):
    """
    3개 문자 그룹을 순환하여 인코딩된 문자열을 반환합니다.
    """
    # split string to groups. Each of length 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # cycle elements in each group. Unless group has fewer elements than 3.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    encode_cyclic 함수로 인코딩된 문자열을 입력으로 받아 디코딩된 문자열을 반환합니다.
    """

def encode_cyclic(s: str):
    """
    세 문자의 그룹을 순환하여 인코딩된 문자열을 반환합니다.
    """
    # 문자열을 그룹으로 분할합니다. 각각 길이가 3입니다.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # 각 그룹의 요소를 순환합니다. 그룹의 요소가 3개보다 적지 않은 경우.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    encode_cyclic 함수로 인코딩된 문자열을 입력으로 받습니다. 디코딩된 문자열을 반환합니다.
    """


def prime_fib(n: int):
    """
    prime_fib는 피보나치 수이며 또한 소수인 n번째 수를 반환합니다.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib는 피보나치 수이면서 동시에 소수인 n번째 숫자를 반환합니다.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero는 정수 리스트를 입력으로 받습니다.
    리스트에서 합이 0이 되는 서로 다른 세 개의 요소가 있으면 True를 반환하고,
    그렇지 않으면 False를 반환합니다.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero 함수는 정수 리스트를 입력으로 받습니다.
    리스트에 합이 0이 되는 세 개의 서로 다른 요소가 있으면 True를 반환하고,
    그렇지 않으면 False를 반환합니다.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero는 정수 목록을 입력으로 받습니다.
    목록에 세 개의 고유한 요소가 있고 그 합이 0이면 True를 반환하고
    그렇지 않으면 False를 반환합니다.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """


def car_race_collision(n: int):
    """
    완벽하게 직선이며 무한히 긴 도로를 상상해보세요.
    n대의 자동차가 왼쪽에서 오른쪽으로 주행하고 있고, 동시에 다른 n대의 자동차가
    오른쪽에서 왼쪽으로 주행하고 있습니다. 두 그룹의 자동차들은 처음에는 서로 매우 멀리 떨어져 있습니다.
    모든 자동차는 같은 속도로 움직입니다. 왼쪽에서 오른쪽으로 가는 자동차가 오른쪽에서 왼쪽으로
    가는 자동차와 부딪힐 때 충돌이 발생했다고 합니다.
    하지만 자동차들은 무한히 견고하고 강해서, 충돌 후에도 마치 충돌하지 않은 것처럼
    계속해서 원래의 경로로 주행합니다.

    이 함수는 이러한 충돌의 횟수를 출력합니다.
    """

def car_race_collision(n: int):
    """
    도로가 완벽하게 직선으로 무한히 긴 선이라고 상상해보세요.
    n대의 자동차가 왼쪽에서 오른쪽으로 운전하고 있습니다; 동시에, 다른 n대의 자동차가
    오른쪽에서 왼쪽으로 운전하고 있습니다. 두 세트의 자동차는 처음에 서로 매우 멀리 떨어져 있습니다.
    모든 자동차는 같은 속도로 움직입니다. 왼쪽에서 오른쪽으로 움직이는 자동차가
    오른쪽에서 왼쪽으로 움직이는 자동차를 만났을 때 충돌했다고 합니다.
    그러나 자동차는 무한히 견고하고 강력합니다; 그 결과, 충돌하지 않은 것처럼
    그들의 궤적을 따라 계속 움직입니다.

    이 함수는 그러한 충돌의 수를 출력합니다.
    """

def car_race_collision(n: int):
    """
    도로가 완벽하게 직선으로 무한히 긴 선이라고 상상해보세요.
    n대의 자동차가 왼쪽에서 오른쪽으로 운전하고 있습니다; 동시에, 다른 n대의 자동차가
    오른쪽에서 왼쪽으로 운전하고 있습니다. 두 세트의 자동차는 처음에 서로 매우 멀리 떨어져 있습니다.
    모든 자동차는 같은 속도로 움직입니다. 왼쪽에서 오른쪽으로 움직이는 자동차가
    오른쪽에서 왼쪽으로 움직이는 자동차를 만났을 때 충돌했다고 합니다.
    그러나 자동차는 무한히 견고하고 강력합니다; 그 결과, 충돌하지 않은 것처럼
    그들의 궤적을 따라 계속 움직입니다.

    이 함수는 이러한 충돌 횟수를 출력합니다.
    """


def incr_list(l: list):
    """요소들을 1씩 증가시킨 리스트를 반환합니다.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """요소가 1씩 증가한 목록을 반환합니다.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """리스트의 모든 요소를 1씩 증가시킨 리스트를 반환합니다.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero는 정수 리스트를 입력으로 받습니다.
    리스트 내에서 합이 0이 되는 서로 다른 두 요소가 있으면 True를 반환하고,
    그렇지 않으면 False를 반환합니다.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero는 정수 목록을 입력으로 받습니다.
    목록에 합이 0이 되는 두 개의 고유한 요소가 있으면 True를 반환하고
    그렇지 않으면 False를 반환합니다.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero는 정수 목록을 입력으로 받습니다.
    목록에 합이 0이 되는 두 개의 고유한 요소가 있으면 True를 반환하고,
    그렇지 않으면 False를 반환합니다.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """입력 숫자 x의 진수를 base로 변경합니다.
    변환 후 문자열 표현을 반환합니다.
    base 숫자는 10보다 작습니다.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """입력 숫자 x의 기수를 base로 변경합니다.
    변환 후 문자열 형태로 반환합니다.
    base 숫자는 10보다 작습니다.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """입력 숫자 x의 진법을 base로 변환합니다.
    변환 후 문자열 표현을 반환합니다.
    진법 숫자는 10 미만입니다.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """삼각형의 한 변의 길이와 높이가 주어졌을 때 삼각형의 넓이를 반환합니다.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """한 변의 길이와 높이가 주어지면 삼각형의 넓이를 반환합니다.
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """Fib4 수열은 피보나치 수열과 유사하며 다음과 같이 정의됩니다:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Fib4 수열의 n번째 요소를 효율적으로 계산하는 함수를 작성하세요. 재귀를 사용하지 마세요.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Fib4 숫자 시퀀스는 다음과 같이 정의된 피보나치 수열과 유사한 시퀀스입니다.
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    fib4 숫자 시퀀스의 n번째 요소를 효율적으로 계산하는 함수를 작성하세요. 재귀를 사용하지 마세요.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
     """

def fib4(n: int):
    """Fib4 숫자 시퀀스는 다음과 같이 정의된 피보나치 수열과 유사한 시퀀스입니다:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    fib4 숫자 시퀀스의 n번째 요소를 효율적으로 계산하는 함수를 작성하세요. 재귀를 사용하지 마세요.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """리스트 l의 요소들의 중앙값을 반환합니다.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """리스트 l의 요소의 중간값을 반환합니다.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    주어진 문자열이 회문인지 확인합니다
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    주어진 문자열이 팰린드롬인지 확인합니다.
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """2^n을 p로 나눈 나머지를 반환합니다 (수치 계산에 주의하세요).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """2^n 모듈로 p를 반환합니다(숫자에 유의하세요).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    알파벳에서 모든 문자를 5칸씩 이동하여 인코딩된 문자열을 반환합니다.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    encode_shift 함수로 인코딩된 문자열을 입력으로 받습니다. 디코딩된 문자열을 반환합니다.
    """

def encode_shift(s: str):
    """
    알파벳의 모든 문자를 5씩 이동하여 인코딩된 문자열을 반환합니다.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

    def decode_shift(s: str):
    """
    encode_shift 함수로 인코딩된 문자열을 입력으로 받습니다. 디코딩된 문자열을 반환합니다.
    """


def remove_vowels(text):
    """
    remove_vowels는 문자열을 받아서 모음이 없는 문자열을 반환하는 함수입니다.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels는 문자열을 받아서 모음이 제거된 문자열을 반환하는 함수입니다.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels는 문자열을 받아 모음이 제거된 문자열을 반환하는 함수입니다.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """리스트 l의 모든 숫자가 임계값 t보다 작은 경우 True를 반환합니다.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """리스트 l의 모든 숫자가 임계값 t 아래에 있으면 True를 반환합니다.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """리스트 l의 모든 숫자가 임계값 t보다 작은지 확인하여 True를 반환합니다.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """두 숫자 x와 y를 더합니다.
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """두 숫자 x와 y를 더합니다
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    두 단어가 동일한 문자들로 구성되어 있는지 확인합니다.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    두 단어에 같은 문자가 있는지 확인합니다.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """n번째 피보나치 수를 반환합니다.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets는 "<"와 ">"로 구성된 문자열입니다.
    모든 여는 괄호에 대응하는 닫는 괄호가 있으면 True를 반환합니다.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

def correct_bracketing(brackets: str):
    """ brackets는 "<"와 ">"의 문자열입니다.
    모든 여는 괄호에 해당하는 닫는 괄호가 있는 경우 True를 반환합니다.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """


def monotonic(l: list):
    """리스트 요소가 단조롭게 증가하거나 감소하는 경우 True를 반환합니다.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """리스트 요소가 단조 증가하거나 단조 감소하는 경우 True를 반환합니다.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """두 리스트의 정렬된 고유한 공통 요소를 반환합니다.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """두 리스트의 공통 요소들을 정렬하여 중복 없이 반환합니다.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """Return sorted unique common elements for two lists.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """n의 가장 큰 소인수를 반환합니다. n > 1이고 소수가 아니라고 가정합니다.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """n의 가장 큰 소수 인수를 반환합니다. n은 1보다 크고 소수가 아니라고 가정합니다.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """
    n의 가장 큰 소인수를 반환합니다. n은 1보다 크고 소수가 아니라고 가정합니다.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n은 1부터 n까지의 숫자를 더하는 함수입니다.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """sum_to_n은 1에서 n까지의 숫자를 합산하는 함수입니다.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ brackets는 "("와 ")"의 문자열입니다.
    모든 여는 괄호에 해당하는 닫는 괄호가 있는 경우 True를 반환합니다.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """

def correct_bracketing(brackets: str):
    """ brackets는 "("와 ")"로 구성된 문자열입니다.
    모든 여는 괄호에 대응하는 닫는 괄호가 있으면 True를 반환합니다.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """


def derivative(xs: list):
    """ xs는 다항식의 계수를 나타냅니다.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    이 다항식의 도함수를 같은 형태로 반환합니다.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs는 다항식의 계수를 나타냅니다.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     이 다항식의 도함수를 같은 형식으로 반환합니다.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs는 다항식의 계수를 나타냅니다.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    이 다항식의 미분을 같은 형태로 반환합니다.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """FibFib 수열은 피보나치 수열과 유사한 수열로 다음과 같이 정의됩니다:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    FibFib 수열의 n번째 요소를 효율적으로 계산하는 함수를 작성하세요.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """FibFib 수열은 피보나치 수열과 유사한 수열로 다음과 같이 정의됩니다:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    fibfib 숫자 시퀀스의 n번째 요소를 효율적으로 계산하는 함수를 작성하세요.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """FibFib 숫자 시퀀스는 다음과 같이 정의된 Fibbonacci 시퀀스와 유사한 시퀀스입니다.
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    fibfib 숫자 시퀀스의 n번째 요소를 효율적으로 계산하는 함수를 작성하세요.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
더 많은 테스트 케이스를 추가하세요.
"""

def vowels_count(s):
    """문자열을 입력으로 받아 문자열에 있는 모음의 개수를 반환하는
    함수 vowels_count를 작성하세요. 이 경우 모음은 'a', 'e', 'i', 'o', 'u'입니다.
    여기서 'y'는 주어진 단어의 끝에 있을 때만 모음으로 간주됩니다.

    예시:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
테스트 케이스를 더 추가합니다.
"""

def vowels_count(s):
    """단어를 나타내는 문자열을 입력으로 받고 문자열의 모음 수를 반환하는 vowels_count 함수를 작성합니다.
    이 경우 모음은 'a', 'e', 'i', 'o', 'u'입니다. 여기서 'y'도 모음이지만
    주어진 단어의 끝에 있을 때만 모음입니다.

    예시:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
더 많은 테스트 케이스를 추가하세요.
"""

def vowels_count(s):
    """문자열로 표현된 단어를 입력으로 받아 해당 문자열의 모음 개수를 반환하는
    vowels_count 함수를 작성하세요.
    여기서 모음은 'a', 'e', 'i', 'o', 'u'입니다. 'y'도 모음으로 취급되지만,
    주어진 단어의 끝에 있을 때만 모음으로 간주됩니다.

    예시:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """정수 x의 자릿수를 순환 이동하여 자릿수를 shift만큼 오른쪽으로 이동하고
    결과를 문자열로 반환합니다.
    만약 shift가 자릿수보다 크면, 자릿수를 반전하여 반환합니다.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """정수 x의 숫자를 순환 이동하고, 숫자를 shift만큼 오른쪽으로 이동하고
    결과를 문자열로 반환합니다.
    shift > 숫자 수이면 숫자를 반전하여 반환합니다.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """정수 x의 자릿수를 순환적으로 이동하며, 자릿수를 shift만큼 오른쪽으로 이동하고
    결과를 문자열로 반환합니다.
    만약 shift가 자릿수보다 크다면, 뒤집힌 자릿수를 반환합니다.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """과제
    문자열을 입력으로 받아 대문자 문자의 ASCII 코드 합계만을 반환하는 함수를 작성하세요.

    예시:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """작업
    문자열을 입력으로 받고 대문자만의 ASCII 코드 합을 반환하는 함수를 작성하세요.

    예시:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """작업
    문자열을 입력으로 받아 대문자 문자만의 ASCII 코드 합계를 반환하는 함수를 작성하세요.

    예시:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s,n):
    """
    이 작업에서는 과일 바구니에 분배된 사과와 오렌지의 수를 나타내는 문자열이 주어집니다.
    이 바구니에는 사과, 오렌지, 망고가 포함되어 있습니다.
    오렌지와 사과의 총 수를 나타내는 문자열과 바구니에 있는 과일의 총 수를 나타내는 정수가 주어졌을 때,
    바구니에 있는 망고의 수를 반환합니다.
    예를 들어:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    이 과제에서는 과일 바구니에 분배된 사과와 오렌지의 수를 나타내는 문자열이 주어집니다.
    이 바구니에는 사과, 오렌지, 망고 과일이 들어있습니다. 오렌지와 사과의 총 개수를 나타내는
    문자열과 바구니에 있는 총 과일 개수를 나타내는 정수가 주어졌을 때,
    바구니에 있는 망고 과일의 개수를 반환합니다.
    예시:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


def pluck(arr):
    """
    "트리의 가지를 나타내는 배열이 주어졌을 때, 이 배열은 음이 아닌 정수 노드로 구성됩니다.
    당신의 작업은 노드 중 하나를 선택하여 반환하는 것입니다.
    선택된 노드는 가장 작은 짝수 값을 가진 노드여야 합니다.
    동일한 가장 작은 짝수 값을 가진 노드가 여러 개 있는 경우, 가장 작은 인덱스를 가진 노드를 반환합니다.

    선택된 노드는 [가장 작은 값, 그 값의 인덱스] 형태의 리스트로 반환되어야 합니다.
    짝수 값이 없거나 주어진 배열이 비어 있는 경우, 빈 리스트를 반환합니다.

    예제 1:
        입력: [4,2,3]
        출력: [2, 1]
        설명: 2는 가장 작은 짝수 값이며, 2는 가장 작은 인덱스를 가집니다.

    예제 2:
        입력: [1,2,3]
        출력: [2, 1]
        설명: 2는 가장 작은 짝수 값이며, 2는 가장 작은 인덱스를 가집니다.

    예제 3:
        입력: []
        출력: []

    예제 4:
        입력: [5, 0, 3, 0, 4, 2]
        출력: [0, 1]
        설명: 0은 가장 작은 값이지만, 두 개의 0이 있으므로
                     첫 번째 0을 선택합니다. 이는 가장 작은 인덱스를 가집니다.

    제약 조건:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "음이 아닌 정수 노드가 있는 트리의 분기를 나타내는 배열이 주어지면
    작업은 노드 중 하나를 뽑아서 반환하는 것입니다.
    뽑은 노드는 가장 작은 짝수 값을 가진 노드여야 합니다.
    동일한 가장 작은 짝수 값을 가진 노드가 여러 개 발견되면 가장 작은 인덱스를 가진 노드를 반환합니다.

    뽑은 노드는 [smalest_value, 해당 인덱스]의 목록으로 반환되어야 합니다.
    짝수 값이 없거나 주어진 배열이 비어 있으면 []을 반환합니다.

    예제 1:
        입력: [4,2,3]
        출력: [2, 1]
        설명: 2는 가장 작은 짝수 값을 가지고 있고 2는 가장 작은 인덱스를 가지고 있습니다.

    예제 2:
        입력: [1,2,3]
        출력: [2, 1]
        설명: 2는 가장 작은 짝수 값을 가지고 있고 2는 가장 작은 인덱스를 가지고 있습니다.

    예 3:
        입력: []
        출력: []

    예 4:
        입력: [5, 0, 3, 0, 4, 2]
        출력: [0, 1]
        설명: 0이 가장 작은 값이지만 0이 두 개 있으므로
                     가장 작은 인덱스를 갖는 첫 번째 0을 선택합니다.

    제약 조건:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    음수가 아닌 정수 노드를 가진 트리의 가지를 나타내는 배열이 주어졌을 때
    노드 중 하나를 뽑아서 반환하는 것이 과제입니다.
    뽑힌 노드는 가장 작은 짝수 값을 가진 노드여야 합니다.
    동일한 가장 작은 짝수 값을 가진 노드가 여러 개 있는 경우 가장 작은 인덱스를 가진 노드를 반환합니다.

    뽑힌 노드는 [가장_작은_값, 해당_인덱스] 형식의 리스트로 반환되어야 합니다.
    짝수 값이 없거나 주어진 배열이 비어있는 경우 []를 반환합니다.

    예시 1:
        Input: [4,2,3]
        Output: [2, 1]
        설명: 2가 가장 작은 짝수 값이며, 2는 가장 작은 인덱스를 가집니다.

    예시 2:
        Input: [1,2,3]
        Output: [2, 1]
        설명: 2가 가장 작은 짝수 값이며, 2는 가장 작은 인덱스를 가집니다.

    예시 3:
        Input: []
        Output: []

    예시 4:
        Input: [5, 0, 3, 0, 4, 2]
        Output: [0, 1]
        설명: 0이 가장 작은 값이지만 0이 두 개 있으므로,
             가장 작은 인덱스를 가진 첫 번째 0을 선택합니다.

    제약 조건:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    양의 정수로 구성된 비어 있지 않은 리스트가 주어집니다. 0보다 크고,
    해당 정수의 빈도수가 정수 자신의 값보다 크거나 같은 가장 큰 정수를 반환합니다.
    정수의 빈도수는 리스트에서 해당 정수가 나타나는 횟수입니다.
    이러한 값이 존재하지 않으면 -1을 반환합니다.
    예시:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    양의 정수로 구성된 비어 있지 않은 리스트가 주어집니다. 0보다 크고, 빈도가 해당 정수의 값보다 크거나 같은 가장 큰 정수를 반환합니다.
    정수의 빈도는 리스트에 나타나는 횟수입니다.
    그러한 값이 존재하지 않으면 -1을 반환합니다.
    예시:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    비어 있지 않은 양의 정수 목록이 주어집니다. 0보다 크고 빈도가 정수 자체의 값보다 크거나 같은 가장 큰 정수를 반환합니다.
    정수의 빈도는 목록에 나타나는 횟수입니다.
    그러한 값이 없으면 -1을 반환합니다.
    예시:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''


def strange_sort_list(lst):
    '''
    정수 리스트가 주어지면, 리스트를 이상한 순서로 반환합니다.
    이상한 정렬은 최소값으로 시작한 다음 남은 정수 중 최대값,
    그 다음 최소값, 이런 식으로 진행됩니다.

    예시:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    정수 리스트가 주어지면 특이한 순서로 된 리스트를 반환합니다.
    특이한 정렬은 최소값으로 시작하여,
    남은 정수들 중 최대값, 그 다음 최소값 등의 순서로 정렬하는 것입니다.

    예시:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    정수 리스트가 주어지면, 리스트를 이상한 순서로 반환합니다.
    이상한 정렬은 최소값으로 시작한 다음 남은 정수 중 최대값,
    그 다음 최소값, 이런 식으로 진행됩니다.

    예:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    삼각형의 세 변의 길이가 주어졌을 때, 세 변이 유효한 삼각형을 형성하면
    삼각형의 넓이를 소수점 둘째 자리까지 반올림하여 반환합니다.
    그렇지 않으면 -1을 반환합니다.
    세 변이 유효한 삼각형을 만들려면, 두 변의 합이 세 번째 변보다 커야 합니다.
    예시:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    삼각형의 세 변의 길이가 주어집니다. 세 변이 유효한 삼각형을 이루면
    삼각형의 넓이를 소수점 2자리까지 반올림하여 반환합니다.
    그렇지 않으면 -1을 반환합니다.
    세 변이 유효한 삼각형을 이루려면 두 변의 합이 나머지 한 변보다
    커야 합니다.
    예시:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    삼각형의 세 변의 길이가 주어짐. 세 변이 유효한 삼각형을 형성하는 경우
    삼각형의 면적을 소수점 둘째 자리까지 반올림하여 반환.
    그렇지 않으면 -1 반환
    세 변의 합이 세 번째 변보다 클 때 유효한 삼각형을 형성함.
    예:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    객체 q가 날 경우 True를 반환하고, 그렇지 않으면 False를 반환하는 함수를 작성하세요.
    객체 q는 균형 잡혔을 때(회문 리스트일 때) 날고, 요소의 합이 최대 가능 무게 w보다 작거나 같을 때 날 것입니다.

    예시:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2는 최대 가능 무게보다 작지만, 불균형합니다.

    will_it_fly([3, 2, 3], 1) ➞ False
    # 균형 잡혔지만, 3+2+3은 최대 가능 무게보다 큽니다.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3은 최대 가능 무게보다 작고, 균형 잡혔습니다.

    will_it_fly([3], 5) ➞ True
    # 3은 가능한 최대 무게보다 적고 균형이 맞습니다.
    '''

def will_it_fly(q,w):
    '''
    객체 q가 날 수 있으면 True를, 그렇지 않으면 False를 반환하는 함수를 작성하세요.
    객체 q는 균형이 잡혀 있고(회문 리스트임) 요소들의 합이 최대 가능 무게 w보다 작거나 같을 때 날 수 있습니다.

    예시:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2는 최대 가능 무게보다 작지만, 균형이 잡혀있지 않습니다.

    will_it_fly([3, 2, 3], 1) ➞ False
    # 균형은 잡혀있지만, 3+2+3이 최대 가능 무게보다 큽니다.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3이 최대 가능 무게보다 작고, 균형도 잡혀있습니다.

    will_it_fly([3], 5) ➞ True
    # 3이 최대 가능 무게보다 작고, 균형도 잡혀있습니다.
    '''

def will_it_fly(q,w):
    '''
    객체 q가 날 수 있으면 True를, 그렇지 않으면 False를 반환하는 함수를 작성하세요.
    객체 q는 균형이 잡혀 있고(회문 리스트임) 요소들의 합이 최대 가능 무게 w보다 작거나 같을 때 날 수 있습니다.

    예시:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2는 최대 가능 무게보다 작지만, 균형이 잡히지 않았습니다.

    will_it_fly([3, 2, 3], 1) ➞ False
    # 균형은 잡혔지만, 3+2+3이 최대 가능 무게보다 큽니다.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3이 최대 가능 무게보다 작고, 균형도 잡혔습니다.

    will_it_fly([3], 5) ➞ True
    # 3이 최대 가능 무게보다 작고, 균형도 잡혔습니다.
    '''


def smallest_change(arr):
    """
    정수 배열 arr이 주어졌을 때, 배열을 회문 배열로 만들기 위해
    변경해야 하는 최소 요소 수를 찾습니다. 회문 배열은 앞뒤로 읽어도
    동일한 배열입니다. 한 번의 변경으로, 하나의 요소를 다른 요소로 변경할 수 있습니다.

    예를 들어:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    정수 배열 arr가 주어졌을 때, 배열을 팰린드롬으로 만들기 위해 변경해야 하는
    최소 요소 개수를 찾습니다. 팰린드롬 배열은 앞에서부터 읽으나 뒤에서부터 읽으나
    동일한 배열입니다. 한 번의 변경으로 하나의 요소를 다른 어떤 요소로든 변경할 수 있습니다.

    예시:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    두 개의 문자열 리스트를 받아서, 리스트 내 모든 문자열의 총 문자 수가
    다른 리스트보다 적은 리스트를 반환하는 함수를 작성하세요.

    만약 두 리스트의 문자 수가 같다면, 첫 번째 리스트를 반환하세요.

    Examples
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    두 개의 문자열 목록을 받아서 목록의 모든 문자열의 총 문자 수가 다른 목록보다 적은 목록을 반환하는 함수를 작성하세요.

    두 목록의 문자 수가 같으면 첫 번째 목록을 반환합니다.

    예시
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    두 개의 문자열 리스트를 받아들이고, 리스트의 모든 문자열의 총 문자 수가
    다른 리스트보다 적은 리스트를 반환하는 함수를 작성하세요.

    두 리스트가 동일한 문자 수를 가지고 있다면, 첫 번째 리스트를 반환하세요.

    예시
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """주어진 숫자가 3개의 소수의 곱인 경우 True를 반환하고,
    그렇지 않은 경우 False를 반환하는 함수를 작성하세요.
    주어진 숫자 (a)는 100보다 작습니다.
    예시:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """주어진 숫자가 3개의 소수의 곱인 경우 true를 반환하고,
    그렇지 않으면 false를 반환하는 함수를 작성하세요.
    (a)가 100보다 작다는 것을 알고 있습니다.
    예시:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """주어진 숫자가 3개의 소수의 곱인 경우 true를 반환하고
    그렇지 않은 경우 false를 반환하는 함수를 작성하세요.
    (a)는 100보다 작다는 것을 알고 있습니다.
    예시:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """숫자 x가 n의 단순 거듭제곱인 경우 true를 반환하고
    다른 경우에는 false를 반환하는 함수를 작성하는 것이 과제입니다.
    n**int=x인 경우 x는 n의 단순 거듭제곱입니다.
    예시:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """당신의 작업은 숫자 x가 n의 단순 거듭제곱이면 true를 반환하고,
    그렇지 않은 경우 false를 반환하는 함수를 작성하는 것입니다.
    x는 n의 단순 거듭제곱일 때 n**int=x입니다.
    예를 들어:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''정수 a가 어떤 정수의 세제곱인지를 확인하는 함수를 작성하세요.
    참고: 입력은 항상 유효하다고 가정합니다.
    예시:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    정수 a를 받아서 이 정수가 어떤 정수의 세제곱인 경우 True를 반환하는 함수를 작성하세요.
    참고: 입력은 항상 유효하다고 가정할 수 있습니다.
    예시:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    다음은 정수 a를 받아서 이 정수가 어떤 정수의 세제곱인지 확인하고,
    그렇다면 True를 반환하는 함수입니다.
    참고: 입력이 항상 유효하다고 가정해도 됩니다.
    예시:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """16진수 숫자를 문자열로 받아서 소수인 16진수 숫자의 개수를 세는 함수입니다
    (소수는 1보다 크고 두 개의 더 작은 자연수의 곱으로 표현될 수 없는 자연수입니다).
    16진수 숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F입니다.
    소수는 2, 3, 5, 7, 11, 13, 17,...입니다.
    따라서 다음 숫자들의 개수를 확인해야 합니다: 2, 3, 5, 7,
    B (=10진수 11), D (=10진수 13).
    참고: 입력은 항상 올바르거나 빈 문자열이며,
    A,B,C,D,E,F 기호는 항상 대문자입니다.
    예시:
    num = "AB"인 경우 출력은 1이어야 합니다.
    num = "1077E"인 경우 출력은 2이어야 합니다.
    num = "ABED1A33"인 경우 출력은 4이어야 합니다.
    num = "123456789ABCDEF0"인 경우 출력은 6이어야 합니다.
    num = "2020"인 경우 출력은 2이어야 합니다.
    """

def hex_key(num):
    """16진수 숫자를 문자열로 받아서 16진수 숫자 중 소수인 숫자의 개수를
    세는 함수를 작성하는 작업을 맡았습니다.
    (소수는 1보다 큰 자연수 중 두 개의 더 작은 자연수의 곱이 아닌 수입니다).
    16진수 숫자는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F입니다.
    소수는 2, 3, 5, 7, 11, 13, 17,...입니다.
    따라서 다음 숫자의 개수를 결정해야 합니다: 2, 3, 5, 7,
    B (=10진수 11), D (=10진수 13).
    참고: 입력은 항상 올바르거나 빈 문자열이라고 가정할 수 있으며,
    기호 A, B, C, D, E, F는 항상 대문자입니다.
    예시:
    num = "AB"일 때 출력은 1이어야 합니다.
    num = "1077E"일 때 출력은 2이어야 합니다.
    num = "ABED1A33"일 때 출력은 4이어야 합니다.
    num = "123456789ABCDEF0"일 때 출력은 6이어야 합니다.
    num = "2020"일 때 출력은 2이어야 합니다.
    """


def decimal_to_binary(decimal):
    """10진수 형태의 숫자가 주어지면 이를 이진수 형식으로 변환하는 것이 당신의 과제입니다.
    함수는 각 문자가 이진수를 나타내는 문자열을 반환해야 합니다. 문자열의 각 문자는 '0' 또는 '1'이 됩니다.

    문자열의 시작과 끝에는 'db'라는 추가 문자가 있습니다.
    이 추가 문자들은 형식을 돕기 위해 존재합니다.

    예시:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    """10진수 형태의 숫자가 주어지고, 여러분의 과제는 그것을
    2진 형식으로 변환하는 것입니다. 이 함수는 각 문자가 2진수를 나타내는 문자열을 반환해야 합니다.
    문자열의 각 문자는 '0' 또는 '1'입니다.

    문자열의 시작과 끝에 몇 개의 추가 문자 'db'가 있습니다.
    추가 문자는 형식을 돕기 위해 있습니다.

    예:
    decimal_to_binary(15)   # "db1111db" 반환
    decimal_to_binary(32)   # "db100000db" 반환
    """

defdecimal_to_binary(decimal):
    """십진수 형태의 숫자가 주어지며, 이 숫자를 이진수 형식으로 변환하는 것이 과제입니다.
    함수는 문자열을 반환해야 하며, 각 문자는 이진수를 나타냅니다.
    문자열의 각 문자는 '0' 또는 '1'이 됩니다.

    문자열의 시작과 끝에 몇 개의 추가 문자 'db'가 있습니다.
    추가 문자는 형식을 돕기 위해 존재합니다.

    예:
    decimal_to_binary(15) # "db1111db"를 반환합니다.
    decimal_to_binary(32) # "db100000db"를 반환합니다.
    """


def is_happy(s):
    """문자열 s가 주어집니다.
    당신의 임무는 이 문자열이 행복한지 아닌지 확인하는 것입니다.
    문자열이 행복하다는 것은 길이가 최소 3이상이며 연속된 3개의 문자가 모두 서로 다른 경우를 의미합니다
    예시:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """문자열 s가 주어졌습니다.
    작업은 문자열이 happy인지 아닌지 확인하는 것입니다.
    문자열은 길이가 3 이상이고 연속된 3개의 문자가 모두 서로 다르면 happy입니다.
    예를 들어:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """이번 학기의 마지막 주이며 교사는 학생들에게 성적을 부여해야 합니다.
    교사는 성적 산출을 위한 자체 알고리즘을 만들었습니다.
    유일한 문제는 성적 산출에 사용했던 코드를 잃어버렸다는 것입니다.
    교사는 일부 학생들의 GPA 목록을 제공했으며, 다음 표를 사용하여
    문자 등급 목록을 출력할 수 있는 함수를 작성해야 합니다:
             GPA       |    Letter grade
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    예시:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """학기 마지막 주이고 선생님은 학생들에게 성적을 주어야 합니다.
    선생님은 채점을 위한 자신만의 알고리즘을 만들어 왔습니다.
    유일한 문제는 채점에 사용한 코드를 잃어버렸다는 것입니다.
    선생님은 일부 학생들의 GPA 목록을 주셨고, 다음 표를 사용하여 문자 등급 목록을 출력할 수 있는 함수를 작성해야 합니다.
             GPA | 문자 등급
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    예시:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """학기 마지막 주이고 선생님은 학생들에게 성적을 주어야 합니다.
    선생님은 자신의 성적 매기기 알고리즘을 만들어 왔습니다.
    유일한 문제는 그녀가 성적 매기기에 사용한 코드를 잃어버렸다는 것입니다.
    선생님은 몇몇 학생들의 GPA 목록을 주셨고, 당신은 다음 표를 사용하여
    문자 등급 목록을 출력할 수 있는 함수를 작성해야 합니다:
             GPA       |    문자 등급
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    예:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


def prime_length(string):
    """문자열을 받아서 문자열의 길이가 소수인 경우 True를,
    그렇지 않은 경우 False를 반환하는 함수를 작성하세요
    예시
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """문자열을 받아서 문자열 길이가 소수이면 True를 반환하고 그렇지 않으면 False를 반환하는 함수를 작성하세요
    예제
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """문자열을 받아서 문자열의 길이가 소수이면 True를, 그렇지 않으면 False를 반환하는 함수를 작성하세요
    예시
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    양의 정수 n이 주어졌을 때, 1로 시작하거나 1로 끝나는 n자리 양의 정수의 개수를 반환합니다.
    """

def starts_one_ends(n):
    """
    양의 정수 n이 주어졌을 때, n자리 양의 정수 중에서
    1로 시작하거나 1로 끝나는 수의 개수를 반환합니다.
    """

def starts_one_ends(n):
    """
    양의 정수 n이 주어지면 1로 시작하거나 끝나는 n자리 양의 정수 개수를 반환합니다.
    """


def solve(N):
    """양의 정수 N이 주어졌을 때, 이진수로 자리수의 총합을 반환합니다.

    예제
        N = 1000일 때, 자리수의 합은 1이며 출력은 "1"이어야 합니다.
        N = 150일 때, 자리수의 합은 6이며 출력은 "110"이어야 합니다.
        N = 147일 때, 자리수의 합은 12이며 출력은 "1100"이어야 합니다.

    변수:
        @N 정수
             제약 조건: 0 ≤ N ≤ 10000.
    출력:
         이진수 문자열
    """

def solve(N):
    """주어진 양의 정수 N에 대해, 각 자릿수의 합을 이진수로 반환합니다.

    예시
        N = 1000인 경우, 자릿수의 합은 1이므로 출력은 "1"이 됩니다.
        N = 150인 경우, 자릿수의 합은 6이므로 출력은 "110"이 됩니다.
        N = 147인 경우, 자릿수의 합은 12이므로 출력은 "1100"이 됩니다.

    변수:
        @N integer
             제약조건: 0 ≤ N ≤ 10000.
    Output:
         이진수를 나타내는 문자열
    """

defsolve(N):
    """양의 정수 N이 주어지면, 이진수로 각 자리의 합계를 반환합니다.

    예시
        N = 1000인 경우, 자리의 합계는 1이고 출력은 "1"입니다.
        N = 150인 경우, 자리의 합계는 6이고 출력은 "110"입니다.
        N = 147인 경우, 자리의 합계는 12이고 출력은 "1100"입니다.

    변수:
        @N 정수
        제약 조건: 0 ≤ N ≤ 10000.
    출력:
        이진수 문자열
    """


def add(lst):
    """정수로 이루어진 비어있지 않은 리스트 lst가 주어집니다. 홀수 인덱스에 있는 짝수 요소들의 합을 구합니다.

    예시:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """정수가 포함된 비어 있지 않은 리스트 lst가 주어졌을 때,
    홀수 인덱스에 있는 짝수 요소를 더합니다.

    예시:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """비어 있지 않은 정수 리스트 lst가 주어지면 홀수 인덱스에 있는 짝수 요소를 추가합니다.

    예:
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    문자열을 받아 정렬된 버전을 반환하는 함수를 작성합니다.
    문자열의 정렬된 버전이란, 모든 단어(공백으로 구분)가
    ascii 값을 기준으로 오름차순으로 정렬된 문자들로 이루어진
    새로운 단어로 대체된 문자열입니다.
    참고: 문장에서 단어의 순서와 공백은 유지해야 합니다.

    예시:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    문자열을 받아 정렬된 버전을 반환하는 함수를 작성하세요.
    문자열의 정렬된 버전이란, 모든 단어(공백으로 구분)가
    ascii 값을 기준으로 오름차순으로 정렬된 문자들로 이루어진
    새로운 단어로 대체된 문자열입니다.
    참고: 문장의 단어 순서와 공백은 유지해야 합니다.

    예시:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    문자열을 받아서 정렬된 버전을 반환하는 함수를 작성하세요.
    정렬된 버전의 문자열은 모든 단어(공백으로 구분)가 새로운 단어로 바뀌고 모든 문자가
    ascii 값을 기준으로 오름차순으로 정렬된 문자열입니다.
    참고: 문장에서 단어와 공백의 순서를 유지해야 합니다.

    예를 들어:
    anti_shuffle('Hi')는 'Hi'를 반환합니다.
    anti_shuffle('hello')는 'ehllo'를 반환합니다.
    anti_shuffle('Hello World!!!')는 'Hello !!!Wdlor'를 반환합니다.
    """


def get_row(lst, x):
    """
    2차원 데이터가 중첩 리스트로 주어집니다.
    이는 행렬과 비슷하지만, 행렬과 달리
    각 행은 서로 다른 수의 열을 포함할 수 있습니다.
    lst와 정수 x가 주어졌을 때, 리스트에서 정수 x를 찾아
    [(x1, y1), (x2, y2) ...] 형태의 튜플 리스트를 반환합니다.
    각 튜플은 0부터 시작하는 좌표(행, 열)입니다.
    좌표는 처음에 행을 기준으로 오름차순으로 정렬합니다.
    또한 같은 행의 좌표는 열을 기준으로 내림차순으로 정렬합니다.

    예시:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    중첩된 목록으로 2차원 데이터가 주어집니다.
    이는 행렬과 유사하지만 행렬과 달리
    각 행에는 다른 수의 열이 포함될 수 있습니다.
    lst와 정수 x가 주어지면 목록에서 정수 x를 찾고
    튜플 목록 [(x1, y1), (x2, y2) ...]을 반환합니다. 이때
    각 튜플은 0부터 시작하는 좌표 - (행, 열)입니다.
    좌표를 처음에 행을 기준으로 오름차순으로 정렬합니다.
    또한 행의 좌표를 열을 기준으로 내림차순으로 정렬합니다.

    예시:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """


def sort_array(array):
    """
    음이 아닌 정수 배열이 주어지면 정렬 후 배열의 복사본을 반환합니다.
    첫 번째 인덱스 값과 마지막 인덱스 값의 합이 홀수이면 오름차순으로 정렬하고,
    첫 번째 인덱스 값과 마지막 인덱스 값의 합이 짝수이면 내림차순으로 정렬합니다.

    참고:
    * 주어진 배열을 변경하지 마세요.

    예시:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    비음수 정수로 이루어진 배열이 주어졌을 때, 주어진 배열을 정렬한 후의 복사본을 반환합니다.
    첫 번째 인덱스 값과 마지막 인덱스 값의 합이 홀수이면 주어진 배열을 오름차순으로 정렬하고,
    합이 짝수이면 내림차순으로 정렬합니다.

    참고:
    * 주어진 배열을 변경하지 마십시오.

    예시:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    음이 아닌 정수로 이루어진 배열이 주어지면, 정렬 후 배열의 복사본을 반환합니다.
    첫 번째 인덱스 값과 마지막 인덱스 값의 합이 홀수이면 오름차순으로 정렬하고,
    첫 번째 인덱스 값과 마지막 인덱스 값의 합이 짝수이면 내림차순으로 정렬합니다.

    Note:
    * 주어진 배열을 변경하지 마세요.

    예시:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """


def encrypt(s):
    """문자열을 인수로 받아 알파벳을 회전시켜 암호화된 문자열을 반환하는
    함수 encrypt를 만듭니다.
    알파벳은 각 문자가 두 자리를 곱한 뒤 두 자리를 이동하는 방식으로 회전해야 합니다.
    예를 들어:
    encrypt('hi')는 'lm'을 반환합니다.
    encrypt('asdfghjkl')은 'ewhjklnop'을 반환합니다.
    encrypt('gf')는 'kj'를 반환합니다.
    encrypt('et')는 'ix'를 반환합니다.
    """

def encrypt(s):
    """문자열을 인수로 받아 알파벳을 회전시켜 암호화된 문자열을 반환하는
    암호화 함수를 만듭니다.
    알파벳은 문자가 2를 곱한 만큼 아래로 이동하는 방식으로
    회전되어야 합니다.
    예시:
    encrypt('hi') returns 'lm'
    encrypt('asdfghjkl') returns 'ewhjklnop'
    encrypt('gf') returns 'kj'
    encrypt('et') returns 'ix'
    """

def encrypt(s):
    """문자열을 인수로 받아 알파벳이 회전된 문자열을 반환하는
    함수 encrypt를 생성합니다. 알파벳은 두 자리씩 곱하여
    각 알파벳이 두 칸씩 아래로 이동하도록 회전해야 합니다.
    예를 들어:
    encrypt('hi')는 'lm'을 반환합니다.
    encrypt('asdfghjkl')는 'ewhjklnop'을 반환합니다.
    encrypt('gf')는 'kj'를 반환합니다.
    encrypt('et')는 'ix'를 반환합니다.
    """


def next_smallest(lst):
    """
    정수 목록이 주어집니다.
    목록에서 두 번째로 작은 요소를 반환하는 next_smallest() 함수를 작성하세요.
    해당 요소가 없으면 None을 반환합니다.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst):
    """
    정수 리스트가 주어집니다.
    리스트에서 두 번째로 작은 요소를 반환하는 next_smallest() 함수를 작성하세요.
    해당 요소가 없는 경우 None을 반환합니다.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """


def is_bored(S):
    """
    문자열로 된 단어들이 주어지면, 지루함의 개수를 세는 것이 당신의 임무입니다.
    지루함이란 'I'라는 단어로 시작하는 문장을 의미합니다.
    문장은 '.', '?' 또는 '!'로 구분됩니다.

    예시:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    단어들로 구성된 문자열이 주어지며, 지루함의 개수를 세는 것이 과제입니다.
    지루함이란 'I'라는 단어로 시작하는 문장을 의미합니다.
    문장은 '.', '?' 또는 '!'로 구분됩니다.

    예시:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    문자열이 주어지면, 당신의 작업은 지루함의 수를 세는 것입니다.
    지루함은 "I"로 시작하는 문장입니다.
    문장은 '.', '?' 또는 '!'로 구분됩니다.

    예를 들어:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """


def any_int(x, y, z):
    '''
    3개의 숫자를 받는 함수를 만듭니다.
    숫자 중 하나가 다른 두 숫자의 합과 같고, 모든 숫자가 정수인 경우 true를 반환합니다.
    다른 모든 경우에는 false를 반환합니다.

    Examples
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    숫자 3개를 받는 함수를 만듭니다.
    숫자 중 하나가 다른 두 개의 합과 같고 모든 숫자가 정수이면 true를 반환합니다.
    다른 경우에는 false를 반환합니다.

    예제
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    3개의 숫자를 받는 함수를 생성합니다.
    세 숫자 중 하나가 나머지 두 숫자의 합과 같고, 모든 숫자가 정수인 경우 true를 반환합니다.
    다른 경우에는 false를 반환합니다.

    예시
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''


def encode(message):
    """
    메시지를 받아서 다음과 같은 방식으로 인코딩하는 함수를 작성하세요:
    모든 문자의 대소문자를 바꾸고, 메시지의 모든 모음을 영어 알파벳에서
    해당 모음보다 2자리 뒤에 있는 문자로 교체합니다.
    문자만 있다고 가정합니다.

    예시:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    메시지를 받아서 모든 문자의 대소문자를 바꾸고,
    메시지의 모든 모음을 영어 알파벳에서 해당 모음보다
    2자리 앞에 있는 문자로 대체하는 함수를 작성하세요.
    오직 문자만 있다고 가정합니다.

    예시:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    메시지를 받아서 모든 문자의 대소문자를 바꾸고,
    메시지의 모든 모음을 영어 알파벳에서 해당 모음보다
    두 글자 앞에 있는 문자로 대체하는 함수를 작성하세요.
    오직 문자만 있다고 가정합니다.

    예시:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """정수의 리스트가 주어집니다.
    가장 큰 소수 값을 찾아서 그 자리수의 합을 반환해야 합니다.

    예시:
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3]의 경우 출력은 10이어야 합니다.
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]의 경우 출력은 25이어야 합니다.
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3]의 경우 출력은 13이어야 합니다.
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6]의 경우 출력은 11이어야 합니다.
    lst = [0,81,12,3,1,21]의 경우 출력은 3이어야 합니다.
    lst = [0,8,1,2,1,7]의 경우 출력은 7이어야 합니다.
    """

def skjkasdkd(lst):
    """정수 리스트가 주어집니다.
    가장 큰 소수 값을 찾아 그 자릿수의 합을 반환해야 합니다.

    예시:
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3]인 경우 출력은 10이어야 합니다
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]인 경우 출력은 25이어야 합니다
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3]인 경우 출력은 13이어야 합니다
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6]인 경우 출력은 11이어야 합니다
    lst = [0,81,12,3,1,21]인 경우 출력은 3이어야 합니다
    lst = [0,8,1,2,1,7]인 경우 출력은 7이어야 합니다
    """

def skjkasdkd(lst):
    """정수 목록이 주어졌습니다.
    가장 큰 소수 값을 찾아 그 자릿수의 합을 반환해야 합니다.

    예시:
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3]의 경우 출력은 10이어야 합니다.
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]의 경우 출력은 25이어야 합니다.
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3]의 경우 출력은 13이어야 합니다.
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] 출력은 11이어야 합니다.
    lst = [0,81,12,3,1,21]의 경우 출력은 3이어야 합니다.
    lst = [0,8,1,2,1,7]의 경우 출력은 7이어야 합니다.
    """


def check_dict_case(dict):
    """
    주어진 딕셔너리에 대해, 모든 키가 소문자 문자열이거나 모든 키가 대문자 문자열인 경우
    True를 반환하고, 그렇지 않은 경우 False를 반환합니다.
    주어진 딕셔너리가 비어있는 경우 함수는 False를 반환해야 합니다.
    예시:
    check_dict_case({"a":"apple", "b":"banana"}) 는 True를 반환해야 합니다.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) 는 False를 반환해야 합니다.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) 는 False를 반환해야 합니다.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) 는 False를 반환해야 합니다.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) 는 True를 반환해야 합니다.
    """

def check_dict_case(dict):
    """
    사전이 주어졌을 때, 모든 키가 소문자 문자열이거나 모든 키가 대문자 문자열이면 True를 반환하고,
    그렇지 않으면 False를 반환합니다.
    주어진 사전이 비어 있으면 함수는 False를 반환해야 합니다.
    예시:
    check_dict_case({"a":"apple", "b":"banana"})는 True를 반환해야 합니다.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"})는 False를 반환해야 합니다.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"})는 False를 반환해야 합니다.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"})는 False를 반환해야 합니다.
    check_dict_case({"STATE":"NC", "ZIP":"12345" })는 True를 반환해야 합니다.
    """

def check_dict_case(dict):
    """
    주어진 사전에서 모든 키가 소문자 문자열이거나 모든 키가 대문자 문자열인 경우 True를 반환하고,
    그렇지 않으면 False를 반환합니다.
    주어진 사전이 비어 있는 경우 함수는 False를 반환해야 합니다.
    예시:
    check_dict_case({"a":"apple", "b":"banana"})는 True를 반환해야 합니다.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"})는 False를 반환해야 합니다.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"})는 False를 반환해야 합니다.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"})는 False를 반환해야 합니다.
    check_dict_case({"STATE":"NC", "ZIP":"12345" })는 진실.
    """


def count_up_to(n):
    """음이 아닌 정수를 받아 n보다 작은 첫 n개의 소수를 배열로 반환하는 함수를 구현하세요.
    예시:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """음이 아닌 정수를 받아서 n보다 작은 소수인 처음 n개의 정수 배열을 반환하는 함수를 구현합니다.
    예를 들어:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """비음수 정수를 받아서, n보다 작은 소수인 처음 n개의 정수를 배열로 반환하는 함수를 구현하세요.
    예를 들어:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """


def multiply(a, b):
    """두 정수를 받아서 각각의 일의 자리 숫자의 곱을 반환하는 함수를 완성하세요.
    입력은 항상 유효하다고 가정합니다.
    예시:
    multiply(148, 412)는 16을 반환해야 합니다.
    multiply(19, 28)는 72를 반환해야 합니다.
    multiply(2020, 1851)는 0을 반환해야 합니다.
    multiply(14,-15)는 20을 반환해야 합니다.
    """

def multiply(a, b):
    """두 정수를 받아 각각의 일의 자리 숫자의 곱을 반환하는 함수를 완성하세요.
    입력은 항상 유효하다고 가정합니다.
    예시:
    multiply(148, 412)는 16을 반환해야 합니다.
    multiply(19, 28)은 72를 반환해야 합니다.
    multiply(2020, 1851)은 0을 반환해야 합니다.
    multiply(14,-15)는 20을 반환해야 합니다.
    """

def duplicate(a, b):
    """두 정수를 받아서 각 수의 일의 자리 숫자의 곱을 반환하는
    함수를 완성하세요.
    입력은 항상 유효하다고 가정합니다.
    예시:
    multiply(148, 412)는 16을 반환합니다.
    multiply(19, 28)는 72를 반환합니다.
    multiply(2020, 1851)는 0을 반환합니다.
    multiply(14,-15)는 20을 반환합니다.
    """


def count_upper(s):
    """
    주어진 문자열 s에서 짝수 인덱스에 있는 대문자 모음의 개수를 세는 함수입니다.

    예시:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """

def count_upper(s):
    """
    문자열 s가 주어졌을 때, 짝수 인덱스에 있는 대문자 모음의 개수를 세어라.

    예를 들어:
    count_upper('aBCdEf')는 1을 반환한다
    count_upper('abcdefg')는 0을 반환한다
    count_upper('dBBE')는 0을 반환한다
    """

def count_upper(s):
    """
    문자열 s가 주어지면 짝수 인덱스에 있는 대문자 모음의 개수를 센다.

    예를 들어:
    count_upper('aBCdEf')는 1을 반환한다
    count_upper('abcdefg')는 0을 반환한다
    count_upper('dBBE')는 0을 반환한다
    """


def closest_integer(value):
    '''
    주어진 숫자를 나타내는 값(문자열)을 받아서 가장 가까운 정수를 반환하는 함수를 만듭니다.
    만약 두 정수로부터 같은 거리에 있다면, 0에서 멀어지는 방향으로 반올림합니다.

    예시
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    참고:
    0에서 멀어지는 방향으로 반올림한다는 것은 주어진 숫자가 두 정수로부터
    같은 거리에 있을 때, 0으로부터 가장 먼 정수를 반환해야 한다는 의미입니다.
    예를 들어 closest_integer("14.5")는 15를 반환해야 하고,
    closest_integer("-14.5")는 -15를 반환해야 합니다.
    '''

def closest_integer(value):
    '''
    숫자를 나타내는 문자열 값을 받아서
    가장 가까운 정수를 반환하는 함수를 만드세요.
    만약 숫자가 두 정수와 같은 거리에 있다면, 0에서 멀어지는 방향으로 반올림하세요.

    예시
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    참고:
    0에서 멀어지는 방향으로 반올림한다는 것은 주어진 숫자가 두 정수와 같은 거리에 있을 때,
    반환해야 하는 정수는 0에서 가장 먼 정수라는 것을 의미합니다. 예를 들어 closest_integer("14.5")는
    15를 반환해야 하고, closest_integer("-14.5")는 -15를 반환해야 합니다.
    '''

def closest_integer(value):
    '''
    문자열로 표현된 숫자를 받아 가장 가까운 정수를 반환하는 함수를 만드세요.
    만약 두 정수로부터 같은 거리에 있다면, 0에서 더 멀리 있는 쪽으로 반올림합니다.

    예시
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    참고:
    0에서 멀어지는 방향으로 반올림한다는 것은, 주어진 숫자가 두 정수와 같은 거리에
    있을 때 0으로부터 더 멀리 있는 정수를 반환해야 한다는 의미입니다.
    예를 들어 closest_integer("14.5")는 15를 반환해야 하고
    closest_integer("-14.5")는 -15를 반환해야 합니다.
    '''


def make_a_pile(n):
    """
    양의 정수 n이 주어지면, n 레벨의 돌 더미를 만들어야 합니다.
    첫 번째 레벨에는 n개의 돌이 있습니다.
    다음 레벨의 돌 개수는 다음과 같습니다.
        - n이 홀수이면 다음 홀수.
        - n이 짝수이면 다음 짝수.
    각 레벨의 돌의 수를 리스트로 반환합니다. 여기서 인덱스 i의 요소는
    레벨 (i+1)의 돌의 수를 나타냅니다.

    예시:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    양의 정수 n이 주어지면, n 레벨의 돌 더미를 만들어야 합니다.
    첫 번째 레벨은 n개의 돌을 가집니다.
    다음 레벨의 돌의 개수는:
        - n이 홀수인 경우 다음 홀수
        - n이 짝수인 경우 다음 짝수
    각 레벨의 돌의 개수를 리스트로 반환하며, 인덱스 i의 요소는
    레벨 (i+1)의 돌의 개수를 나타냅니다.

    예시:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    양의 정수 n이 주어지면, n 레벨의 돌무더기를 만들어야 합니다.
    첫 번째 레벨에는 n개의 돌이 있습니다.
    다음 레벨의 돌의 수는:
        - n이 홀수이면 다음 홀수입니다.
        - n이 짝수이면 다음 짝수입니다.
    각 레벨의 돌의 수를 리스트로 반환합니다. 여기서 인덱스 i의 요소는
    레벨 (i+1)의 돌의 수를 나타냅니다.

    예시:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    쉼표나 공백으로 구분된 단어들의 문자열이 주어집니다. 당신의 임무는
    문자열을 단어들로 분리하고 단어들의 배열을 반환하는 것입니다.

    예시:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    쉼표나 공백으로 구분된 단어 문자열이 제공됩니다. 작업은
    문자열을 단어로 분할하고 단어 배열을 반환하는 것입니다.

    예를 들어
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    쉼표나 공백으로 구분된 단어 문자열이 제공됩니다. 작업은
    문자열을 단어로 분할하고 단어 배열을 반환하는 것입니다.

    예를 들어:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """


def choose_num(x, y):
    """이 함수는 두 개의 양수 x와 y를 받아서 [x, y] 범위 내에 있는 가장 큰 짝수 정수를 반환합니다. 그러한 숫자가 없으면 함수는 -1을 반환해야 합니다.

    예를 들어:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """이 함수는 두 양의 정수 x와 y를 받아서
    범위 [x, y]에 포함된 가장 큰 짝수를 반환합니다.
    만약 그러한 숫자가 없다면, 함수는 -1을 반환해야 합니다.

    예시:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """이 함수는 두 개의 양수 x와 y를 받아서 [x, y] 범위 내에 있는 가장 큰 짝수 정수를 반환합니다.
    만약 그러한 숫자가 없다면, 함수는 -1을 반환해야 합니다.
    예를 들어:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """두 개의 양의 정수 n과 m이 주어지고, 여러분의 과제는 n에서 m까지의 정수(n과 m 포함)
    의 평균을 계산하는 것입니다.
    답을 가장 가까운 정수로 반올림하고 이를 이진수로 변환합니다.
    n이 m보다 크면 -1을 반환합니다.
    예시:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """두 개의 양의 정수 n과 m이 주어지며, n부터 m까지의 정수들의
    평균을 계산하는 것이 과제입니다.
    답을 가장 가까운 정수로 반올림하고 이진수로 변환하세요.
    만약 n이 m보다 크다면, -1을 반환하세요.
    예시:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """두 개의 양의 정수 n과 m이 주어지고, 여러분의 과제는 n에서 m까지의 정수(n과 m 포함)의 평균을 계산하는 것입니다.
    답을 가장 가까운 정수로 반올림하고 이를 이진수로 변환합니다.
    n이 m보다 크면 -1을 반환합니다.
    예시:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """양의 정수 리스트 x가 주어졌을 때, 짝수 숫자가 전혀 포함되지 않은
    모든 요소들을 정렬된 리스트로 반환합니다.

    참고: 반환된 리스트는 오름차순으로 정렬되어야 합니다.

    예시:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """양의 정수로 이루어진 리스트 x가 주어지면 짝수가 없는 모든
    숫자의 정렬된 목록을 반환합니다.

    참고: 반환된 목록은 오름차순으로 정렬되어야 합니다.

    예를 들어:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """양의 정수들의 목록 x가 주어지면 짝수 숫자를 포함하지 않는 모든
    요소의 정렬된 목록을 반환합니다.

    참고: 반환된 목록은 오름차순으로 정렬되어야 합니다.

    예를 들어:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    1에서 9 사이의 정수 배열이 주어지면, 해당 정수들을 정렬하고,
    결과 배열을 뒤집은 다음, 각 숫자를 "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"에
    해당하는 이름으로 바꿉니다.

    예시:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      배열이 비어있다면, 빈 배열을 반환합니다:
      arr = []
      return []

      배열에 이상한 숫자가 있다면 무시합니다:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    1부터 9까지의 정수를 포함하는 배열이 주어졌을 때,
    해당 정수들을 정렬하고, 결과 배열을 뒤집은 다음, 각 숫자를
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"에 해당하는 이름으로 바꿉니다.

    For example:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      배열이 비어있는 경우, 빈 배열을 반환합니다:
      arr = []
      return []

      배열에 이상한 숫자가 있으면 무시합니다:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    정수 배열이 주어지면 1에서 9 사이의 정수를 정렬하고,
    결과 배열을 뒤집은 다음 각 숫자를 해당 이름으로 바꿉니다.
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    예를 들어:
    arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
    return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

    배열이 비어 있으면, 빈 배열을 반환합니다:
    arr = []
    return []

    배열에 이상한 숫자가 있으면 무시합니다:
    arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
    return = ['One']
    """


def f(n):
    """ 매개변수로 n을 취하고,
    크기가 n인 리스트를 반환하는 함수 f를 구현합니다. 이때 i가 짝수이면 인덱스 i에 있는 요소의 값이 i의 팩토리얼이고,
    그렇지 않으면 1에서 i까지의 숫자의 합입니다.
    i는 1부터 시작합니다.
    i의 팩토리얼은 1에서 i까지의 숫자를 곱한 것입니다(1 * 2 * ... * i).
    예시:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ 함수 f를 구현합니다. 이 함수는 n을 매개변수로 받아들이고,
    크기가 n인 리스트를 반환하는 함수 f를 구현합니다. 이때 i가 짝수이면 인덱스 i에 있는 요소의 값이 i의 팩토리얼이고,
    그렇지 않으면 1에서 i까지의 숫자의 합입니다.
    i는 1부터 시작합니다.
    i의 팩토리얼은 1에서 i까지의 숫자를 곱한 것입니다(1 * 2 * ... * i).
    예시:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ n을 매개변수로 받는 함수 f를 구현하세요.
    크기가 n인 리스트를 반환하며, 인덱스 i의 요소 값은 i가 짝수일 경우 i의 팩토리얼이고,
    그렇지 않으면 1부터 i까지의 숫자의 합입니다.
    i는 1부터 시작합니다.
    i의 팩토리얼은 1부터 i까지의 숫자를 곱한 값입니다 (1 * 2 * ... * i).
    에시:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    양의 정수 n이 주어졌을 때, range(1, n) 범위 내에서 짝수와 홀수인
    정수 팰린드롬의 개수를 튜플로 반환합니다.

    예시 1:

        Input: 3
        Output: (1, 2)
        설명:
        정수 팰린드롬은 1, 2, 3입니다. 그 중 하나는 짝수이고, 두 개는 홀수입니다.

    예시 2:

        Input: 12
        Output: (4, 6)
        설명:
        정수 팰린드롬은 1, 2, 3, 4, 5, 6, 7, 8, 9, 11입니다. 그 중 네 개는 짝수이고, 여섯 개는 홀수입니다.

    참고:
        1. 1 <= n <= 10^3
        2. 반환되는 튜플은 각각 짝수와 홀수인 정수 팰린드롬의 개수입니다.
    """

def even_odd_palindrome(n):
    """
    양의 정수 n이 주어지면 범위(1, n) 내에 있는 짝수 및 홀수 정수 팰린드롬의 개수를 갖는 튜플을 반환합니다.

    예제 1:

        입력: 3
        출력: (1, 2)
        설명:
        정수 팰린드롬은 1, 2, 3입니다. 그 중 하나는 짝수이고, 그 중 두 개는 홀수입니다.

    예제 2:

        입력: 12
        출력: (4, 6)
        설명:
        정수 팰린드롬은 1, 2, 3, 4, 5, 6, 7, 8, 9, 11입니다. 그 중 네 개는 짝수이고, 그 중 여섯 개는 홀수입니다.

    참고:
        1. 1 <= n <= 10^3
        2. 반환된 튜플에는 각각 짝수 및 홀수 정수 팰린드롬의 개수가 있습니다.
    """

def even_odd_palindrome(n):
    """
    양의 정수 n이 주어졌을 때, 범위(1, n) 내에 포함된 짝수 및 홀수 정수 팰린드롬의 수를 가진 튜플을 반환합니다.

    예제 1:

        입력: 3
        출력: (1, 2)
        설명:
        정수 팰린드롬은 1, 2, 3입니다. 그 중 하나는 짝수이고, 두 개는 홀수입니다.

    예제 2:

        입력: 12
        출력: (4, 6)
        설명:
        정수 팰린드롬은 1, 2, 3, 4, 5, 6, 7, 8, 9, 11입니다. 그 중 네 개는 짝수이고, 여섯 개는 홀수입니다.

    참고:
        1. 1 <= n <= 10^3
        2. 반환된 튜플은 각각 짝수 및 홀수 정수 팰린드롬의 수를 가집니다.
    """


def count_nums(arr):
    """
    정수 배열을 받아서 각 숫자의 자릿수 합이 0보다 큰 요소의 개수를 반환하는 함수입니다.
    음수인 경우, 첫 번째 부호가 있는 자릿수는 음수가 됩니다:
    예시) -123의 부호가 있는 자릿수는 -1, 2, 3입니다.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    정수 배열을 받아서 숫자 합이 0보다 큰 요소의 개수를 반환하는 count_nums 함수를 작성하세요.
    숫자가 음수이면 첫 번째 부호 있는 숫자는 음수가 됩니다.
    예를 들어 -123은 -1, 2, 3의 부호 있는 숫자를 갖습니다.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    정수 배열을 받아서 각 자릿수의 합이 0보다 큰 요소들의 개수를 반환하는
    함수 count_nums를 작성하세요.
    숫자가 음수인 경우, 첫 번째 부호가 있는 자릿수는 음수가 됩니다:
    예를 들어 -123의 부호가 있는 자릿수는 -1, 2, 3입니다.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """우리는 N개의 정수 arr[1], arr[2], ..., arr[N]로 이루어진 배열 'arr'을 가지고 있습니다.
    배열의 숫자는 무작위로 정렬되어 있습니다. 주어진 배열에 대해 다음 작업을 수행하여
    배열을 비감소 순서로 정렬할 수 있는지 확인하는 것이 과제입니다:
        오른쪽으로 이동하는 작업을 원하는 만큼 수행할 수 있습니다.

    오른쪽으로 이동하는 작업은 배열의 모든 요소를 오른쪽 방향으로 한 위치씩 이동시키는 것을 의미합니다.
    배열의 마지막 요소는 배열의 시작 위치, 즉 0번째 인덱스로 이동됩니다.

    위의 작업을 수행하여 정렬된 배열을 얻을 수 있다면 True를 반환하고, 그렇지 않으면 False를 반환합니다.
    주어진 배열이 비어 있다면 True를 반환합니다.

    참고: 주어진 리스트는 고유한 요소를 가지고 있는 것이 보장됩니다.

    예시:

    move_one_ball([3, 4, 5, 1, 2])==>True
    설명: 2번의 오른쪽 이동 작업을 수행하여 주어진 배열에 대해 비감소 순서를 달성할 수 있습니다.
    move_one_ball([3, 5, 4, 1, 2])==>False
    설명: 주어진 배열에 대해 어떤 수의 오른쪽 이동 작업을 수행하더라도 비감소 순서를 얻을 수 없습니다.

    """

def move_one_ball(arr):
    """N개의 정수로 이루어진 배열 'arr'이 있습니다. arr[1], arr[2], ..., arr[N].
    배열의 숫자들은 무작위로 정렬되어 있습니다. 주어진 배열에서 다음 연산을 수행하여
    비감소 순서로 정렬된 배열을 얻을 수 있는지 확인하는 것이 당신의 임무입니다:
        오른쪽 시프트 연산을 원하는 만큼 수행할 수 있습니다.

    하나의 오른쪽 시프트 연산은 배열의 모든 요소를 오른쪽 방향으로 한 위치씩
    이동시키는 것을 의미합니다. 배열의 마지막 요소는 배열의 시작 위치인
    0번째 인덱스로 이동됩니다.

    위의 연산을 수행하여 정렬된 배열을 얻을 수 있다면 True를 반환하고,
    그렇지 않다면 False를 반환합니다.
    주어진 배열이 비어있다면 True를 반환합니다.

    참고: 주어진 리스트는 고유한 요소만을 포함하는 것이 보장됩니다.

    예시:

    move_one_ball([3, 4, 5, 1, 2])==>True
    설명: 2번의 오른쪽 시프트 연산을 수행하면 주어진 배열을
          비감소 순서로 만들 수 있습니다.
    move_one_ball([3, 5, 4, 1, 2])==>False
    설명: 어떤 횟수의 오른쪽 시프트 연산을 수행하더라도
          주어진 배열을 비감소 순서로 만들 수 없습니다.

    """

def move_one_ball(arr):
    """우리는 N개의 정수 arr[1], arr[2], ..., arr[N]로 이루어진 배열 'arr'을 가지고 있습니다.
    배열의 숫자는 무작위로 정렬되어 있습니다. 주어진 배열에 대해 다음 작업을 수행하여
    배열을 비감소 순서로 정렬할 수 있는지 확인하는 것이 과제입니다:
        오른쪽으로 이동하는 작업을 원하는 만큼 수행할 수 있습니다.

    오른쪽으로 이동하는 작업은 배열의 모든 요소를 오른쪽 방향으로 한 위치씩 이동시키는 것을 의미합니다.
    배열의 마지막 요소는 배열의 시작 위치, 즉 0번째 인덱스로 이동됩니다.

    위의 연산을 수행하여 정렬된 배열을 얻을 수 있는 경우
    True를 반환하고 그렇지 않은 경우 False를 반환합니다.
    주어진 배열이 비어 있는 경우 True를 반환합니다.

    참고: 주어진 목록은 고유한 요소를 갖는 것이 보장됩니다.

    예를 들어:

    move_one_ball([3, 4, 5, 1, 2])==>True
    설명: 오른쪽 이동 연산을 2번 수행하면 주어진 배열에 대해 감소하지 않는 순서를 얻을 수 있습니다.
    move_one_ball([3, 5, 4, 1, 2])==>False
    설명: 주어진 배열에 대해 감소하지 않는 순서를 얻는 것은 오른쪽 이동 연산을 아무리 많이 수행해도 불가능합니다.

    """


def exchange(lst1, lst2):
    """이 문제에서는 두 개의 숫자 리스트를 받아서, lst1을 모두 짝수로만 이루어진
    리스트로 만들기 위해 두 리스트 간에 원소를 교환할 수 있는지 판단하는 함수를 구현합니다.
    lst1과 lst2 사이의 교환 가능한 원소 수에는 제한이 없습니다.
    lst1과 lst2 사이에서 원소를 교환하여 lst1의 모든 원소를 짝수로 만들 수 있다면
    "YES"를 반환합니다.
    그렇지 않다면 "NO"를 반환합니다.
    예시:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    입력 리스트는 비어있지 않다고 가정합니다.
    """

def exchange(lst1, lst2):
    """이 문제에서는 숫자 목록 두 개를 가져오고,
    두 목록 간에 요소를 교환하여 lst1을 짝수만 있는 목록으로 만들 수 있는지 여부를 판별하는 함수를 구현합니다.
    lst1과 lst2 간에 교환되는 요소의 수에는 제한이 없습니다.
    lst1과 lst2 간에 요소를 교환하여
    lst1의 모든 요소를 짝수로 만들 수 있는 경우 "YES"를 반환합니다.
    그렇지 않으면 "NO"를 반환합니다.
    예를 들어:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    입력 목록은 비어 있지 않을 것으로 가정합니다.
    """

def exchange(lst1, lst2):
    """이 문제에서는 두 숫자 리스트를 받아들이고,
    lst1을 짝수만으로 구성된 리스트로 만들기 위해
    두 리스트 사이에서 요소 교환이 가능한지를 결정하는 함수를 구현합니다.
    st1과 lst2 사이에서 교환할 수 있는 요소의 수에는 제한이 없습니다.
    lst1의 모든 요소를 짝수로 만들기 위해 lst1과 lst2 사이에서
    요소를 교환할 수 있다면 "YES"를 반환합니다.
    그렇지 않으면 "NO"를 반환합니다.
    예를 들어:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    입력 리스트는 비어 있지 않다고 가정합니다.
    """


def histogram(test):
    """공백으로 구분된 소문자 문자열이 주어지면, 가장 많이 반복되는 문자의 사전을 반환하고
    해당 문자의 개수를 포함합니다.
    여러 문자가 동일한 발생 횟수를 가지면, 모두 반환합니다.

    예시:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """공백으로 구분된 소문자를 나타내는 문자열이 주어지면 가장 많이 반
    복된 문자와 해당 횟수를 포함하는 사전을 반환합니다.
    여러 문자가 동일한 발생을 갖는 경우 모든 문자를 반환합니다.

    예시:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """공백으로 구분된 소문자로 이루어진 문자열이 주어졌을 때, 가장 많이 반복되는 문자와
    해당 문자의 출현 횟수를 포함하는 사전을 반환합니다.
    여러 문자가 동일한 횟수로 출현하는 경우, 해당하는 모든 문자를 반환합니다.

    예시:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


def reverse_delete(s, c):
    """작업
    두 개의 문자열 s와 c가 주어집니다. 문자열 s에서 c에 포함된 모든 문자를 삭제한 후,
    결과 문자열이 팰린드롬인지 확인합니다.
    팰린드롬은 앞으로 읽을 때와 뒤로 읽을 때 동일한 문자열입니다.
    함수는 결과 문자열과 그 확인에 대한 True/False를 포함하는 튜플을 반환해야 합니다.
    예시:
    s = "abcde", c = "ae" 일 경우, 결과는 ('bcd', False) 여야 합니다.
    s = "abcdef", c = "b" 일 경우, 결과는 ('acdef', False) 여야 합니다.
    s = "abcdedcba", c = "ab" 일 경우, 결과는 ('cdedc', True) 여야 합니다.
    """

def reverse_delete(s,c):
    """작업
    문자열 s와 c가 주어지면, s에서 c의 모든 문자와 동일한 문자들을 삭제한 후
    결과 문자열이 회문인지 확인해야 합니다.
    회문이란 앞에서부터 읽으나 뒤에서부터 읽으나 동일한 문자열을 말합니다.
    결과 문자열과 True/False 확인 결과를 튜플로 반환해야 합니다.
    예시
    s = "abcde", c = "ae"인 경우, 결과는 ('bcd',False)여야 합니다
    s = "abcdef", c = "b"인 경우, 결과는 ('acdef',False)여야 합니다
    s = "abcdedcba", c = "ab"인 경우, 결과는 ('cdedc',True)여야 합니다
    """


def odd_count(lst):
    """숫자로만 구성된 문자열 리스트가 주어졌을 때, 리스트를 반환합니다.
    출력의 각 요소 i는 "입력의 i번째 문자열에 있는 홀수 요소의 개수"여야 하며,
    모든 i는 입력의 i번째 문자열에 있는 홀수 숫자의 개수로 대체되어야 합니다.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """

def odd_count(lst):
    """각 문자열이 숫자로만 구성된 문자열 목록이 주어지면 목록을 반환합니다.
    출력의 각 요소 i는 "입력의 i번째 문자열에 있는 홀수 요소의 수"여야 합니다.
    여기서 모든 i는 입력의 i번째 문자열에 있는 홀수 숫자의 수로 대체되어야 합니다.

    >>> odd_count(['1234567'])
    ["4nput의 문자열 4에 있는 홀수 요소의 수."]
    >>> odd_count(['3',"11111111"])
    ["1nput의 문자열 1에 있는 홀수 요소의 수.",
    "8nput의 문자열 8에 있는 홀수 요소의 수."]
    """


def minSubArraySum(nums):
    """
    정수 배열 nums가 주어졌을 때, nums의 비어 있지 않은 부분 배열의 최소 합을 찾습니다.
    예제
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    정수 배열 nums가 주어졌을 때, nums의 비어 있지 않은 부분 배열의 최소 합을 계산합니다.
    예시
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    정수 배열 nums가 주어졌을 때, nums의 비어있지 않은 하위 배열의 최소 합을 찾습니다.
    예시
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    우물들의 직사각형 격자가 주어집니다. 각 행은 하나의 우물을 나타내며,
    행의 각 1은 물 한 단위를 나타냅니다.
    각 우물에는 물을 추출하는 데 사용할 수 있는 양동이가 있으며,
    모든 양동이는 동일한 용량을 가집니다.
    당신의 임무는 양동이를 사용하여 우물을 비우는 것입니다.
    양동이를 내려야 하는 횟수를 출력하세요.

    예시 1:
        Input:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Output: 6

    예시 2:
        Input:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Output: 5

    예시 3:
        Input:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Output: 0

    제약조건:
        * 모든 우물은 같은 길이를 가집니다
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    직사각형 우물 그리드가 주어집니다. 각 행은 하나의 우물을 나타내고,
    행의 각 1은 물 한 단위를 나타냅니다.
    각 우물에는 물을 추출하는 데 사용할 수 있는 해당 버킷이 있으며,
    모든 버킷의 용량은 동일합니다.
    작업은 버킷을 사용하여 우물을 비우는 것입니다.
    버킷을 낮추어야 하는 횟수를 출력합니다.
    예제 1:
        입력:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        출력: 6

    예제 2:
       입력:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        출력: 5

    예제 3:
        입력t:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        출력: 0

    제약 조건:
        * 모든 웰의 길이는 동일합니다
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    직사각형 우물 그리드가 주어집니다. 각 행은 하나의 우물을 나타내고,
    행의 각 1은 물 한 단위를 나타냅니다.
    각 우물에는 물을 추출하는 데 사용할 수 있는 해당 버킷이 있으며,
    모든 버킷의 용량은 동일합니다.
    작업은 버킷을 사용하여 우물을 비우는 것입니다.
    버킷을 낮추어야 하는 횟수를 출력합니다.

    예제 1:
        입력:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        출력: 6

    예제 2:
        입력:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        출력: 5

    예제 3:
        입력:
        grid : [[0,0,0], [0,0,0]]
        bucket_capacity : 5
        출력: 0

    제약 조건:
        * 모든 웰의 길이는 동일합니다.
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    이 Kata에서는 이진수 표현에서 1의 개수에 따라
    음이 아닌 정수 배열을 오름차순으로 정렬해야 합니다.
    1의 개수가 같은 경우에는 십진수 값을 기준으로 정렬합니다.

    다음과 같이 구현되어야 합니다:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    이 Kata에서는 이진수 표현에서 1의 개수에 따라
    음이 아닌 정수 배열을 오름차순으로 정렬해야 합니다.
    1의 개수가 같은 경우 십진수 값을 기준으로 정렬합니다.

    다음과 같이 구현되어야 합니다:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    이 Kata에서는 0 이상의 정수 배열을 이진 표현에서 1의 개수에 따라 오름차순으로 정렬해야 합니다.
    1의 개수가 같은 경우, 십진수 값을 기준으로 정렬합니다.

    다음과 같이 구현해야 합니다.
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """


def select_words(s, n):
    """문자열 s와 자연수 n이 주어졌을 때, 정확히 n개의 자음을 포함하는
    문자열 s의 모든 단어를 리스트로 반환하는 함수를 구현해야 합니다.
    이 단어들은 문자열 s에 나타나는 순서대로 반환됩니다.
    문자열 s가 비어 있으면 함수는 빈 리스트를 반환해야 합니다.
    참고: 입력 문자열은 오직 문자와 공백만 포함한다고 가정할 수 있습니다.
    예시:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """주어진 문자열 s와 자연수 n에 대해, 문자열 s에서 정확히 n개의 자음을 포함하는
    모든 단어를 s에 나타나는 순서대로 반환하는 함수를 구현해야 합니다.
    문자열 s가 비어있다면 함수는 빈 리스트를 반환해야 합니다.
    참고: 입력 문자열은 문자와 공백만 포함한다고 가정할 수 있습니다.
    예시:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """주어진 문자열 s와 자연수 n에 대해, 문자열 s에서 정확히 n개의 자음을 포함하는
    모든 단어를 문자열에 나타나는 순서대로 반환하는 함수를 구현해야 합니다.
    문자열 s가 비어있는 경우 함수는 빈 리스트를 반환해야 합니다.
    참고: 입력 문자열은 문자와 공백만 포함한다고 가정할 수 있습니다.
    예시:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """