智能code生成Basics

# 生成一个function, 用于计算两个数 最 big 公约数
def gcd(a, b):
    """
    计算两个数 最 big 公约数
    
    :param a: 第一个数
    :param b: 第二个数
    :return: 最 big 公约数
    """
    while b:
        a, b = b, a % b
    return a

# testfunction
print(gcd(48, 18))  # 输出: 6

// 生成一个function, 用于checkstring is 否 is 回文
function isPalindrome(str) {
    """
    checkstring is 否 is 回文
    
    @param {string} str - 要check string
    @returns {boolean} - such as果 is 回文返回true, 否则返回false
    """
    // 去除非字母number字符并转换 for  small 写
    const cleanStr = str.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
    // 反转string
    const reversedStr = cleanStr.split('').reverse().join('');
    // 比较原string and 反转 after  string
    return cleanStr === reversedStr;
}

// testfunction
console.log(isPalindrome("A man, a plan, a canal, Panama!")); // 输出: true
console.log(isPalindrome("Hello, World!")); // 输出: false

// 生成一个class, 用于表示二维向量并implementationbasic 向量运算
public class Vector2D {
    private double x;
    private double y;
    
    /**
     * constructfunction
     * @param x x坐标
     * @param y y坐标
     */
    public Vector2D(double x, double y) {
        this.x = x;
        this.y = y;
    }
    
    /**
     * 获取x坐标
     * @return x坐标
     */
    public double getX() {
        return x;
    }
    
    /**
     * 获取y坐标
     * @return y坐标
     */
    public double getY() {
        return y;
    }
    
    /**
     * 向量加法
     * @param other 另一个向量
     * @return 两个向量  and 
     */
    public Vector2D add(Vector2D other) {
        return new Vector2D(this.x + other.x, this.y + other.y);
    }
    
    /**
     * 向量减法
     * @param other 另一个向量
     * @return 两个向量 差
     */
    public Vector2D subtract(Vector2D other) {
        return new Vector2D(this.x - other.x, this.y - other.y);
    }
    
    /**
     * 向量乘法 (标量) 
     * @param scalar 标量值
     * @return 向量 and 标量 乘积
     */
    public Vector2D multiply(double scalar) {
        return new Vector2D(this.x * scalar, this.y * scalar);
    }
    
    /**
     * 计算向量 模 long 
     * @return 向量 模 long 
     */
    public double magnitude() {
        return Math.sqrt(x * x + y * y);
    }
    
    /**
     * 计算向量 单位向量
     * @return 单位向量
     */
    public Vector2D normalize() {
        double mag = magnitude();
        if (mag == 0) {
            return new Vector2D(0, 0);
        }
        return new Vector2D(x / mag, y / mag);
    }
    
    /**
     * 计算两个向量 点积
     * @param other 另一个向量
     * @return 两个向量 点积
     */
    public double dotProduct(Vector2D other) {
        return this.x * other.x + this.y * other.y;
    }
    
