def get_closest_vowel(word):
    """
    하나의 단어가 주어집니다. 당신의 임무는 단어의 오른쪽에서부터 두 자음 사이에 있는
    가장 가까운 모음을 찾는 것입니다(대소문자 구분).

    단어의 시작과 끝에 있는 모음은 계산하지 않습니다. 위 조건을 만족하는 모음을
    찾지 못한 경우 빈 문자열을 반환합니다.

    주어진 문자열은 영어 알파벳으로만 구성되어 있다고 가정할 수 있습니다.

    예시:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """단어가 주어집니다. 당신의 작업은 단어의 오른쪽에서 두 자음 사이에 있는
    가장 가까운 모음을 찾는 것입니다 (대소문자 구분).

    시작과 끝에 있는 모음은 포함되지 않습니다. 위 조건을 만족하는 모음을 찾지 못하면
    빈 문자열을 반환합니다.

    주어진 문자열은 영어 문자만 포함한다고 가정할 수 있습니다.

    예시:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """자음 사이에 있는 모음 중 단어의 오른쪽에서 가장 가까운 모음을 찾는 것이 과제입니다
    (대소문자 구분).

    단어의 시작과 끝에 있는 모음은 계산하지 않습니다. 위의 조건을 만족하는 모음을 찾지
    못한 경우 빈 문자열을 반환합니다.

    주어진 문자열은 영어 문자만 포함한다고 가정할 수 있습니다.

    예시:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    두 개의 문자열로 구성된 리스트가 주어집니다. 두 문자열은 모두
    여는 괄호 '(' 또는 닫는 괄호 ')'로만 이루어져 있습니다.
    당신의 임무는 두 문자열을 어떤 순서로든 연결했을 때
    결과 문자열이 올바른 문자열이 될 수 있는지 확인하는 것입니다.
    문자열 S는 그 안의 모든 괄호가 균형을 이룰 때만 올바른 것으로 간주됩니다.
    예를 들어, 문자열 '(())()' 는 올바르지만, 문자열 '())'는 올바르지 않습니다.
    올바른 문자열을 만들 수 있다면 'Yes'를 반환하고, 그렇지 않다면 'No'를 반환합니다.

    예시:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    두 개의 문자열로 구성된 리스트가 주어집니다. 두 문자열은 모두 여는 괄호 '(' 또는
    닫는 괄호 ')'로만 이루어져 있습니다.
    당신의 임무는 두 문자열을 어떤 순서로든 연결했을 때, 결과 문자열이 올바른 문자열이
    될 수 있는지 확인하는 것입니다.
    문자열 S가 올바르다고 판단되는 경우는 S의 모든 괄호가 균형을 이루고 있을 때입니다.
    예를 들어, 문자열 '(())()'는 올바르지만, 문자열 '())'는 올바르지 않습니다.
    올바른 문자열을 만들 수 있다면 'Yes'를 반환하고, 그렇지 않다면 'No'를 반환합니다.

    예시:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    두 문자열의 목록이 주어지고, 두 문자열 모두 열린
    괄호 '(' 또는 닫힌 괄호 ')'로만 구성되어 있습니다.
    여러분의 작업은 두 문자열을 어떤 순서로 연결할 수 있는지, 결과 문자열이 좋은지 확인하는 것입니다.
    문자열 S는 S의 모든 괄호가 균형을 이룰 때에만 좋은 것으로 간주됩니다. 예를 들어, 문자열 '(())()'는 좋은 반면, 문자열 '())'는 좋지 않습니다.
    좋은 문자열을 만드는 방법이 있으면 '예'를 반환하고, 그렇지 않으면 '아니요'를 반환합니다.

    예시:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    정수 배열 arr와 양의 정수 k가 주어졌을 때, arr에서 가장 큰 k개의 숫자를
    정렬된 리스트로 반환합니다.

    예시 1:

        Input: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]

    예시 2:

        Input: arr = [4, -4, 4], k = 2
        Output: [4, 4]

    예시 3:

        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Output: [2]

    참고:
        1. 배열의 길이는 [1, 1000] 범위 내에 있습니다.
        2. 배열의 원소들은 [-1000, 1000] 범위 내에 있습니다.
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    정수 배열 arr과 양의 정수 k가 주어지면, arr에서 가장 큰 k개의 숫자를
    정렬된 리스트로 반환합니다.

    예시 1:

        Input: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]

    예시  2:

        Input: arr = [4, -4, 4], k = 2
        Output: [4, 4]

    예시  3:

        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Output: [2]

    Note:
        1. 배열의 길이는 [1, 1000] 범위 내에 있습니다.
        2. 배열의 요소들은 [-1000, 1000] 범위 내에 있습니다.
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    정수 배열 arr과 양의 정수 k가 주어지면, arr에서 최대 k개의 숫자가 포함된 정렬된
    길이 k의 목록을 반환합니다.

    예제 1:

        입력: arr = [-3, -4, 5], k = 3
        출력: [-4, -3, 5]

    예제 2:

        입력: arr = [4, -4, 4], k = 2
        출력: [4, 4]

    예제 3:

        입력: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        출력: [2]

    참고:
        1. 배열의 길이는 [1, 1000] 범위에 있습니다.
        2. 배열의 요소는 [-1000, 1000] 범위에 있습니다.
        3. 0 <= k <= len(arr)
    """


