Antigravity advancedfunctions and techniques

# 原始code
import time

def calculate_factorial(n):
    result = 1
    for i in range(1, n+1):
        result *= i
    return result

# testperformance
start_time = time.time()
result = calculate_factorial(100000)
end_time = time.time()
print(f"计算100000 阶乘耗时: {end_time - start_time}秒")

# optimization after  code
def calculate_factorial_optimized(n):
    """
    计算阶乘 optimizationversion
    usingmathmodulein factorialfunction, performance更优
    """
    import math
    return math.factorial(n)

# testoptimization after performance
start_time = time.time()
result = calculate_factorial_optimized(100000)
end_time = time.time()
print(f"optimization after 计算100000 阶乘耗时: {end_time - start_time}秒")

// 原始code
function processUserData(user) {
    // verificationuserdata
    if (!user || !user.name || !user.email) {
        console.error('Invalid user data');
        return null;
    }
    
    // processinguser姓名
    const formattedName = user.name.trim().toLowerCase();
    
    // processinguser邮箱
    const formattedEmail = user.email.trim().toLowerCase();
    
    // check邮箱格式
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    if (!emailRegex.test(formattedEmail)) {
        console.error('Invalid email format');
        return null;
    }
    
    // 生成userID
    const userId = Math.random().toString(36).substring(2, 10);
    
    // creationprocessing after  userobject
    const processedUser = {
        id: userId,
        name: formattedName,
        email: formattedEmail,
        createdAt: new Date().toISOString()
    };
    
    return processedUser;
}

// refactor after  code
function validateUserData(user) {
    if (!user || !user.name || !user.email) {
        console.error('Invalid user data');
        return false;
    }
    return true;
}

function validateEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
}

function formatUserInput(input) {
    return input.trim().toLowerCase();
}

function generateUserId() {
    return Math.random().toString(36).substring(2, 10);
}

function processUserDataRefactored(user) {
    if (!validateUserData(user)) {
        return null;
    }
    
    const formattedName = formatUserInput(user.name);
    const formattedEmail = formatUserInput(user.email);
    
    if (!validateEmail(formattedEmail)) {
        console.error('Invalid email format');
        return null;
    }
    
    const userId = generateUserId();
    
    const processedUser = {
        id: userId,
        name: formattedName,
        email: formattedEmail,
        createdAt: new Date().toISOString()
    };
    
    return processedUser;
}

# 原始function
def calculate_discount(price, discount_rate, min_price=0):
    discounted_price = price * (1 - discount_rate)
    return max(discounted_price, min_price)

# 生成documentation after  function
def calculate_discount(price, discount_rate, min_price=0):
    """
    计算折扣 after  价格
    
    :param price: 原始价格
    :type price: float
    :param discount_rate: 折扣率 (0-1之间  small 数) 
    :type discount_rate: float
    :param min_price: 最 low 价格, 默认 for 0
    :type min_price: float
    :return: 折扣 after  价格, 不 low 于最 low 价格
    :rtype: float
    :raises ValueError: such as果价格 for 负数 or 折扣率不 in 0-1之间
    """
    if price < 0:
        raise ValueError("Price cannot be negative")
    if discount_rate < 0 or discount_rate > 1:
        raise ValueError("Discount rate must be between 0 and 1")
    if min_price < 0:
        raise ValueError("Minimum price cannot be negative")
    
    discounted_price = price * (1 - discount_rate)
    return max(discounted_price, min_price)

# 原始class
class Calculator:
    def add(self, a, b):
        return a + b
    
    def subtract(self, a, b):
        return a - b
    
    def multiply(self, a, b):
        return a * b
    
    def divide(self, a, b):
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return a / b

# 生成documentation after  class
class Calculator:
    """
     simple  计算器class, providingbasic 算术运算
    
    该classsupport加法, 减法, 乘法 and 除法运算
    """
    
    def add(self, a, b):
        """
        执行加法运算
        
        :param a: 第一个operation数
        :type a: int or float
        :param b: 第二个operation数
        :type b: int or float
        :return: 两个数  and 
        :rtype: int or float
        """
        return a + b
    
    def subtract(self, a, b):
        """
        执行减法运算
        
        :param a: 被减数
        :type a: int or float
        :param b: 减数
        :type b: int or float
        :return: 两个数 差
        :rtype: int or float
        """
        return a - b
    
    def multiply(self, a, b):
        """
        执行乘法运算
        
        :param a: 第一个operation数
        :type a: int or float
        :param b: 第二个operation数
        :type b: int or float
        :return: 两个数 积
        :rtype: int or float
        """
        return a * b
    
    def divide(self, a, b):
        """
        执行除法运算
        
        :param a: 被除数
        :type a: int or float
        :param b: 除数
        :type b: int or float
        :return: 两个数 商
        :rtype: float
        :raises ValueError: such as果除数 for 零
        """
        if b == 0:
            raise ValueError("Cannot divide by zero")
        return a / b

