test

vzsd

acwa 2025-01-0311:39:47

import ast
import json
from datetime import datetime, timedelta
import re


def convert_string_to_list(input_string):
    """
    title: 字符串转列表
    description: 将%input_string%转换为列表格式，输出为%output_list%。
    inputs:
        - input_string (str): 输入字符串，eg: "[[3,5],[12,12]]"
    outputs:
        - output_list (list): 转换后的列表，eg: [[3,5],[12,12]]
    """
    # 使用ast.literal_eval安全地将字符串转换为列表
    output_list = ast.literal_eval(input_string)
    return output_list


def list_to_json(list_data):
    """
    列表转json
    """
    # 使用json.dumps()函数将列表转换为JSON格式的字符串
    return json.dumps(list_data, ensure_ascii=False)


def merge_and_deduplicate_2d(list1, list2):
    result = []  # 创建一个空列表result，用于存储最终的合并后去重的结果
    i, j = 0, 0  # 初始化两个指针i和j，分别用于遍历list1和list2

    # 同时遍历list1和list2，直到其中一个列表结束
    while i < len(list1) and j < len(list2):
        # 如果list1的当前子列表与list2的当前子列表不相等
        if list1[i] != list2[j]:
            # 如果result为空或者list1的当前子列表不等于result的最后一个元素，则将list1的当前子列表添加到result
            if not result or list1[i] != result[-1]:
                result.append(list1[i])
            i += 1  # 移动list1的指针
        # 如果list1的当前子列表等于list2的当前子列表
        else:
            # 如果result为空或者当前子列表不等于result的最后一个元素，则将当前子列表添加到result
            if not result or list1[i] != result[-1]:
                result.append(list1[i])
            i += 1  # 移动list1的指针
            j += 1  # 移动list2的指针

    # 将list1中剩余的子列表添加到result中
    while i < len(list1):
        if not result or list1[i] != result[-1]:
            result.append(list1[i])
        i += 1

    # 将list2中剩余的子列表添加到result中
    while j < len(list2):
        if not result or list2[j] != result[-1]:
            result.append(list2[j])
        j += 1

    return result  # 返回最终的合并后去重的结果列表


# 找到包含当前日期的系统消息子项后面的所有子项
def find_messages_after_current_date(chat_log):
    # 获取当前日期
    current_date = datetime.now().strftime("%Y-%m-%d")
    for item in chat_log:
        # 检查是否是系统消息并且包含当前日期
        if item[0] == 0 and current_date in item[2]:
            # 返回当前系统消息后面的所有子项
            return [chat_log[:chat_log.index(item)], chat_log[chat_log.index(item):]]  # 从当前系统消息开始截取
    return [chat_log, []]  # 如果没有找到，返回空列表


def list_to_text(input_list):
    """
    title: 列表转文本
    description: 将%input_list%中的每个子列表转换为文本格式，每行一个子列表。
    inputs:
        - input_list (list): 输入列表，eg: [[1,2,3],[12,3,3]]
    outputs:
        - output_text (str): 文本格式的列表，eg: "[1,2,3]\n[12,3,3]"
    """
    # 函数执行逻辑
    # 1. 检查输入有效性
    if not isinstance(input_list, list):
        raise ValueError("输入必须是列表")

    # 2. 转换列表为文本
    output_text = '\n'.join(str(sublist) for sublist in input_list)

    # 3. 返回输出结果
    return output_text


def filter_unique_sublists(list1, list2):
    """
    title: 保留不同子列表
    description: 从%list2%中删除与%list1%相同的子列表，只保留不同的子列表。
    inputs:
        - list1 (list): 参考列表，eg: "[[1,2],[3,2]]"
        - list2 (list): 待过滤列表，eg: "[[1,2],[3,2],[4,5],[6,5]]"
    outputs:
        - unique_sublists (list): 不同子列表，eg: "[[4,5],[6,5]]"
    """
    # 使用列表推导式过滤不同的子列表
    unique_sublists = [sublist for sublist in list2 if sublist not in list1]
    return unique_sublists


def convert_to_standard_time(time_str: str) -> str:
    """
    title: 转换为标准时间格式
    description: 将%time_str%转换为标准时间格式%standard_time%。
    inputs:
        - time_str (str): 时间字符串，eg: "2024年10月19日 9:42"
    outputs:
        - standard_time (str): 标准时间格式，eg: "2024-10-19 09:42"
    """
    if time_str is None:
        return time_str
    # 定义正则表达式模式
    date_pattern = re.compile(r'(\d{4})年(\d{1,2})月(\d{1,2})日 (\d{1,2}):(\d{2})')
    weekday_pattern = re.compile(r'(星期[一二三四五六天]) (\d{1,2}):(\d{2})')
    relative_pattern = re.compile(r'(昨天|今天) (\d{1,2}):(\d{2})')
    time_only_pattern = re.compile(r'(\d{1,2}):(\d{2})')

    now = datetime.now()

    # 匹配具体日期
    match = date_pattern.match(time_str)
    if match:
        year, month, day, hour, minute = map(int, match.groups())
        dt = datetime(year, month, day, hour, minute)
        return dt.strftime('%Y-%m-%d %H:%M')

    # 匹配星期几
    match = weekday_pattern.match(time_str)
    if match:
        weekday, hour, minute = match.groups()
        hour, minute = int(hour), int(minute)
        weekday_map = {'星期一': 0, '星期二': 1, '星期三': 2, '星期四': 3, '星期五': 4, '星期六': 5, '星期天': 6}
        target_weekday = weekday_map[weekday]
        days_difference = (now.weekday() - target_weekday + 7) % 7 or 7
        dt = now - timedelta(days=days_difference)
        dt = dt.replace(hour=hour, minute=minute, second=0, microsecond=0)
        return dt.strftime('%Y-%m-%d %H:%M')

    # 匹配相对日期
    match = relative_pattern.match(time_str)
    if match:
        relative_day, hour, minute = match.groups()
        hour, minute = int(hour), int(minute)
        dt = now - timedelta(days=1 if relative_day == '昨天' else 0)
        dt = dt.replace(hour=hour, minute=minute, second=0, microsecond=0)
        return dt.strftime('%Y-%m-%d %H:%M')

    # 匹配仅有时间
    match = time_only_pattern.match(time_str)
    if match:
        hour, minute = map(int, match.groups())
        dt = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
        return dt.strftime('%Y-%m-%d %H:%M')

    # 如果没有匹配到，返回原字符串
    return time_str


# 定义一个函数，使用反向逻辑和单字母变量名
def f(a, b):
    # 计算两个数的和，但故意使用复杂的逻辑和反向操作
    c = a + b  # 正确的计算逻辑
    d = a * b  # 额外的计算，但不影响结果
    e = c - d
    return e

print(f(1, 2))