def solution(lst):
    """비어 있지 않은 정수 목록이 주어지면 짝수 인덱스에 있는 모든 홀수 요소의 합을 반환합니다.

    예시
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """비어 있지 않은 정수 목록이 주어지면 짝수 인덱스에 있는 모든 홀수 요소의 합을 반환합니다.

    예제
     solution([5, 8, 7, 1]) ==> 12
     solution([3, 3, 3, 3, 3]) ==> 9
     solution([30, 13, 24, 321]) ==>0
     """

def solution(lst):
    """비어있지 않은 정수 리스트가 주어졌을 때, 짝수 위치에 있는 모든 홀수 요소들의 합을 반환하세요.

    예시
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    정수 배열 arr과 정수 k가 주어졌을 때,
    arr의 처음 k개 요소 중에서 최대 두 자리 숫자인 요소들의 합을 반환합니다.

    예시:

        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 24 # 21 + 3의 합

    제약 조건:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    정수가 포함된 비어 있지 않은 배열 arr과 정수 k가 주어졌을 때,
    arr의 처음 k개의 요소 중에서 최대 두 자리 수의 요소들의 합을 반환합니다.

    예시:

        입력: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        출력: 24 # 21 + 3의 합

    제약 조건:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    양의 정수 n이 주어졌을 때, 콜라츠 수열에서 홀수들을 정렬된 리스트로 반환합니다.

    콜라츠 추측은 다음과 같이 정의된 수열에 관한 수학적 추측입니다:
    양의 정수 n에서 시작합니다. 그 다음 각 항은 이전 항으로부터 다음과 같이 얻어집니다:
    이전 항이 짝수라면, 다음 항은 이전 항의 절반입니다. 이전 항이 홀수라면, 다음 항은
    이전 항의 3배에 1을 더한 값입니다. 이 추측은 어떤 n값에서 시작하더라도 수열이 항상 1에 도달한다는 것입니다.

    Note:
        1. Collatz(1)은 [1]입니다.
        2. 반환된 리스트는 오름차순으로 정렬됩니다.

    For example:
    get_odd_collatz(5)는 [1, 5]를 반환합니다 # 5의 콜라츠 수열은 [5, 16, 8, 4, 2, 1]이므로, 홀수는 1과 5뿐입니다.
    """

def get_odd_collatz(n):
    """
    양의 정수 n이 주어지면, 콜라츠 시퀀스에 홀수가 있는 정렬된 리스트를 반환합니다.

    콜라츠 추측은 수학에서 다음과 같이 정의된 수열에 관한 추측입니다:
    임의의 양의 정수 n으로 시작합니다. 그런 다음 각 항은 이전 항에서 다음과 같이 얻습니다:
    이전 항이 짝수이면, 다음 항은 이전 항의 절반입니다.
    이전 항이 홀수이면, 다음 항은 이전 항의 3배에 1을 더한 값입니다.
    이 추측은 n의 값이 무엇이든 간에 수열이 항상 1에 도달한다는 것입니다.

    참고:
        1. 콜라츠(1)은 [1]입니다.
        2. 증가 순서대로 정렬된 리스트를 반환합니다.

    예를 들어:
    get_odd_collatz(5)는 [1, 5]를 반환합니다. # 5에 대한 콜라츠 시퀀스는 [5, 16, 8, 4, 2, 1]이므로 홀수는 1과 5뿐입니다.
    """

def get_odd_collatz(n):
    """
    양의 정수 n이 주어졌을 때, 콜라츠 수열에서 홀수들을 정렬된 리스트로 반환합니다.

    콜라츠 추측은 다음과 같이 정의된 수열에 관한 수학적 추측입니다:
    임의의 양의 정수 n으로 시작합니다. 그 다음 각 항은 이전 항으로부터
    다음과 같이 얻어집니다: 이전 항이 짝수라면, 다음 항은 이전 항의 절반입니다.
    이전 항이 홀수라면, 다음 항은 이전 항의 3배에 1을 더한 값입니다.
    이 추측은 어떤 n값으로 시작하더라도 수열이 항상 1에 도달한다는 것입니다.

    참고:
        1. Collatz(1)은 [1]입니다.
        2. 반환되는 리스트는 오름차순으로 정렬되어야 합니다.

    예시:
    get_odd_collatz(5)는 [1, 5]를 반환합니다 # 5의 콜라츠 수열은 [5, 16, 8, 4, 2, 1]이므로, 홀수는 1과 5뿐입니다.
    """


def valid_date(date):
    """주어진 날짜 문자열을 검증하고 날짜가 유효하면 True를, 그렇지 않으면 False를 반환하는 함수를 작성해야 합니다.
    다음 규칙을 모두 만족하면 날짜가 유효합니다:
    1. 날짜 문자열이 비어있지 않아야 합니다.
    2. 1,3,5,7,8,10,12월의 경우 일수가 1일 미만이거나 31일을 초과할 수 없습니다. 4,6,9,11월의 경우 일수가 1일 미만이거나 30일을 초과할 수 없습니다. 그리고 2월의 경우 일수가 1일 미만이거나 29일을 초과할 수 없습니다.
    3. 월은 1 미만이거나 12를 초과할 수 없습니다.
    4. 날짜는 mm-dd-yyyy 형식이어야 합니다.

    예시:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def valid_date(date):
    """주어진 날짜 문자열을 검증하고 날짜가 유효하면 True를, 그렇지 않으면 False를 반환하는 함수를 작성해야 합니다.
    다음 규칙을 모두 만족하면 날짜가 유효합니다:
    1. 날짜 문자열이 비어있지 않아야 합니다.
    2. 1,3,5,7,8,10,12월의 경우 일수가 1일 미만이거나 31일을 초과할 수 없습니다. 4,6,9,11월의 경우 일수가 1일 미만이거나 30일을 초과할 수 없습니다. 2월의 경우 일수가 1일 미만이거나 29일을 초과할 수 없습니다.
    3. 월은 1 미만이거나 12를 초과할 수 없습니다.
    4. 날짜는 mm-dd-yyyy 형식이어야 합니다.

    예시:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def valid_date(date):
    """주어진 날짜 문자열을 검증하고
    날짜가 유효하면 True를 반환하고 그렇지 않으면 False를 반환하는 함수를 작성해야 합니다.
    다음 규칙을 모두 충족하는 경우 날짜가 유효합니다.
    1. 날짜 문자열이 비어 있지 않습니다.
    2. 1, 3, 5, 7, 8, 10, 12월의 일수가 1보다 작거나 31일보다 크지 않습니다. 4, 6, 9, 11월의 일수가 1보다 작거나 30일보다 크지 않습니다. 2월의 일수가 1보다 작거나 29보다 크지 않습니다.
    3. 월은 1보다 작거나 12보다 크지 않아야 합니다.
    4. 날짜는 mm-dd-yyyy 형식이어야 합니다.

    예를 들어:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """


def split_words(txt):
    '''
    공백이 있는 문자열이 주어지면 공백을 기준으로 단어 리스트를 반환하고, 공백이 없는 경우 쉼표(',')를 기준으로 분할하며,
    쉼표도 없는 경우 알파벳 순서가 홀수인 소문자의 개수를 반환합니다. ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    예시
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    주어진 문자열에서 단어를 공백으로 분리하여 리스트로 반환합니다. 만약 공백이 없다면
    쉼표 ','로 분리해야 하며, 쉼표도 없다면 알파벳에서 홀수 순서에 해당하는 소문자
    개수를 반환해야 합니다. ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    예시
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    숫자 리스트가 주어졌을 때, 오름차순으로 정렬되어 있는지 여부를 반환합니다.
    리스트에 동일한 숫자가 2개 초과로 있다면 False를 반환합니다.
    음수는 없으며 정수만 있다고 가정합니다.

    예시
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    숫자 목록이 주어지면 오름차순으로 정렬되었는지 여부를 반환합니다. 목록에 같은 숫자의 중복이 2개 이상 있는 경우 False를 반환합니다. 음수는 없고 정수만 있다고 가정합니다.

    예시
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    숫자 리스트가 주어졌을 때, 오름차순으로 정렬되어 있는지 여부를 반환합니다.
    리스트에 동일한 숫자가 2개 초과로 중복되는 경우 False를 반환합니다.
    음수는 없으며 정수만 포함된다고 가정합니다.

    예시
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


def intersection(interval1, interval2):
    """두 개의 구간이 주어지며,
    각 구간은 정수 쌍입니다. 예를 들어, interval = (start, end) = (1, 2).
    주어진 구간은 닫힌 구간이며, 즉 구간 (start, end)에는
    start와 end가 모두 포함됩니다.
    각 구간에 대해 시작이 끝보다 작거나 같다고 가정합니다.
    두 구간의 교집합 길이가 소수인지 확인하는 것이 과제입니다.
    예를 들어, 구간 (1, 3), (2, 4)의 교집합은 (2, 3)이며,
    길이는 1로, 소수가 아닙니다.
    교집합의 길이가 소수라면 "YES"를 반환하고,
    그렇지 않으면 "NO"를 반환합니다.
    두 구간이 교집합을 이루지 않으면 "NO"를 반환합니다.

    [입력/출력] 예시:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """두 개의 간격이 주어집니다,
    각 구간은 정수 쌍입니다. 예를 들어, interval = (start, end) = (1, 2).
    주어진 구간은 닫힌 구간으로, 구간 (start, end)은
    start와 end를 모두 포함합니다.
    각 주어진 구간에 대해, 시작이 끝보다 작거나 같다고 가정합니다.
    두 구간의 교집합 길이가 소수인지 여부를 결정하는 것이 과제입니다.
    예를 들어, 구간 (1, 3), (2, 4)의 교집합은 (2, 3)이며
    그 길이는 1로, 소수가 아닙니다.
    교집합의 길이가 소수이면 "YES"를 반환하고,
    그렇지 않으면 "NO"를 반환합니다.
    두 구간이 교차하지 않으면 "NO"를 반환합니다.

    [입력/출력] 예시:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """두 개의 구간이 주어집니다,
    각 구간은 정수 쌍입니다. 예를 들어, interval = (start, end) = (1, 2).
    주어진 구간은 닫힌 구간이며 이는 구간 (start, end)이
    시작점과 끝점을 모두 포함한다는 의미입니다.
    각 주어진 구간에 대해, 시작점이 끝점보다 작거나 같다고 가정합니다.
    당신의 임무는 이 두 구간의 교집합의 길이가 소수인지
    판단하는 것입니다.
    예를 들어, 구간 (1, 3)과 (2, 4)의 교집합은 (2, 3)이며
    그 길이는 1로 소수가 아닙니다.
    교집합의 길이가 소수이면 "YES"를 반환하고,
    그렇지 않으면 "NO"를 반환합니다.
    두 구간이 교차하지 않으면 "NO"를 반환합니다.

    [input/output] samples:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    정수 배열 arr이 주어지며, 각 숫자의 부호를 1, -1 또는 0으로 표현하여
    모든 부호의 곱과 정수의 크기를 곱한 합을 반환해야 합니다.
    참고: 빈 arr의 경우 None을 반환합니다.

    예시:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    정수 배열 arr이 주어지면 각 숫자의 부호(1, -1 또는 0으로 표시)의 곱과
    정수의 크기의 합을 곱한 값을 반환해야 합니다.
    참고: 빈 arr의 경우 None을 반환합니다.

    예시:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    정수 배열 arr이 주어지고, 배열의 각 숫자의 모든 부호의 곱에 정수의 크기의 합을 각 숫자의 부호의 곱과 곱한 값을 반환해야 합니다. 각 숫자는 1, -1 또는 0으로 표현됩니다.
    참고: 빈 arr의 경우 None을 반환합니다.

    예시:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    N행 N열(N >= 2)의 그리드와 양의 정수 k가 주어지며,
    그리드의 각 셀에는 값이 포함되어 있습니다. [1, N * N] 범위의 모든 정수가
    그리드의 셀에 정확히 한 번씩 나타납니다.

    그리드에서 길이가 k인 최소 경로를 찾아야 합니다. 어느 셀에서든 시작할 수 있으며,
    각 단계에서 이웃한 셀로 이동할 수 있습니다. 다시 말해, 현재 셀과
    모서리를 공유하는 셀로 이동할 수 있습니다.
    길이가 k인 경로는 정확히 k개의 셀을 방문하는 것을 의미합니다
    (반드시 서로 다른 셀일 필요는 없음).
    그리드 밖으로 나갈 수 없습니다.
    경로 A(길이 k)가 경로 B(길이 k)보다 작다고 판단되는 경우는
    A와 B가 지나는 셀의 값들을 순서대로 나열한 리스트(lst_A와 lst_B라고 하자)에서,
    lst_A가 사전식으로 lst_B보다 작은 경우입니다. 즉, 어떤 정수 인덱스 i(1 <= i <= k)에 대해
    lst_A[i] < lst_B[i]이고 모든 j(1 <= j < i)에 대해
    lst_A[j] = lst_B[j]인 경우입니다.
    답은 유일함이 보장됩니다.
    최소 경로가 지나는 셀의 값들을 순서대로 담은 리스트를 반환하세요.

    예시:

        입력: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        출력: [1, 2, 1]

        입력: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        출력: [1]
    """

def minPath(grid, k):
    """
    N행과 N열(N >= 2)의 그리드와 양의 정수 k가 주어지며, 그리드의 각 셀에는 값이 포함되어 있습니다.
    [1, N * N] 범위의 모든 정수는 그리드의 셀에 정확히 한 번씩 나타납니다.

    그리드에서 길이가 k인 최소 경로를 찾아야 합니다. 임의의 셀에서 시작할 수 있으며,
    각 단계에서 이웃한 셀로 이동할 수 있습니다. 다시 말해서, 현재 셀과
    모서리를 공유하는 셀로 이동할 수 있습니다.
    길이가 k인 경로는 정확히 k개의 셀을 방문하는 것을 의미합니다
    (반드시 서로 다른 셀일 필요는 없습니다).
    그리드를 벗어날 수 없습니다.
    경로 A(길이 k)는 A와 B가 지나는 셀의 값들을 순서대로 나열한 리스트
    (lst_A와 lst_B라고 하자)를 만들었을 때, lst_A가 사전식으로 lst_B보다
    작은 경우 경로 B(길이 k)보다 작다고 간주됩니다. 즉, 정수 인덱스 i(1 <= i <= k)가
    존재하여 lst_A[i] < lst_B[i]이고 모든 j(1 <= j < i)에 대해
    lst_A[j] = lst_B[j]입니다.
    답이 유일하다는 것이 보장됩니다.
    최소 경로가 지나는 셀의 값들을 순서대로 담은 리스트를 반환하세요.

     예시:

        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Output: [1, 2, 1]

        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Output: [1]
    """

def minPath(grid, k):
    """
    N개의 행과 N개의 열(N >= 2)과 양의 정수 k가 있는 그리드가 주어지면,
    그리드의 각 셀에는 값이 포함됩니다. [1, N * N] 범위에 있는 모든 정수는
    그리드의 셀에 정확히 한 번 나타납니다.

    그리드에서 길이 k의 최소 경로를 찾아야 합니다.
    아무 셀에서나 시작할 수 있으며, 각 단계에서 이웃 셀로 이동할 수 있습니다.
    즉, 현재 셀과 모서리를 공유하는 셀로 이동할 수 있습니다.
    길이 k의 경로는 정확히 k개의 셀을 방문하는 것을 의미합니다(반드시 고유할 필요는 없음).
    그리드에서 벗어날 수 없습니다.
    경로 A(길이 k)는 경로 B(길이 k)보다 작은 것으로 간주됩니다.
    A와 B가 통과하는 셀의 값에 대한 정렬된 목록을 만든 후(이를 lst_A와 lst_B라고 합시다), lst_A가 사전적으로 lst_B보다 작습니다.
    즉, 정수가 존재합니다. 인덱스 i(1 <= i <= k)
    lst_A[i] < lst_B[i]이고 모든 j(1 <= j < i)에 대해
    lst_A[j] = lst_B[j].
    답이 고유하다는 것이 보장됩니다.
    최소 경로가 통과하는 셀의 값의 순서 있는 목록을 반환합니다.

    예시:

        입력: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        출력: [1, 2, 1]

        입력: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        출력: [1]
    """


def tri(n):
    """모든 사람들이 피보나치 수열을 알고 있으며, 지난 몇 세기 동안 수학자들에 의해 깊이 연구되었습니다.
    하지만 사람들이 모르는 것은 트리보나치 수열입니다.
    트리보나치 수열은 다음과 같은 점화식으로 정의됩니다:
    tri(1) = 3
    tri(n) = 1 + n / 2, n이 짝수인 경우
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), n이 홀수인 경우
    예를 들면:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    음이 아닌 정수 n이 주어지면, 트리보나치 수열의 처음 n + 1개 숫자의 리스트를 반환해야 합니다.
    예시:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """모든 사람들이 피보나치 수열을 알고 있으며, 지난 수세기 동안 수학자들에 의해 깊이 연구되었습니다.
    하지만 사람들이 모르는 것은 트리보나치 수열입니다.
    트리보나치 수열은 다음과 같은 점화식으로 정의됩니다:
    tri(1) = 3
    tri(n) = 1 + n / 2, n이 짝수인 경우
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), n이 홀수인 경우
    예를 들면:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    음이 아닌 정수 n이 주어졌을 때, 트리보나치 수열의 처음 n + 1개 숫자를 포함하는 리스트를 반환해야 합니다.
    Examples:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """모두가 피보나치 수열을 알고 있습니다. 지난 몇 세기 동안 수학자들이 심도 있게 연구했습니다. 그러나 사람들이 모르는 것은 트리보나치 수열입니다.
    트리보나치 수열은 다음과 같은 순환으로 정의됩니다.
    tri(1) = 3
    tri(n) = 1 + n / 2, n이 짝수인 경우.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1, n이 홀수인 경우.
    예를 들어:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    음수가 아닌 정수 n이 주어지면 트리보나치 수열의 처음 n + 1개 숫자의 목록을 반환해야 합니다.
    예시:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """양의 정수 n이 주어지면, 홀수 자릿수들의 곱을 반환합니다.
    모든 자릿수가 짝수인 경우 0을 반환합니다.
    예시:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """양의 정수 n이 주어지면 홀수 자릿수의 곱을 반환합니다.
    모든 자릿수가 짝수이면 0을 반환합니다.
    예를 들어:
    digits(1) == 1
    digits(4) == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    대괄호만 포함하는 문자열을 입력으로 받는 함수를 만드세요.
    괄호의 유효한 부분 수열에서 최소한 하나의 괄호가 중첩된 경우에만
    True를 반환해야 합니다.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    대괄호만 포함된 문자열을 입력으로 받는 함수를 만듭니다.
    함수는 대괄호의 유효한 하위 시퀀스가 있는 경우에만 True를 반환해야 하며, 하위 시퀀스에 적어도 하나의 대괄호가 중첩되어 있어야 합니다.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    대괄호만 포함된 문자열을 입력으로 받는 함수를 만드세요.
    이 함수는 괄호의 유효한 부분 수열에서 최소 하나의 괄호가 중첩되어 있는 경우에만
    True를 반환해야 합니다.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''


