sample_dict = {'a': 100, 'b': 200, 'c': 300}

in_dict(sample_dict, 100) -> True
in_dict(sample_dict, 110) -> False

def in_dict(dict_arg, value):
    return value in dict_arg.values()

sample_dict = {'a': 100, 'b': 200, 'c': 300}

print(in_dict(sample_dict, 100))  # Output: True
print(in_dict(sample_dict, 110))  # Output: False

dict_arg = {'bad': 1, 'ok': 2, 'good': 3, 'best': 4, 'geek': 5}
mean_val(dict_arg) -> 3.0

def mean_val(dict_arg):
    # Calculate the sum of all values in the dictionary
    total_sum = sum(dict_arg.values())
    
    # Calculate the number of items in the dictionary
    num_items = len(dict_arg)
    
    # Calculate and return the mean value
    mean_value = total_sum / num_items
    return mean_value

# Example usage
dict_arg = {'bad': 1, 'ok': 2, 'good': 3, 'best': 4, 'geek': 5}
print(mean_val(dict_arg))  # Output: 3.0

dict1 = {'Ten': 10, 'Twenty': 20, 'Thirty': 30}
dict2 = {'Thirty': 30, 'Fourty': 40, 'Fifty': 50}

期望的输出：
{'Ten': 10, 'Twenty': 20, 'Thirty': 30, 'Fourty': 40, 'Fifty': 50}

def merge_dict(dict1, dict2):
    merged_dict = dict1.copy()
    merged_dict.update(dict2)
    return merged_dict

# Example usage:
dict1 = {'Ten': 10, 'Twenty': 20, 'Thirty': 30}
dict2 = {'Thirty': 30, 'Fourty': 40, 'Fifty': 50}

result = merge_dict(dict1, dict2)
print(result)  # Output: {'Ten': 10, 'Twenty': 20, 'Thirty': 30, 'Fourty': 40, 'Fifty': 50}

dict_arg = {'key1': [5, 7, 9, 4, 0], 'key2': [6, 7, 4, 3, 3], 'key3': [9, 9, 9, 5, 5, 5, 5, 5]}
high_unique_key(dict_arg) -> "key1"

def high_unique_key(dict_arg):
    max_unique_elements = 0
    high_key = None

    for key, value_list in dict_arg.items():
        unique_elements = len(set(value_list))

        if unique_elements > max_unique_elements:
            max_unique_elements = unique_elements
            high_key = key

    return high_key

def high_unique_key(dict_arg):
    # 初始化 max_unique_elements 为 0，用于存储目前为止找到的最大唯一元素数量
    max_unique_elements = 0
    # 初始化 high_key 为 None，用于存储与最大唯一元素数量相关的键
    high_key = None

    # 遍历字典中的每个键值对
    for key, value_list in dict_arg.items():
        # 使用 set 函数计算 value_list 中唯一元素的数量
        unique_elements = len(set(value_list))

        # 如果当前唯一元素数量大于当前最大值
        if unique_elements > max_unique_elements:
            # 更新 max_unique_elements 和 high_key
            max_unique_elements = unique_elements
            high_key = key

    # 返回具有最大唯一元素数量的 value_list 的键
    return high_key

check_password("AbraCad") -> False
check_password("AbraCadabra*123") -> False
check_password("Abra#123") -> True
check_password("Ab*1") -> True
check_password("Abr1@1") -> False

"B".isupper() -> True
"b".islower() -> True
"2".isnumeric() -> True

def check_password(string_arg):
    if len(string_arg) < 4 or len(string_arg) > 8:
        return False
    
    has_lower = False
    has_upper = False
    has_numeric = False
    has_special = False
    
    for char in string_arg:
        if char.islower():
            has_lower = True
        elif char.isupper():
            has_upper = True
        elif char.isnumeric():
            has_numeric = True
        elif char in ['*', '#']:
            has_special = True
    
    return has_lower and has_upper and has_numeric and has_special

# Test cases
print(check_password("AbraCad"))            # -> False
print(check_password("AbraCadabra*123"))    # -> False
print(check_password("Abra#123"))           # -> True
print(check_password("Ab*1"))               # -> True
print(check_password("Abr1@1"))             # -> False

def check_password(string_arg):
    # 检查密码长度是否在4到8个字符之间（含）
    if len(string_arg) < 4 or len(string_arg) > 8:
        return False
    
    # 初始化四个布尔变量，分别用于检查各条件是否满足
    has_lower = False
    has_upper = False
    has_numeric = False
    has_special = False
    
    # 遍历字符串中的每个字符
    for char in string_arg:
        # 如果字符是小写字母
        if char.islower():
            has_lower = True
        # 如果字符是大写字母
        elif char.isupper():
            has_upper = True
        # 如果字符是数字
        elif char.isnumeric():
            has_numeric = True
        # 如果字符是特殊字符（* 或 #）
        elif char in ['*', '#']:
            has_special = True
    
    # 如果所有条件都满足，则返回 True，否则返回 False
    return has_lower and has_upper and has_numeric and has_special

# 测试用例
print(check_password("AbraCad"))            # -> False
print(check_password("AbraCadabra*123"))    # -> False
print(check_password("Abra#123"))           # -> True
print(check_password("Ab*1"))               # -> True
print(check_password("Abr1@1"))             # -> False