# 原始function
def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

# 生成 单元test
import unittest

class TestIsPrime(unittest.TestCase):
    """
    testis_primefunction 单元test
    """
    
    def test_negative_numbers(self):
        """
        test负数
        """
        self.assertFalse(is_prime(-1))
        self.assertFalse(is_prime(-10))
        self.assertFalse(is_prime(-100))
    
    def test_zero_and_one(self):
        """
        test0 and 1
        """
        self.assertFalse(is_prime(0))
        self.assertFalse(is_prime(1))
    
    def test_small_primes(self):
        """
        test small 质数
        """
        self.assertTrue(is_prime(2))
        self.assertTrue(is_prime(3))
        self.assertTrue(is_prime(5))
        self.assertTrue(is_prime(7))
        self.assertTrue(is_prime(11))
    
    def test_small_non_primes(self):
        """
        test small 非质数
        """
        self.assertFalse(is_prime(4))
        self.assertFalse(is_prime(6))
        self.assertFalse(is_prime(8))
        self.assertFalse(is_prime(9))
        self.assertFalse(is_prime(10))
    
    def test_large_primes(self):
        """
        test big 质数
        """
        self.assertTrue(is_prime(97))
        self.assertTrue(is_prime(101))
        self.assertTrue(is_prime(199))
    
    def test_large_non_primes(self):
        """
        test big 非质数
        """
        self.assertFalse(is_prime(100))
        self.assertFalse(is_prime(200))
        self.assertFalse(is_prime(300))

if __name__ == '__main__':
    unittest.main()

# 生成 集成test
import unittest
from unittest.mock import Mock, patch

class TestUserServiceIntegration(unittest.TestCase):
    """
    userservice 集成test
    """
    
    def setUp(self):
        """
        设置testenvironment
        """
        from user_service import UserService
        from user_repository import UserRepository
        
        # creationmock user仓library
        self.mock_repository = Mock(spec=UserRepository)
        self.user_service = UserService(self.mock_repository)
    
    def test_create_user_success(self):
        """
        test成功creationuser
        """
        # configurationmockobject
        test_user = {
            "id": 1,
            "name": "Test User",
            "email": "test@example.com"
        }
        self.mock_repository.create.return_value = test_user
        
        # 执行test
        result = self.user_service.create_user("Test User", "test@example.com")
        
        # verification结果
        self.assertEqual(result, test_user)
        self.mock_repository.create.assert_called_once_with("Test User", "test@example.com")
    
    def test_get_user_success(self):
        """
        test成功获取user
        """
        # configurationmockobject
        test_user = {
            "id": 1,
            "name": "Test User",
            "email": "test@example.com"
        }
        self.mock_repository.get_by_id.return_value = test_user
        
        # 执行test
        result = self.user_service.get_user(1)
        
        # verification结果
        self.assertEqual(result, test_user)
        self.mock_repository.get_by_id.assert_called_once_with(1)
    
    def test_get_user_not_found(self):
        """
        test获取不存 in  user
        """
        # configurationmockobject
        self.mock_repository.get_by_id.return_value = None
        
        # 执行test
        result = self.user_service.get_user(999)
        
        # verification结果
        self.assertIsNone(result)
        self.mock_repository.get_by_id.assert_called_once_with(999)

if __name__ == '__main__':
    unittest.main()

# Pythoncode
def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

# 转换 for JavaScript
function fibonacci(n) {
    if (n <= 1) {
        return n;
    } else {
        return fibonacci(n-1) + fibonacci(n-2);
    }
}

// JavaScriptcode
class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    
    greet() {
        return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
    }
    
    celebrateBirthday() {
        this.age += 1;
        return `Happy birthday! I am now ${this.age} years old.`;
    }
}

// 转换 for Python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."
    
    def celebrate_birthday(self):
        self.age += 1
        return f"Happy birthday! I am now {self.age} years old."

# 生成一个完整 Flask Webapplication
"""
Flask Webapplicationexample
package含以 under functions: 
1. userregister and login
2. datastore
3. APIinterface
4. basic  before 端页面
"""

from flask import Flask, render_template, request, redirect, url_for, session
from flask_sqlalchemy import SQLAlchemy
from werkzeug.security import generate_password_hash, check_password_hash
import os