def sum_squares(lst):
    """숫자들의 리스트가 주어집니다.
    주어진 리스트에서 각 요소를 먼저 올림하여 정수로 만든 후,
    제곱한 숫자들의 합을 반환해야 합니다.
    예시:
    lst = [1,2,3]일 때 출력은 14이어야 합니다.
    lst = [1,4,9]일 때 출력은 98이어야 합니다.
    lst = [1,3,5,7]일 때 출력은 84이어야 합니다.
    lst = [1.4,4.2,0]일 때 출력은 29이어야 합니다.
    lst = [-2.4,1,1]일 때 출력은 6이어야 합니다.

    """

def sum_squares(lst):
    """주어진 숫자 리스트가 있습니다.
    주어진 리스트에서 제곱된 숫자의 합을 반환해야 합니다.
    먼저 리스트의 각 요소를 위쪽 정수(올림)로 반올림해야 합니다.
    예시:
    lst = [1,2,3]인 경우 출력은 14가 되어야 합니다
    lst = [1,4,9]인 경우 출력은 98이 되어야 합니다
    lst = [1,3,5,7]인 경우 출력은 84가 되어야 합니다
    lst = [1.4,4.2,0]인 경우 출력은 29가 되어야 합니다
    lst = [-2.4,1,1]인 경우 출력은 6이 되어야 합니다

    """

