Python Sandbox

import re

def validate_email(email):
    """
    Improved email validation with better edge case handling.
    """
    # Check for consecutive dots
    if '..' in email:
        return False

    # More strict regex pattern
    # Local part: starts and ends with alphanumeric, can contain ._+-% 
    # Domain: proper format with labels that start/end with alphanumeric
    pattern = (
        r'^[a-zA-Z0-9][a-zA-Z0-9._%+-]*[a-zA-Z0-9]'
        r'@[a-zA-Z0-9]+([.-][a-zA-Z0-9]+)*\.[a-zA-Z]{2,}$'
        r'|^[a-zA-Z0-9]@[a-zA-Z0-9]+([.-][a-zA-Z0-9]+)*\.[a-zA-Z]{2,}$'
    )

    return re.match(pattern, email) is not None

import re

def validate_email(email):
    """
    Improved email validation with better edge case handling.
    """
    # Check for consecutive dots
    if '..' in email:
        return False
    
    # More strict regex pattern
    pattern = r'^[a-zA-Z0-9][a-zA-Z0-9._%+-]*[a-zA-Z0-9]@[a-zA-Z0-9]+([.-][a-zA-Z0-9]+)*\.[a-zA-Z]{2,}$|^[a-zA-Z0-9]@[a-zA-Z0-9]+([.-][a-zA-Z0-9]+)*\.[a-zA-Z]{2,}$'
    
    return re.match(pattern, email) is not None

# Test cases
test_cases = [
    ("user@example.com", True),
    ("user.name@example.co.uk", True),
    ("user+tag@example.com", True),
    ("invalid.email@", False),
    ("@example.com", False),
    ("user@.com", False),
    ("user@example", False),
    ("user name@example.com", False),
    ("user@example..com", False),
]

print("Email Validation Test Results")
print("=" * 50)
passed = 0
failed = 0

for email, expected in test_cases:
    result = validate_email(email)
    status = "✓ PASS" if result == expected else "✗ FAIL"
    
    if result == expected:
        passed += 1
    else:
        failed += 1
    
    print(f"{status} | {email:30} | Expected: {expected}, Got: {result}")

print("=" * 50)
print(f"Results: {passed}/{len(test_cases)} passed, {failed} failed")

if failed > 0:
    print("\n⚠️  Some test cases failed. Review the pattern.")
else:
    print("\n✓ All test cases passed!")

Email Validation Test Results
==================================================
✓ PASS | user@example.com              | Expected: True, Got: True
✓ PASS | user.name@example.co.uk       | Expected: True, Got: True
✓ PASS | user+tag@example.com          | Expected: True, Got: True
✓ PASS | invalid.email@                | Expected: False, Got: False
✓ PASS | @example.com                  | Expected: False, Got: False
✓ PASS | user@.com                     | Expected: False, Got: False
✓ PASS | user@example                  | Expected: False, Got: False
✓ PASS | user name@example.com         | Expected: False, Got: False
✓ PASS | user@example..com             | Expected: False, Got: False
==================================================
Results: 9/9 passed, 0 failed

✓ All test cases passed!

import numpy as np

sales_data = np.array([45000, 52000, 48000, 61000, 58000, 67000, 
                      72000, 68000, 75000, 81000, 79000, 88000])

mean_sales = np.mean(sales_data)
median_sales = np.median(sales_data)
std_dev = np.std(sales_data)

# Calculate month-over-month growth
growth_rates = np.diff(sales_data) / sales_data[:-1] * 100
avg_growth = np.mean(growth_rates)

print(f"Sales Analysis Report")
print("=" * 50)
print(f"Mean Sales: ${mean_sales:,.2f}")
print(f"Median Sales: ${median_sales:,.2f}")
print(f"Standard Deviation: ${std_dev:,.2f}")
print(f"Average Monthly Growth: {avg_growth:.2f}%")
print(f"Trend: {'Positive' if avg_growth > 0 else 'Negative'}")

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    
    return -1

# Test cases
test_cases = [
    ([], 5, -1, "Empty array"),
    ([1], 1, 0, "Single element - found"),
    ([1], 2, -1, "Single element - not found"),
    ([1, 2, 3, 4, 5], 3, 2, "Standard case - middle element"),
    ([1, 2, 3, 4, 5], 1, 0, "First element"),
    ([1, 2, 3, 4, 5], 5, 4, "Last element"),
    ([1, 2, 3, 4, 5], 6, -1, "Target larger than all"),
    ([1, 1, 2, 2, 3, 3], 2, 2, "Duplicate values"),
]

print("Binary Search Test Results")
print("=" * 70)
passed = 0

for arr, target, expected, description in test_cases:
    result = binary_search(arr, target)
    status = "✓ PASS" if result == expected else "✗ FAIL"
    
    if result == expected:
        passed += 1
    
    print(f"{status} | {description:30} | Expected: {expected:3}, Got: {result:3}")

print("=" * 70)
print(f"Results: {passed}/{len(test_cases)} tests passed")

import math

# Coefficients for 2x² - 8x + 6 = 0
a, b, c = 2, -8, 6

# Calculate discriminant
discriminant = b**2 - 4*a*c
print(f"Quadratic Equation: {a}x² + ({b})x + {c} = 0")
print("=" * 50)
print(f"Discriminant (b² - 4ac): {discriminant}")

if discriminant > 0:
    x1 = (-b + math.sqrt(discriminant)) / (2*a)
    x2 = (-b - math.sqrt(discriminant)) / (2*a)
    
    print(f"\nTwo distinct real solutions:")
    print(f"x₁ = {x1}")
    print(f"x₂ = {x2}")
    
    # Verify solutions
    print(f"\nVerification:")
    print(f"For x₁={x1}: {a}({x1})² + ({b})({x1}) + {c} = {a*x1**2 + b*x1 + c:.10f}")
    print(f"For x₂={x2}: {a}({x2})² + ({b})({x2}) + {c} = {a*x2**2 + b*x2 + c:.10f}")
elif discriminant == 0:
    x = -b / (2*a)
    print(f"\nOne repeated real solution: x = {x}")
else:
    real_part = -b / (2*a)
    imaginary_part = math.sqrt(-discriminant) / (2*a)
    print(f"\nTwo complex solutions:")
    print(f"x₁ = {real_part} + {imaginary_part}i")
    print(f"x₂ = {real_part} - {imaginary_part}i")