# creationFlaskapplication
app = Flask(__name__)
app.config['SECRET_KEY'] = os.urandom(24)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///app.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# 初始化datalibrary
 db = SQLAlchemy(app)

# 定义usermodel
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password_hash = db.Column(db.String(128), nullable=False)
    
    def set_password(self, password):
        self.password_hash = generate_password_hash(password)
    
    def check_password(self, password):
        return check_password_hash(self.password_hash, password)

# 定义taskmodel
class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    description = db.Column(db.Text, nullable=True)
    completed = db.Column(db.Boolean, default=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)

# creationdatalibrary表
with app.app_context():
    db.create_all()

# routing: 首页
@app.route('/')
def index():
    if 'user_id' in session:
        user = User.query.get(session['user_id'])
        tasks = Task.query.filter_by(user_id=user.id).all()
        return render_template('index.html', user=user, tasks=tasks)
    return redirect(url_for('login'))

# routing: register
@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'POST':
        username = request.form['username']
        email = request.form['email']
        password = request.form['password']
        
        # checkuser名 is 否已存 in 
        if User.query.filter_by(username=username).first():
            return render_template('register.html', error='user名已存 in ')
        
        # check邮箱 is 否已存 in 
        if User.query.filter_by(email=email).first():
            return render_template('register.html', error='邮箱已被register')
        
        # creation new user
        new_user = User(username=username, email=email)
        new_user.set_password(password)
        db.session.add(new_user)
        db.session.submitting()
        
        # login new user
        session['user_id'] = new_user.id
        return redirect(url_for('index'))
    return render_template('register.html')

# routing: login
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        
        # finduser
        user = User.query.filter_by(username=username).first()
        
        # verificationuser
        if user and user.check_password(password):
            session['user_id'] = user.id
            return redirect(url_for('index'))
        
        return render_template('login.html', error='user名 or passworderror')
    return render_template('login.html')

# routing: 登出
@app.route('/logout')
def logout():
    session.pop('user_id', None)
    return redirect(url_for('login'))

# routing: 添加task
@app.route('/add_task', methods=['POST'])
def add_task():
    if 'user_id' not in session:
        return redirect(url_for('login'))
    
    title = request.form['title']
    description = request.form['description']
    
    new_task = Task(title=title, description=description, user_id=session['user_id'])
    db.session.add(new_task)
    db.session.submitting()
    
    return redirect(url_for('index'))

# routing: completiontask
@app.route('/complete_task/')
def complete_task(task_id):
    if 'user_id' not in session:
        return redirect(url_for('login'))
    
    task = Task.query.get(task_id)
    if task and task.user_id == session['user_id']:
        task.completed = not task.completed
        db.session.submitting()
    
    return redirect(url_for('index'))

# routing: deletetask
@app.route('/delete_task/')
def delete_task(task_id):
    if 'user_id' not in session:
        return redirect(url_for('login'))
    
    task = Task.query.get(task_id)
    if task and task.user_id == session['user_id']:
        db.session.delete(task)
        db.session.submitting()
    
    return redirect(url_for('index'))

# APIrouting: 获取tasklist
@app.route('/api/tasks')
def api_tasks():
    if 'user_id' not in session:
        return {'error': 'Not logged in'},
    
    user = User.query.get(session['user_id'])
    tasks = Task.query.filter_by(user_id=user.id).all()
    
    task_list = []
    for task in tasks:
        task_list.append({
            'id': task.id,
            'title': task.title,
            'description': task.description,
            'completed': task.completed
        })
    
    return {'tasks': task_list}

if __name__ == '__main__':
    app.run(debug=True)

def find_duplicates(lst):
    duplicates = []
    for i in range(len(lst)):
        for j in range(i+1, len(lst)):
            if lst[i] == lst[j] and lst[i] not in duplicates:
                duplicates.append(lst[i])
    return duplicates

class Stack:
    def __init__(self):
        self.items = []
    
    def push(self, item):
        self.items.append(item)
    
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        return None
    
    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        return None
    
    def is_empty(self):
        return len(self.items) == 0
    
    def size(self):
        return len(self.items)

def reverse_string(s):
    return s[::-1]


def is_palindrome(s):
    cleaned = ''.join(c.lower() for c in s if c.isalnum())
    return cleaned == cleaned[::-1]

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    
    return merge(left, right)


def merge(left, right):
    result = []
    i = j = 0
    
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    
    result.extend(left[i:])
    result.extend(right[j:])
    return result