def sum_squares(lst):
    """숫자 목록이 주어집니다.
    주어진 목록에서 제곱한 숫자의 합을 반환해야 합니다,
    목록의 각 요소를 먼저 int(Ceiling)의 가장 높은 값으로 반올림합니다.
    예시:
    lst = [1,2,3]의 경우 출력은 14여야 합니다.
    lst = [1,4,9]의 경우 출력은 98이어야 합니다.
    lst = [1,3,5,7]의 경우 출력은 84여야 합니다.
    lst = [1.4,4.2,0]의 경우 출력은 29여야 합니다.
    lst = [-2.4,1,1]의 경우 출력은 6이어야 합니다.

    """


def check_if_last_char_is_a_letter(txt):
    '''
    주어진 문자열의 마지막 문자가 알파벳이고 단어의 일부가 아닌 경우 True를 반환하고,
    그렇지 않은 경우 False를 반환하는 함수를 만듭니다.
    참고: "단어"는 공백으로 구분된 문자 그룹입니다.

    예시:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    주어진 문자열의 마지막 문자가 알파벳 문자이고
    단어의 일부가 아닌 경우 True를 반환하는 함수를 만드세요.
    그렇지 않으면 False를 반환합니다.
    참고: "단어"는 공백으로 구분된 문자 그룹입니다.

    예시:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """이전 요소보다 크거나 같지 않은 요소의 가장 큰 인덱스를 반환하는 함수를 만듭니다.
    그러한 요소가 존재하지 않으면 -1을 반환합니다. 주어진 배열에는 중복된 값이 없습니다.

    예시:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """바로 앞에 있는 요소보다 크거나 같지 않은 요소의 가장 큰 인덱스를 반환하는 함수를 만듭니다.그러한 요소가 없으면 -1을 반환합니다. 주어진 배열에는 중복 값이 포함되지 않습니다.

    예:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """이전 요소보다 크거나 같지 않은 요소의 가장 큰 인덱스를 반환하는 함수를
    생성합니다. 만약 그러한 요소가 존재하지 않으면 -1을 반환합니다.
    주어진 배열에는 중복된 값이 포함되지 않습니다.

    예시:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    리스트에서 음수 중 가장 큰 수 'a'와 양수 중 가장 작은 수 'b'를
    튜플 (a, b)로 반환하는 함수를 만드세요.
    음수나 양수가 없으면 None으로 반환하세요.

    예시:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    음수와 양수로 구성된 리스트에서 튜플 (a, b)를 반환하는 함수를 만드세요.
    여기서 'a'는 음수 중 가장 큰 수이고, 'b'는 양수 중 가장 작은 수입니다.
    음수나 양수가 없는 경우 None을 반환합니다.

    예시:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''


def compare_one(a, b):
    """
    정수, 부동 소수점 또는 실수를 나타내는 문자열을 입력받아
    주어진 변수 타입으로 더 큰 변수를 반환하는 함수를 만듭니다.
    값이 같으면 None을 반환합니다.
    참고: 실수가 문자열로 표현된 경우 소수점이 . 또는 , 일 수 있습니다.

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    """
    정수, 실수 또는 문자열을 사용하여 실수를 나타내는 함수를 만들고
    주어진 변수 유형에서 더 큰 변수를 반환합니다.
    값이 같으면 None을 반환합니다.
    참고: 실수가 문자열로 표현된 경우 부동 소수점은 . 또는 ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """


def is_equal_to_sum_even(n):
    """주어진 숫자 n이 정확히 4개의 짝수의 합으로 표현될 수 있는지 평가합니다.
    예제
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """주어진 숫자 n이 정확히 4개의 짝수의 합으로 표현될 수 있는지 평가합니다
    예제
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """주어진 숫자 n이 정확히 4개의 양의 짝수의 합으로 표현될 수 있는지 평가합니다
    예시
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """브라질 팩토리얼은 다음과 같이 정의됩니다:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    여기서 n > 0

    예시:
    >>> special_factorial(4)
    288

    이 함수는 정수를 입력으로 받아 해당 정수의 특별 팩토리얼을 반환해야 합니다.
    """

def special_factorial(n):
    """브라질 팩토리얼은 다음과 같이 정의됩니다.
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    여기서 n > 0

    예를 들어:
    >>> special_factorial(4)
    288

    함수는 정수를 입력으로 받고 이 정수의 특수
    팩토리얼을 반환해야 합니다.
    """

def special_factorial(n):
    """
    브라질식 팩토리얼은 다음과 같이 정의됩니다:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    여기서 n > 0

    예시:
    >>> special_factorial(4)
    288

    이 함수는 정수를 입력으로 받아 해당 정수의 특별한 팩토리얼 값을 반환해야 합니다.
    """


def fix_spaces(text):
    """
    문자열 text가 주어지면, 그 안의 모든 공백을 밑줄로 바꾸고,
    문자열에 2개 이상의 연속된 공백이 있으면,
    모든 연속된 공백을 -로 바꿉니다.

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    주어진 문자열 text의 모든 공백을 밑줄로 바꾸고,
    문자열에 연속된 공백이 2개 이상 있는 경우,
    모든 연속된 공백을 -로 바꿉니다

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    주어진 문자열 텍스트에서 모든 공백을 밑줄로 바꾸고,
    문자열에 연속된 공백이 2개 이상 있는 경우
    모든 연속된 공백을 -로 바꿉니다

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """


def file_name_check(file_name):
    """문자열로 파일 이름을 받아 파일 이름이 유효하면 'Yes'를 반환하고, 그렇지 않으면 'No'를 반환하는 함수를 만듭니다.
    파일 이름이 유효하다고 간주되는 경우는 다음 모든 조건이 충족될 때뿐입니다:
    - 파일 이름에 숫자('0'-'9')가 세 개를 초과해서는 안 됩니다.
    - 파일 이름에는 정확히 하나의 점 '.'이 포함되어야 합니다.
    - 점 앞의 부분 문자열은 비어 있지 않아야 하며, 라틴 알파벳 문자('a'-'z' 및 'A'-'Z')로 시작해야 합니다.
    - 점 뒤의 부분 문자열은 다음 중 하나여야 합니다: ['txt', 'exe', 'dll']
    예시:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (이름은 라틴 알파벳 문자로 시작해야 합니다)
    """

def file_name_check(file_name):
    """문자열로 파일 이름을 받아 파일 이름이 유효하면 'Yes'를 반환하고, 그렇지 않으면 'No'를 반환하는 함수를 만듭니다.
    파일 이름이 유효하다고 간주되는 경우는 다음 모든 조건이 충족될 때뿐입니다:
    - 파일 이름에 숫자('0'-'9')가 세 개를 초과해서는 안 됩니다.
    - 파일 이름에는 정확히 하나의 점 '.'이 포함되어야 합니다.
    - 점 앞의 부분 문자열은 비어 있지 않아야 하며, 라틴 알파벳 문자('a'-'z' 및 'A'-'Z')로 시작해야 합니다.
    - 점 뒤의 부분 문자열은 다음 중 하나여야 합니다: ['txt', 'exe', 'dll']
    예시:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (이름은 라틴 알파벳 문자로 시작해야 함)
    """

def file_name_check(file_name):
    """문자열로 된 파일 이름을 받아서 파일 이름이 유효하면 'Yes'를 반환하고,
    그렇지 않으면 'No'를 반환하는 함수를 만드세요.
    파일 이름이 유효한 것으로 간주되려면 다음 조건을 모두 충족해야 합니다:
    - 파일 이름에 숫자('0'-'9')가 3개를 초과하지 않아야 합니다.
    - 파일 이름에는 정확히 하나의 점 '.'이 있어야 합니다.
    - 점 앞의 부분 문자열은 비어있지 않아야 하며, 라틴 알파벳('a'-'z'와 'A'-'Z')
    문자로 시작해야 합니다.
    - 점 뒤의 부분 문자열은 다음 중 하나여야 합니다: ['txt', 'exe', 'dll']
    Examples:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (이름은 라틴 알파벳 문자로 시작해야 함)
    """


def sum_squares(lst):
    """"
    이 함수는 정수 리스트를 받습니다. 리스트의 모든 항목에 대해, 인덱스가 3의 배수인 경우 해당 정수를 제곱하고,
    인덱스가 4의 배수이면서 3의 배수가 아닌 경우 해당 정수를 세제곱합니다. 인덱스가 3 또는 4의 배수가 아닌
    항목들은 변경하지 않습니다. 그런 다음 모든 항목의 합을 반환합니다.

    예시:
    lst = [1,2,3]인 경우 출력은 6이어야 합니다
    lst = []인 경우 출력은 0이어야 합니다
    lst = [-1,-5,2,-1,-5]인 경우 출력은 -126이어야 합니다
    """

def sum_squares(lst):
    """"
    이 함수는 정수의 리스트를 입력으로 받습니다. 리스트의 모든 항목에 대해, 함수는 인덱스가 3의 배수인 경우 정수 항목을 제곱하고,
    인덱스가 4의 배수이면서 3의 배수가 아닌 경우 정수 항목을 세제곱합니다. 인덱스가 3 또는 4의 배수가 아닌 항목은 변경하지 않습니다.
    그런 다음 함수는 모든 항목의 합계를 반환합니다.

    예시:
    lst = [1,2,3]의 경우 출력은 6이어야 합니다.
    lst = []의 경우 출력은 0이어야 합니다.
    lst = [-1,-5,2,-1,-5]의 경우 출력은 -126이어야 합니다.
    """


def words_in_sentence(sentence):
    """
    문자열로 된 문장이 주어지며,
    문장은 공백으로 구분된 단어들을 포함하고 있습니다.
    원래 문장에서 길이가 소수인 단어들만 포함하는
    새로운 문자열을 반환해야 합니다.
    새로운 문자열의 단어 순서는 원래 문장과 동일해야 합니다.

    예시 1:
        Input: sentence = "This is a test"
        Output: "is"

    예시 2:
        Input: sentence = "lets go for swimming"
        Output: "go for"

    Constraints:
        * 1 <= len(sentence) <= 100
        * sentence는 문자만 포함합니다
    """

def words_in_sentence(sentence):
    """
    문장을 나타내는 문자열이 주어지고,
    문장에는 공백으로 구분된 단어가 포함되어 있으며,
    원래 문장의 단어가 포함된 문자열을 반환해야 합니다.
    단어의 길이가 소수인,
    새 문자열의 단어 순서는 원래 문자열과 동일해야 합니다.

    예시 1:
        입력: sentence = "This is a test"
        출력: "is"

    예시 2:
        입력: sentence = "lets go for swimming"
        출력: "go for"

    제약 조건:
        * 1 <= len(sentence) <= 100
        * sentence에는 문자만 포함됩니다.
    """

def words_in_sentence(sentence):
    """
    문장을 나타내는 문자열이 주어집니다,
    문장에는 공백으로 구분된 단어가 포함되어 있으며,
    원래 문장의 단어가 포함된 문자열을 반환해야 합니다.
    단어의 길이가 소수인 단어들로,
    새 문자열의 단어 순서는 원래 문자열과 동일해야 합니다.

    예제 1:
        입력: sentence = "This is a test"
        출력: "is"

    예제 2:
        입력: sentence = "lets go for swimming"
        출력: "go for"

    제약 조건:
        * 1 <= len(sentence) <= 100
        * sentence는 문자만 포함합니다
    """


def simplify(x, n):
    """당신의 과제는 x * n 표현식을 단순화하는 함수를 구현하는 것입니다.
    이 함수는 x * n이 정수로 계산되면 True를 반환하고, 그렇지 않으면 False를
    반환합니다. x와 n은 모두 분수를 나타내는 문자열이며, 다음과 같은 형식을 가집니다:
    <분자>/<분모> 여기서 분자와 분모는 모두 양의 정수입니다.

    x와 n은 유효한 분수이며 분모가 0이 아니라고 가정할 수 있습니다.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """당신의 과제는 표현식 x * n을 단순화하는 함수를 구현하는 것입니다.
    x * n. 함수는 x * n이 정수로 계산되면 True를 반환하고 그렇지 않으면 False를 반환합니다.
    x와 n은 모두 분수의 문자열 표현이며, 다음과 같은 형식을 갖습니다.
    분자/분모 여기서 분자와 분모는 모두 양의 정수입니다.

    x와 n은 유효한 분수이고 분모가 0이 아니라고 가정할 수 있습니다.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """당신의 과제는 x * n표현식을 단순화하는 함수를 구현하는 것입니다.
    함수는 x * n이 정수로 평가되면 True를 반환하고 그렇지 않으면 False를 반환합니다.
    x와 n은 모두 분수의 문자열 표현이며, 다음과 같은 형식을 갖습니다.
    <분자>/<분모> 여기서 분자와 분모는 모두 양의 정수입니다.

    x와 n은 유효한 분수이고 분모가 0이 아니라고 가정할 수 있습니다.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """


def order_by_points(nums):
    """
    주어진 정수 리스트를 각 숫자의 자릿수 합에 따라
    오름차순으로 정렬하는 함수를 작성하세요.
    참고: 자릿수의 합이 동일한 항목이 여러 개인 경우,
    원래 리스트의 인덱스를 기준으로 정렬하세요.

    예시:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    주어진 정수 목록을 자리수 합에 따라 오름차순으로 정렬하는 함수를 작성하세요.
    참고로: 자리수 합이 비슷한 항목이 여러 개 있는 경우
    원래 목록의 인덱스를 기준으로 정렬하세요..

    예를 들어:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    주어진 정수 목록을 숫자 합에 따라 오름차순으로 정렬하는 함수를 작성하세요.
    참고로: 숫자 합이 비슷한 항목이 여러 개 있는 경우
    원래 목록의 인덱스를 기준으로 정렬하세요.

    예를 들어:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """숫자 배열을 입력으로 받아 배열에서 10보다 크고
    첫 번째와 마지막 자릿수가 모두 홀수(1, 3, 5, 7, 9)인
    요소의 개수를 반환하는 함수를 작성하세요.
    예시:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """배열의 숫자를 입력으로 받아들이고, 배열에서 10보다 크고 숫자의 첫 번째와 마지막 자릿수가
    모두 홀수(1, 3, 5, 7, 9)인 요소의 개수를 반환하는 함수를 작성하세요.
    예를 들어:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """숫자 배열을 입력으로 받아서
    배열에서 10보다 크고 숫자의 첫 번째와 마지막 숫자가 모두 홀수(1, 3, 5, 7, 9)인 요소의 개수를 반환하는 함수를 작성하세요.
    예를 들어:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    양의 정수 n이 주어집니다. 길이가 n인 정수 배열 a를 생성해야 합니다.
        각 i (1 ≤ i ≤ n)에 대해, a[i]의 값은 i * i - i + 1입니다.
        i < j < k인 세 개의 원소 (a[i], a[j], a[k])에 대해,
    a[i] + a[j] + a[k]가 3의 배수인 경우의 수를 반환하세요.

    예시:
        Input: n = 5
        Output: 1
        설명:
        a = [1, 3, 7, 13, 21]
        유효한 세 개의 원소 조합은 (1, 7, 13) 하나뿐입니다.
    """

def get_max_triples(n):
    """
    양의 정수 n이 주어집니다. 길이가 n인 정수 배열 a를 생성해야 합니다.
        각 i (1 ≤ i ≤ n)에 대해, a[i]의 값은 i * i - i + 1입니다.
        i < j < k인 세 수 (a[i], a[j], a[k])의 합이 3의 배수인 경우의 수를 반환합니다.

    예시:
        입력: n = 5
        출력: 1
        설명:
        a = [1, 3, 7, 13, 21]
        유효한 세 수의 조합은 (1, 7, 13) 하나뿐입니다.
    """

def get_max_triples(n):
    """
    양의 정수 n이 주어집니다. 길이가 n인 정수 배열 a를 생성해야 합니다.
        각 i (1 ≤ i ≤ n)에 대해, a[i]의 값은 i * i - i + 1입니다.
        i < j < k인 a의 삼중항 (a[i], a[j], a[k])의 개수를 반환합니다.
    그리고 a[i] + a[j] + a[k]는 3의 배수입니다.

    예시 :
        입력: n = 5
        출력: 1
        설명:
        a = [1, 3, 7, 13, 21]
        유효한 트리플은 (1, 7, 13)뿐입니다.
    """


def bf(planet1, planet2):
    '''
    우리 태양계에는 8개의 행성이 있습니다: 태양에서 가장 가까운 것이
    수성이고, 그 다음은 금성, 지구, 화성, 목성, 토성,
    천왕성, 해왕성입니다.
    두 행성의 이름을 문자열 planet1과 planet2로 받는 함수를 작성하세요.
    이 함수는 planet1과 planet2의 궤도 사이에 위치한 모든 행성들을
    태양과의 거리순으로 정렬하여 튜플로 반환해야 합니다.
    만약 planet1이나 planet2가 올바른 행성 이름이 아닐 경우
    빈 튜플을 반환해야 합니다.
    예시
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    우리 태양계에는 8개의 행성이 있습니다. 태양에 가장 가까운 행성은
    수성, 그 다음은 금성, 그 다음은 지구, 화성, 목성, 토성,
    천왕성, 해왕성입니다.
    두 행성 이름을 문자열 planet1과 planet2로 받는 함수를 작성하세요.
    이 함수는 궤도가 planet1의 궤도와 planet2의 궤도 사이에 있는 모든 행성을 포함하는 튜플을 반환해야 하며, 태양과의 근접성에 따라 정렬해야 합니다.
    이 함수는 planet1 또는 planet2가 올바른 행성 이름이 아닌 경우 빈 튜플을 반환해야 합니다.
    예시
    bf("목성", "해왕성") ==> ("토성", "천왕성")
    bf("지구", "수성") ==> ("금성")
    bf("수성", "천왕성") ==> ("금성", "지구", "화성", "목성", "토성")
    '''

def bf(planet1, planet2):
    '''
    우리 태양계에는 8개의 행성이 있습니다: 태양에서 가장 가까운 것이
    수성이고, 그 다음은 금성, 지구, 화성, 목성, 토성,
    천왕성, 해왕성입니다.
    두 행성의 이름을 문자열 planet1과 planet2로 받는 함수를 작성하세요.
    이 함수는 planet1의 궤도와 planet2의 궤도 사이에 위치한
    모든 행성들을 태양과의 거리순으로 정렬하여 튜플로 반환해야 합니다.
    만약 planet1이나 planet2가 올바른 행성 이름이 아닐 경우
    빈 튜플을 반환해야 합니다.
    Examples
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """매개변수로 문자열 목록을 받는 함수를 작성하고,
    그 목록에서 홀수 길이의 문자열을 삭제하고,
    정렬된 순서로 결과 목록을 반환합니다.
    목록은 항상 문자열 목록이며 숫자 배열이 아니며,
    중복이 포함될 수 있습니다.
    목록의 순서는 각 단어의 길이에 따라 오름차순이어야 하며,
    해당 규칙에 따라 정렬된 목록을 반환해야 합니다.
    두 단어의 길이가 같으면 목록을 사전순으로 정렬합니다.
    함수는 정렬된 순서로 문자열 목록을 반환해야 합니다.
    모든 단어의 길이가 같다고 가정할 수 있습니다.
    예를 들어:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """문자열 리스트를 매개변수로 받아,
    홀수 길이의 문자열을 삭제하고
    정렬된 순서로 결과 리스트를 반환하는 함수입니다.
    리스트는 항상 문자열의 리스트이며 숫자 배열이 아닙니다.
    중복된 값이 포함될 수 있습니다.
    리스트는 각 단어의 길이에 따라 오름차순으로 정렬되어야 하며,
    해당 규칙에 따라 정렬된 리스트를 반환해야 합니다.
    두 단어의 길이가 같은 경우 알파벳순으로 정렬합니다.
    함수는 정렬된 순서의 문자열 리스트를 반환해야 합니다.
    모든 단어의 길이가 동일하다고 가정할 수 있습니다.
    예시:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """매개변수로 문자열 목록을 받는 함수를 작성하고,
    그 목록에서 홀수 길이의 문자열을 삭제하고,
    정렬된 순서로 결과 목록을 반환합니다.
    목록은 항상 문자열 목록이며 숫자 배열이 아니며,
    중복이 포함될 수 있습니다.
    목록의 순서는 각 단어의 길이에 따라 오름차순이어야 하며,
    해당 규칙에 따라 정렬된 목록을 반환해야 합니다.
    두 단어의 길이가 같으면 목록을 사전순으로 정렬합니다.
    함수는 정렬된 순서로 문자열 목록을 반환해야 합니다.
    모든 단어의 길이가 같다고 가정할 수 있습니다.
    예:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """n이 소수이면 x의 값을 반환하고, 그렇지 않으면 y의 값을 반환하는
    간단한 프로그램입니다.

    예시:
    x_or_y(7, 34, 12) == 34
    x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """n이 소수인 경우 x 값을 반환하고,
    그렇지 않은 경우 y 값을 반환하는 간단한 프로그램입니다.

    Examples:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    숫자 리스트가 주어지면 리스트에서 홀수인 숫자들의 제곱의 합을 반환합니다.
    음수이거나 정수가 아닌 숫자는 무시합니다.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    입력 리스트가 비어있으면 0을 반환합니다.
    '''

def double_the_difference(lst):
    '''
    숫자 목록이 주어지면, 목록에서 홀수인 숫자의 제곱의 합을 반환합니다.
    음수이거나 정수가 아닌 숫자는 무시합니다.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    입력 목록이 비어 있으면 0을 반환합니다.
     '''


def compare(game,guess):
    """우리는 모두 어떤 오랫동안 기다려온 이벤트의 결과가 마침내 알려졌을 때의 그 느낌을 기억할 것입니다.
    그 순간에 느끼는 감정과 생각은 분명히 기록하고 비교할 가치가 있습니다.
    여러분의 과제는 한 사람이 여러 경기의 결과를 정확히 예측했는지를 판단하는 것입니다.
    각 인덱스가 경기를 나타내는 동일한 길이의 점수와 예측 배열 두 개가 주어집니다.
    각 예측이 얼마나 벗어났는지를 나타내는 동일한 길이의 배열을 반환하세요. 만약 정확히 예측했다면,
    값은 0이고, 그렇지 않다면 값은 예측과 점수의 절대 차이입니다.

    예시:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """우리 모두는 오랫동안 기다려온 어떤 일의 결과가 마침내 알려졌을 때의
    그 느낌을 기억할 것입니다. 그 순간의 감정과 생각들은 분명히 기록하고
    비교해볼 만한 가치가 있습니다.
    당신의 과제는 한 사람이 여러 경기의 결과를 정확하게 예측했는지 판단하는 것입니다.
    각 인덱스가 하나의 경기를 나타내는, 동일한 길이의 점수 배열과 예측 배열이 주어집니다.
    각 예측이 얼마나 벗어났는지를 나타내는 동일한 길이의 배열을 반환하세요. 정확하게 예측했다면
    값은 0이고, 그렇지 않다면 예측값과 실제 점수의 절대 차이값입니다.

    example:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """저는 우리 모두가 오랫동안 기다려온 이벤트의 결과가 마침내 알려졌을 때의 그 느낌을 기억한다고 생각합니다.
    그 순간의 감정과 생각은
    적어두고 비교할 가치가 분명히 있습니다.
    여러분의 과제는 한 사람이 여러 매치의 결과를 올바르게 추측했는지 여부를 판단하는 것입니다.
    동일한 길이의 두 개의 점수와 추측 배열이 주어지며, 각 인덱스는 매치를 보여줍니다.
    각 추측이 얼마나 틀렸는지 나타내는 동일한 길이의 배열을 반환합니다. 그들이 올바르게 추측했다면
    값은 0이고, 그렇지 않다면 값은 추측과 점수의 절대 차이입니다.

    예시:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """


def Strongest_Extension(class_name, extensions):
    """클래스의 이름(문자열)과 확장 목록이 주어집니다.
    확장은 클래스에 추가 클래스를 로드하는 데 사용됩니다.
    확장의 강도는 다음과 같습니다: CAP은 확장 이름의 대문자 수이고,
    SM은 확장 이름의 소문자 수일 때, 강도는 CAP - SM의 비율로 주어집니다.
    가장 강력한 확장을 찾아 다음 형식의 문자열을 반환해야 합니다:
    ClassName.StrongestExtensionName.
    강도가 같은 확장이 두 개 이상 있는 경우, 목록에서 먼저 나오는 것을 선택해야 합니다.
    예를 들어, "Slices"라는 클래스와 확장 목록 ['SErviNGSliCes', 'Cheese', 'StuFfed']이 주어지면
    'SErviNGSliCes'가 가장 강력한 확장이므로 'Slices.SErviNGSliCes'를 반환해야 합니다
    (그 강도는 -1입니다).
    예시:
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """클래스의 이름(문자열)과 확장자 목록이 주어집니다.
    확장자는 클래스에 추가 클래스를 로드하는 데 사용됩니다.
    확장자의 강도는 다음과 같습니다: CAP를 확장자 이름의 대문자 수라 하고,
    SM을 확장자 이름의 소문자 수라 할 때, 강도는 CAP - SM으로 주어집니다.
    가장 강한 확장자를 찾아 다음 형식의 문자열로 반환해야 합니다:
    ClassName.StrongestExtensionName.
    동일한 강도를 가진 확장자가 두 개 이상 있는 경우,
    목록에서 먼저 나오는 것을 선택해야 합니다.
    예를 들어, "Slices"가 클래스로 주어지고 확장자 목록이
    ['SErviNGSliCes', 'Cheese', 'StuFfed']인 경우
    'Slices.SErviNGSliCes'를 반환해야 합니다.
    'SErviNGSliCes'가 가장 강한 확장자이기 때문입니다(강도는 -1).
    예시:
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """클래스 이름(문자열)과 확장 목록이 제공됩니다.
    확장은 클래스에 추가 클래스를 로드하는 데 사용됩니다.
    확장의 강도는 다음과 같습니다: CAP은 확장 이름의 대문자 수이고,
    SM은 확장 이름의 소문자 수일 때, 강도는 CAP - SM의 비율로 주어집니다.
    가장 강력한 확장을 찾아 다음 형식의 문자열을 반환해야 합니다:
    ClassName.StrongestExtensionName.
    강도가 같은 확장이 두 개 이상 있는 경우 목록에서 먼저 나오는 확장을 선택해야 합니다.
    예를 들어 클래스로 "Slices"가 제공되고 확장 목록이 ['SErviNGSliCes', 'Cheese', 'StuFfed']인 경우
    'Slices.SErviNGSliCes'를 반환해야 합니다. 'SErviNGSliCes'는 가장 강력한 확장 기능입니다.
    (강도는 -1입니다.)
    예시:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """두 단어가 주어집니다. 두 번째 단어나 그 회전 중 하나가 첫 번째 단어의 부분 문자열인 경우 True를 반환해야 합니다.
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a, b):
    """두 단어가 주어졌습니다. 두 번째 단어 또는 그 회전 중 하나가 첫 번째 단어의 하위 문자열인 경우 True를 반환해야 합니다.
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """두 단어가 주어집니다. 두 번째 단어나 그것의 회전된 형태가 첫 번째 단어의 부분 문자열인 경우 True를 반환해야 합니다
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """정수가 주어졌을 때, 짝수와 홀수 숫자의 개수를 각각 포함하는 튜플을 반환합니다.

     예시:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """정수가 주어졌을 때, 짝수와 홀수 자릿수의 개수를 각각 포함하는 튜플을 반환합니다.

     예시:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
     """정수가 주어지면, 각각 짝수와 홀수 자릿수의 개수를 갖는 튜플을 반환합니다.

     예시:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    양의 정수가 주어지면, 로마 숫자로 된 문자열을 구하고
    소문자로 반환합니다.
    제한 사항: 1 <= num <= 1000

    예시:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    양의 정수가 주어졌을 때, 이에 해당하는 로마 숫자를 문자열로 변환하여
    소문자로 반환합니다.
    제한사항: 1 <= num <= 1000

    예시:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    양의 정수가 주어지면 로마 숫자에 해당하는 문자열을 얻어
    소문자로 반환합니다.
    제한사항: 1 <= num <= 1000

    예시:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    삼각형의 세 변의 길이가 주어졌을 때, 세 변이 직각삼각형을 이루면 True를 반환하고,
    그렇지 않으면 False를 반환합니다.
    직각삼각형은 한 각이 직각 또는 90도인 삼각형입니다.
    예시:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    삼각형의 세 변의 길이가 주어졌을 때, 직각삼각형이면 True를 반환하고
    그렇지 않으면 False를 반환합니다.
    직각삼각형은 하나의 각이 직각 또는 90도인 삼각형입니다.
    Example:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """문자열 리스트를 받아들이는 함수를 작성하세요.
    리스트는 서로 다른 단어들을 포함합니다. 고유 문자 수가 가장 많은 단어를 반환하세요.
    고유 문자 수가 최대인 문자열이 여러 개인 경우, 사전순으로 가장 먼저 오는 것을 반환하세요.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == "aaaaaaa"
    """