    @Override
    public String toString() {
        return "Vector2D{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

// testclass
public class VectorTest {
    public static void main(String[] args) {
        Vector2D v1 = new Vector2D(3, 4);
        Vector2D v2 = new Vector2D(1, 2);
        
        System.out.println("v1: " + v1);
        System.out.println("v2: " + v2);
        System.out.println("v1 + v2: " + v1.add(v2));
        System.out.println("v1 - v2: " + v1.subtract(v2));
        System.out.println("v1 * 2: " + v1.multiply(2));
        System.out.println("v1 magnitude: " + v1.magnitude());
        System.out.println("v1 normalized: " + v1.normalize());
        System.out.println("v1 dot v2: " + v1.dotProduct(v2));
    }
}

"""
生成一个Pythonmodule, 用于processing日期 and 时间相关 operation
"""

import datetime
from datetime import datetime, timedelta


def get_current_date():
    """
    获取当 before 日期
    
    :return: 当 before 日期string, 格式 for YYYY-MM-DD
    """
    return datetime.now().strftime("%Y-%m-%d")


def get_current_time():
    """
    获取当 before 时间
    
    :return: 当 before 时间string, 格式 for HH:MM:SS
    """
    return datetime.now().strftime("%H:%M:%S")


def get_current_datetime():
    """
    获取当 before 日期 and 时间
    
    :return: 当 before 日期 and 时间string, 格式 for YYYY-MM-DD HH:MM:SS
    """
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")


def format_date(date_obj, format_str="%Y-%m-%d"):
    """
    format日期object for string
    
    :param date_obj: 日期object
    :param format_str: formatstring, 默认 for "%Y-%m-%d"
    :return: format after  日期string
    """
    return date_obj.strftime(format_str)


def parse_date(date_str, format_str="%Y-%m-%d"):
    """
    解析日期string for 日期object
    
    :param date_str: 日期string
    :param format_str: formatstring, 默认 for "%Y-%m-%d"
    :return: 日期object
    """
    return datetime.strptime(date_str, format_str)


def add_days(date_str, days, format_str="%Y-%m-%d"):
    """
     in 指定日期 on 添加指定天数
    
    :param date_str: 日期string
    :param days: 要添加 天数
    :param format_str: formatstring, 默认 for "%Y-%m-%d"
    :return:  new  日期string
    """
    date_obj = parse_date(date_str, format_str)
    new_date = date_obj + timedelta(days=days)
    return format_date(new_date, format_str)


def get_days_between(date_str1, date_str2, format_str="%Y-%m-%d"):
    """
    计算两个日期之间 天数差
    
    :param date_str1: 第一个日期string
    :param date_str2: 第二个日期string
    :param format_str: formatstring, 默认 for "%Y-%m-%d"
    :return: 天数差 绝 for 值
    """
    date1 = parse_date(date_str1, format_str)
    date2 = parse_date(date_str2, format_str)
    return abs((date2 - date1).days)


def is_weekend(date_str, format_str="%Y-%m-%d"):
    """
    判断指定日期 is 否 is 周末
    
    :param date_str: 日期string
    :param format_str: formatstring, 默认 for "%Y-%m-%d"
    :return: such as果 is 周末返回True, 否则返回False
    """
    date_obj = parse_date(date_str, format_str)
    return date_obj.weekday() >= 5  # 5表示周六, 6表示周日


if __name__ == "__main__":
    # testfunction
    print("Current date:", get_current_date())
    print("Current time:", get_current_time())
    print("Current datetime:", get_current_datetime())
    
    test_date = "2023-12-25"
    print(f"\nTesting with date: {test_date}")
    print("Is weekend:", is_weekend(test_date))
    print("Add 7 days:", add_days(test_date, 7))
    print("Days between 2023-12-25 and 2024-01-01:", get_days_between(test_date, "2024-01-01"))

# 生成一个function, 用于 in Pythoninimplementation二分findalgorithms
# 要求: 
# 1. function接受一个 has 序list and 一个目标值serving asparameter
# 2. function返回目标值 in listin index, such as果不存 in 则返回-1
# 3. function应该using递归implementation
# 4. function应该package含详细 documentationstring
# 5. function应该processingedge界circumstances, such as空list
# 6. function应该 has 良 good  performance, 时间complexity for O(log n)
def binary_search_recursive(arr, target, low=0, high=None):
    """
    using递归implementation二分findalgorithms
    
    :param arr:  has 序list
    :param target: 要find 目标值
    :param low: 搜索范围 起始index, 默认 for 0
    :param high: 搜索范围 结束index, 默认 for None (表示list末尾) 
    :return: 目标值 in listin index, such as果不存 in 则返回-1
    """
    # processingedge界circumstances
    if not arr:
        return -1
    
    # 初始化highparameter
    if high is None:
        high = len(arr) - 1
    
    # basiccircumstances: 搜索范围 for 空
    if low > high:
        return -1
    
    # 计算in间index
    mid = (low + high) // 2
    
    # 找 to 目标值
    if arr[mid] == target:
        return mid
    # 目标值 in  left 半部分
    elif arr[mid] > target:
        return binary_search_recursive(arr, target, low, mid - 1)
    # 目标值 in  right 半部分
    else:
        return binary_search_recursive(arr, target, mid + 1, high)


# testfunction
if __name__ == "__main__":
    test_arr = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
    test_targets = [7, 8, 1, 19, 10]
    
    for target in test_targets:
        result = binary_search_recursive(test_arr, target)
        if result != -1:
            print(f"Target {target} found at index {result}")
        else:
            print(f"Target {target} not found in the array")

"""
生成一个Python客户端, 用于调用RESTful API
要求: 
1. usingrequestslibrary
2. supportGET, POST, PUT, DELETEmethod
3. supportrequest头 and queryparameter
4. supportJSONresponse解析
5. package含errorprocessing
6.  has 良 good  documentation
"""

import requests
import json


class APIClient:
    """
    RESTful API客户端
    """
    
    def __init__(self, base_url, headers=None):
        """
        初始化API客户端
        
        :param base_url: API BasicsURL
        :param headers: 默认request头
        """
        self.base_url = base_url.rstrip('/')
        self.headers = headers or {
            'Content-Type': 'application/json',
            'Accept': 'application/json'
        }
    
    def get(self, endpoint, params=None, headers=None):
        """
        发送GETrequest
        
        :param endpoint: API端点
        :param params: queryparameter
        :param headers: 额 out  request头
        :return: responsedata
        """
        url = f"{self.base_url}/{endpoint.lstrip('/')}"
        combined_headers = {**self.headers, **(headers or {})}
        
        try:
            response = requests.get(url, params=params, headers=combined_headers)
            response.raise_for_status()  # 引发HTTPerror
            return response.json()
        except requests.exceptions.HTTPError as http_err:
            print(f"HTTPerror: {http_err}")
            return {'error': str(http_err), 'status_code': response.status_code}
        except requests.exceptions.RequestException as req_err:
            print(f"requesterror: {req_err}")
            return {'error': str(req_err)}
        except json.JSONDecodeError as json_err:
            print(f"JSON解析error: {json_err}")
            return {'error': str(json_err), 'content': response.text}
    
    def post(self, endpoint, data=None, json_data=None, headers=None):
        """
        发送POSTrequest
        
        :param endpoint: API端点
        :param data: 表单data
        :param json_data: JSONdata
        :param headers: 额 out  request头
        :return: responsedata
        """
        url = f"{self.base_url}/{endpoint.lstrip('/')}"
        combined_headers = {**self.headers, **(headers or {})}
        
        try:
            if json_data is not None:
                response = requests.post(url, json=json_data, headers=combined_headers)
            else:
                response = requests.post(url, data=data, headers=combined_headers)
            
            response.raise_for_status()  # 引发HTTPerror
            return response.json()
        except requests.exceptions.HTTPError as http_err:
            print(f"HTTPerror: {http_err}")
            return {'error': str(http_err), 'status_code': response.status_code}
        except requests.exceptions.RequestException as req_err:
            print(f"requesterror: {req_err}")
            return {'error': str(req_err)}
        except json.JSONDecodeError as json_err:
            print(f"JSON解析error: {json_err}")
            return {'error': str(json_err), 'content': response.text}
    
    def put(self, endpoint, data=None, json_data=None, headers=None):
        """
        发送PUTrequest
        
        :param endpoint: API端点
        :param data: 表单data
        :param json_data: JSONdata
        :param headers: 额 out  request头
        :return: responsedata
        """
        url = f"{self.base_url}/{endpoint.lstrip('/')}"
        combined_headers = {**self.headers, **(headers or {})}
        
        try:
            if json_data is not None:
                response = requests.put(url, json=json_data, headers=combined_headers)
            else:
                response = requests.put(url, data=data, headers=combined_headers)
            
            response.raise_for_status()  # 引发HTTPerror
            return response.json()
        except requests.exceptions.HTTPError as http_err:
            print(f"HTTPerror: {http_err}")
            return {'error': str(http_err), 'status_code': response.status_code}
        except requests.exceptions.RequestException as req_err:
            print(f"requesterror: {req_err}")
            return {'error': str(req_err)}
        except json.JSONDecodeError as json_err:
            print(f"JSON解析error: {json_err}")
            return {'error': str(json_err), 'content': response.text}
    
    def delete(self, endpoint, params=None, headers=None):
        """
        发送DELETErequest
        
        :param endpoint: API端点
        :param params: queryparameter
        :param headers: 额 out  request头
        :return: responsedata
        """
        url = f"{self.base_url}/{endpoint.lstrip('/')}"
        combined_headers = {**self.headers, **(headers or {})}
        
        try:
            response = requests.delete(url, params=params, headers=combined_headers)
            response.raise_for_status()  # 引发HTTPerror
            
            # checkresponse is 否 has  in 容
            if response.content:
                return response.json()
            else:
                return {'status': 'success', 'message': 'Resource deleted successfully'}
        except requests.exceptions.HTTPError as http_err:
            print(f"HTTPerror: {http_err}")
            return {'error': str(http_err), 'status_code': response.status_code}
        except requests.exceptions.RequestException as req_err:
            print(f"requesterror: {req_err}")
            return {'error': str(req_err)}
        except json.JSONDecodeError as json_err:
            print(f"JSON解析error: {json_err}")
            return {'error': str(json_err), 'content': response.text}


# example用法
if __name__ == "__main__":
    # 初始化客户端
    client = APIClient('https://jsonplaceholder.typicode.com')
    
    # testGETrequest
    print("\nTesting GET request:")
    posts = client.get('posts', params={'userId': 1})
    print(f"Found {len(posts)} posts for user 1")
    
    # testPOSTrequest
    print("\nTesting POST request:")
    new_post = {
        'title': 'Test Post',
        'body': 'This is a test post',
        'userId': 1
    }
    created_post = client.post('posts', json_data=new_post)
    print(f"Created post with ID: {created_post.get('id')}")
    
    # testPUTrequest
    print("\nTesting PUT request:")
    updated_post = {
        'title': 'Updated Test Post',
        'body': 'This is an updated test post'
    }
    result = client.put('posts/1', json_data=updated_post)
    print(f"Updated post title: {result.get('title')}")
    
    # testDELETErequest
    print("\nTesting DELETE request:")
    result = client.delete('posts/1')
    print(f"Delete result: {result}")