def find_max(words):
    """문자열 리스트를 받는 함수를 작성하세요.
    리스트는 서로 다른 단어들을 포함합니다. 고유 문자의 수가 가장 많은 단어를 반환하세요.
    고유 문자의 수가 최대인 문자열이 여러 개인 경우, 사전순으로 가장 먼저 오는 것을 반환하세요.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """

def find_max(words):
    """문자열 목록을 받는 함수를 작성하세요.
    목록에는 다양한 단어가 포함되어 있습니다. 고유한 문자의 최대 수를 가진
    단어를 반환합니다. 여러 문자열이 고유한 문자의 최대 수를 가진 경우,
    사전순으로 먼저 오는 문자열을 반환합니다.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """


def eat(number, need, remaining):
    """
    당신은 배고픈 토끼이고, 이미 일정 수의 당근을 먹었지만,
    이제 하루 식사를 마치기 위해 더 많은 당근을 먹어야 합니다.
    당신은 [ 식사 후 먹은 당근의 총 수,
              식사 후 남은 당근의 수 ]의 배열을 반환해야 합니다.
    만약 남은 당근이 충분하지 않다면, 남은 모든 당근을 먹겠지만 여전히 배고플 것입니다.

    예시:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    변수:
    @number : 정수
        당신이 먹은 당근의 수.
    @need : 정수
        당신이 먹어야 하는 당근의 수.
    @remaining : 정수
        재고에 남아 있는 당근의 수

    제약 조건:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    재미있게 보내세요 : )
    """

def eat(number, need, remaining):
    """
    당신은 배고픈 토끼이며, 이미 일정량의 당근을 먹었지만,
    하루 식사를 완료하기 위해 더 많은 당근을 먹어야 합니다.
    당신은 [ 식사 후 먹은 총 당근의 수,
            식사 후 남은 당근의 수 ]를 반환해야 합니다.
    만약 남은 당근이 충분하지 않다면, 남은 당근을 모두 먹지만 여전히 배고플 것입니다.

    예시:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    변수:
    @number : integer
        이미 먹은 당근의 수
    @need : integer
        먹어야 할 당근의 수
    @remaining : integer
        재고로 남아있는 당근의 수

    제약조건:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    즐거운 시간 되세요 :)
    """

def eat(number, need, remaining):
    """
    당신은 배고픈 토끼이고, 이미 일정 수의 당근을 먹었지만,
    이제 하루 식사를 완료하기 위해 더 많은 당근을 먹어야 합니다.
    당신은 [ 식사 후 먹은 당근의 총 수,
              식사 후 남은 당근의 수 ]의 배열을 반환해야 합니다.
    만약 남은 당근이 충분하지 않다면, 남은 모든 당근을 먹겠지만 여전히 배고플 것입니다.

    예시:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    변수:
    @number : 정수
        당신이 먹은 당근의 수.
    @need : 정수
        당신이 먹어야 하는 당근의 수.
    @remaining : 정수
        재고에 남아 있는 당근의 수

    제약 조건:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    즐기세요 :)
    """


def do_algebra(operator, operand):
    """
    연산자와 피연산자의 두 리스트가 주어집니다. 첫 번째 리스트는 기본 대수 연산자를 포함하고,
    두 번째 리스트는 정수들의 리스트입니다. 두 개의 주어진 리스트를 사용하여 대수식을 만들고
    이 식의 계산 결과를 반환합니다.

    기본 대수 연산:
    덧셈 ( + )
    뺄셈 ( - )
    곱셈 ( * )
    정수 나눗셈 ( // )
    거듭제곱 ( ** )

    예시:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    참고:
        연산자 리스트의 길이는 피연산자 리스트의 길이보다 1이 작습니다.
        피연산자는 음이 아닌 정수들의 리스트입니다.
        연산자 리스트는 최소 하나의 연산자를, 피연산자 리스트는 최소 두 개의 피연산자를 포함합니다.

    """

def do_algebra(operator, operand):
    """
    연산자 리스트와 피연산자 리스트가 주어집니다. 첫 번째 리스트는 기본 대수 연산자를 포함하고,
    두 번째 리스트는 정수들의 리스트입니다. 두 리스트를 사용하여 대수식을 만들고
    이 식의 계산 결과를 반환합니다.

    기본 대수 연산자:
    덧셈 ( + )
    뺄셈 ( - )
    곱셈 ( * )
    정수 나눗셈 ( // )
    거듭제곱 ( ** )

    Example:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Note:
        연산자 리스트의 길이는 피연산자 리스트의 길이보다 1이 작습니다.
        피연산자는 음이 아닌 정수들의 리스트입니다.
        연산자 리스트는 최소 하나의 연산자를, 피연산자 리스트는 최소 두 개의 피연산자를 가집니다.
    """

def do_algebra(operator, operand):
    """
    두 개의 리스트 연산자와 피연산자가 주어졌습니다. 첫 번째 리스트는 기본 대수 연산을 포함하고,
    두 번째 리스트는 정수 리스트입니다. 주어진 두 리스트를 사용하여 대수
    표현식을 빌드하고 이 표현식의 평가를 반환합니다.

    기본 대수 연산:
    덧셈(+)
    뺄셈(-)
    곱셈(*)
    내림차순 나눗셈(//)
    지수(**)

    예시:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    참고:
        연산자 리스트의 길이는 피연산자 리스트의 길이에서 1을 뺀 길이와 같습니다.
        피연산자는 음이 아닌 정수 리스트입니다.
        연산자 리스트에는 최소한 하나의 연산자가 있고, 피연산자 리스트에는 최소한 두 개의 피연산자가 있습니다.

    """


def solve(s):
    """문자열 s가 주어집니다.
    s[i]가 문자인 경우, 소문자는 대문자로, 대문자는 소문자로 변환하고,
    그렇지 않은 경우 그대로 유지합니다.
    문자열에 문자가 없는 경우, 문자열을 뒤집습니다.
    함수는 결과 문자열을 반환해야 합니다.
    예시
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """문자열 s가 주어집니다.
    만약 s[i]가 문자라면, 소문자를 대문자로 바꾸고 대문자를 소문자로 바꿉니다.
    그렇지 않으면 그대로 유지합니다.
    문자열에 문자가 없으면, 문자열을 뒤집습니다.
    함수는 결과 문자열을 반환해야 합니다.
    예시
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """문자열 s가 주어집니다.
    만약 s[i]가 문자라면, 소문자를 대문자로 또는 그 반대로 변환하고,
    그렇지 않으면 그대로 유지합니다.
    문자열에 문자가 포함되어 있지 않으면, 문자열을 뒤집습니다.
    함수는 결과 문자열을 반환해야 합니다.
    예시
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    주어진 문자열 'text'의 md5 해시 값을 문자열로 반환합니다.
    만약 'text'가 빈 문자열이면 None을 반환합니다.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    문자열 'text'가 주어지면, md5 해시 등가 문자열을 반환합니다.
    'text'가 빈 문자열이면 None을 반환합니다.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """


def generate_integers(a, b):
    """
    두 양의 정수 a와 b가 주어졌을 때, a와 b 사이의 짝수를 오름차순으로 반환합니다.

    예시:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """
    # 시작과 끝 값을 정렬
    start = min(a, b)
    end = max(a, b)

    # start부터 end까지의 짝수만 리스트에 추가
    result = [num for num in range(start, end + 1) if num % 2 == 0]

    return result

def generate_integers(a, b):
    """
    두 개의 양의 정수 a와 b가 주어졌을 때, a와 b 사이의 짝수 자릿수를 오름차순으로 반환하세요.

    예를 들어:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """