Ace Your
Technical Interview

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

print(reverse_string("hello"))

def is_palindrome(s: str) -> bool:
    s = s.lower().replace(" ", "")
    return s == s[::-1]

print(is_palindrome("racecar"))

def factorial(n: int) -> int:
    if n < 0:
        raise ValueError("Negative input not allowed")
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))

def fibonacci(n: int) -> int:
    if n <= 0:
        return 0
    if n == 1:
        return 1
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

print(fibonacci(7))

def is_prime(n: int) -> bool:
    if n < 2:
        return False
    if n < 4:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True

print(is_prime(17))

def find_max(arr: list) -> int:
    if not arr:
        raise ValueError("Array is empty")
    maximum = arr[0]
    for num in arr[1:]:
        if num > maximum:
            maximum = num
    return maximum

print(find_max([3, 1, 4, 1, 5, 9, 2, 6]))

def remove_duplicates(arr: list) -> list:
    seen = set()
    result = []
    for item in arr:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

print(remove_duplicates([1, 2, 2, 3, 4, 4, 5]))

def two_sum(nums: list, target: int) -> list:
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

print(two_sum([2, 7, 11, 15], 9))

def merge_sorted(arr1: list, arr2: list) -> list:
    result = []
    i = j = 0
    while i < len(arr1) and j < len(arr2):
        if arr1[i] <= arr2[j]:
            result.append(arr1[i])
            i += 1
        else:
            result.append(arr2[j])
            j += 1
    result.extend(arr1[i:])
    result.extend(arr2[j:])
    return result

print(merge_sorted([1, 3, 5], [2, 4, 6]))

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

print(binary_search([1, 2, 3, 4, 5, 6, 7], 5))

def bubble_sort(arr: list) -> list:
    n = len(arr)
    for i in range(n):
        swapped = False
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:
            break
    return arr

print(bubble_sort([64, 34, 25, 12, 22, 11, 90]))

def quick_sort(arr: list) -> list:
    if len(arr) <= 1:
        return arr
    pivot = arr[-1]
    left = [x for x in arr[:-1] if x <= pivot]
    right = [x for x in arr[:-1] if x > pivot]
    return quick_sort(left) + [pivot] + quick_sort(right)

print(quick_sort([10, 7, 8, 9, 1, 5]))

def merge_sort(arr: list) -> list:
    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: list, right: list) -> list:
    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

print(merge_sort([38, 27, 43, 3, 9, 82, 10]))

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def reverse_list(head: ListNode) -> ListNode:
    prev = None
    current = head
    while current:
        next_temp = current.next
        current.next = prev
        prev = current
        current = next_temp
    return prev

def to_list(head):
    result = []
    while head:
        result.append(head.val)
        head = head.next
    return result

head = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5)))))
reversed_head = reverse_list(head)
print(to_list(reversed_head))

class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if self.is_empty():
            raise IndexError("Pop from empty stack")
        return self.items.pop()

    def peek(self):
        if self.is_empty():
            raise IndexError("Peek from empty stack")
        return self.items[-1]

    def is_empty(self):
        return len(self.items) == 0

stack = Stack()
stack.push(1)
stack.push(2)
print(stack.peek())
print(stack.pop())
print(stack.is_empty())

class Queue:
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        if self.is_empty():
            raise IndexError("Dequeue from empty queue")
        return self.items.pop(0)

    def peek(self):
        if self.is_empty():
            raise IndexError("Peek from empty queue")
        return self.items[0]

    def is_empty(self):
        return len(self.items) == 0

queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
print(queue.dequeue())
print(queue.peek())
queue.enqueue(3)
print(queue.dequeue())

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def inorder(root):
    if not root:
        return []
    return inorder(root.left) + [root.val] + inorder(root.right)

def preorder(root):
    if not root:
        return []
    return [root.val] + preorder(root.left) + preorder(root.right)

def postorder(root):
    if not root:
        return []
    return postorder(root.left) + postorder(root.right) + [root.val]

root = TreeNode(1, TreeNode(2, TreeNode(4), TreeNode(5)), TreeNode(3))
print("In-order:", inorder(root))
print("Pre-order:", preorder(root))
print("Post-order:", postorder(root))

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)
    result = []
    while queue:
        vertex = queue.popleft()
        result.append(vertex)
        for neighbor in graph[vertex]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)
    return result

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    result = [start]
    for neighbor in graph[start]:
        if neighbor not in visited:
            result.extend(dfs(graph, neighbor, visited))
    return result

graph = {0: [1, 2], 1: [2], 2: [3], 3: []}
print("BFS:", bfs(graph, 0))
print("DFS:", dfs(graph, 0))

def fib_dp(n: int) -> int:
    if n <= 0:
        return 0
    if n == 1:
        return 1
    dp = [0] * (n + 1)
    dp[1] = 1
    for i in range(2, n + 1):
        dp[i] = dp[i - 1] + dp[i - 2]
    return dp[n]

print(fib_dp(10))

def longest_substring(s: str) -> int:
    char_index = {}
    max_length = 0
    start = 0
    for end, char in enumerate(s):
        if char in char_index and char_index[char] >= start:
            start = char_index[char] + 1
        char_index[char] = end
        max_length = max(max_length, end - start + 1)
    return max_length

print(longest_substring("abcabcbb"))

def is_valid(s: str) -> bool:
    stack = []
    mapping = {")": "(", "]": "[", ": "{"}
    for char in s:
        if char in mapping:
            top = stack.pop() if stack else "#"
            if mapping[char] != top:
                return False
        else:
            stack.append(char)
    return not stack

print(is_valid("()[]{}"))

def find_missing(nums: list) -> int:
    n = len(nums)
    expected_sum = n * (n + 1) // 2
    actual_sum = sum(nums)
    return expected_sum - actual_sum

print(find_missing([3, 0, 1]))

def move_zeros(arr: list) -> list:
    write_pos = 0
    for i in range(len(arr)):
        if arr[i] != 0:
            arr[write_pos] = arr[i]
            write_pos += 1
    while write_pos < len(arr):
        arr[write_pos] = 0
        write_pos += 1
    return arr

print(move_zeros([0, 1, 0, 3, 12]))

def intersection(arr1: list, arr2: list) -> list:
    return list(set(arr1) & set(arr2))

print(intersection([1, 2, 2, 1], [2, 2]))

def find_duplicates(nums: list) -> list:
    result = []
    for num in nums:
        index = abs(num) - 1
        if nums[index] < 0:
            result.append(abs(num))
        else:
            nums[index] = -nums[index]
    return result

print(find_duplicates([4, 3, 2, 7, 8, 2, 3, 1]))

import time
from functools import wraps

def timer(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"Function executed in {end - start:.4f} seconds")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(0.1)
    return "done"

print(slow_function())

def safe_convert(strings: list) -> list:
    results = []
    for s in strings:
        try:
            results.append(int(s))
        except ValueError:
            results.append(None)
    return results

print(safe_convert(["1", "2", "abc", "4"]))

import os

def file_io_demo():
    filepath = "/tmp/test_file.txt"
    try:
        with open(filepath, "w") as f:
            f.write("Hello World")
        with open(filepath, "r") as f:
            content = f.read()
        return content
    finally:
        if os.path.exists(filepath):
            os.remove(filepath)

print(file_io_demo())

def squares_of_evens(nums: list) -> list:
    return [x ** 2 for x in nums if x % 2 == 0]

print(squares_of_evens([1, 2, 3, 4, 5, 6, 7, 8]))

def fib_generator():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

gen = fib_generator()
result = [next(gen) for _ in range(10)]
print("First 10 Fibonacci:", ", ".join(map(str, result)))

#include <stdio.h>
#include <string.h>

void reverse_string(char *str) {
    int len = strlen(str);
    for (int i = 0; i < len / 2; i++) {
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }
}

int main() {
    char str[] = "hello";
    reverse_string(str);
    printf("%s\n", str);
    return 0;
}

#include <stdio.h>
#include <string.h>

int is_palindrome(const char *str) {
    int left = 0;
    int right = strlen(str) - 1;
    while (left < right) {
        if (str[left] != str[right])
            return 0;
        left++;
        right--;
    }
    return 1;
}

int main() {
    printf("%d\n", is_palindrome("racecar"));
    return 0;
}

#include <stdio.h>

long long factorial(int n) {
    if (n < 0)
        return -1;
    if (n <= 1)
        return 1;
    return n * factorial(n - 1);
}

int main() {
    printf("%lld\n", factorial(5));
    return 0;
}

#include <stdio.h>

void fibonacci(int n) {
    int a = 0, b = 1;
    for (int i = 0; i < n; i++) {
        printf("%d ", a);
        int temp = a + b;
        a = b;
        b = temp;
    }
    printf("\n");
}

int main() {
    fibonacci(8);
    return 0;
}

#include <stdio.h>
#include <math.h>

int is_prime(int n) {
    if (n < 2) return 0;
    if (n < 4) return 1;
    if (n % 2 == 0 || n % 3 == 0) return 0;
    for (int i = 5; i <= sqrt(n); i += 6) {
        if (n % i == 0 || n % (i + 2) == 0)
            return 0;
    }
    return 1;
}

int main() {
    printf("%d\n", is_prime(17));
    return 0;
}

#include <stdio.h>

void reverse_array(int arr[], int size) {
    for (int i = 0; i < size / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[size - 1 - i];
        arr[size - 1 - i] = temp;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    reverse_array(arr, size);
    for (int i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

#include <stdio.h>
#define N 2

void multiply(int A[N][N], int B[N][N], int C[N][N]) {
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++) {
            C[i][j] = 0;
            for (int k = 0; k < N; k++)
                C[i][j] += A[i][k] * B[k][j];
        }
}

int main() {
    int A[N][N] = {{1, 2}, {3, 4}};
    int B[N][N] = {{5, 6}, {7, 8}};
    int C[N][N];
    multiply(A, B, C);
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++)
            printf("%d ", C[i][j]);
        printf("\n");
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node *next;
};

void insert(struct Node **head, int data) {
    struct Node *new_node = malloc(sizeof(struct Node));
    new_node->data = data;
    new_node->next = *head;
    *head = new_node;
}

void delete_node(struct Node **head, int key) {
    struct Node *temp = *head, *prev = NULL;
    if (temp && temp->data == key) {
        *head = temp->next;
        free(temp);
        return;
    }
    while (temp && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    if (temp) {
        prev->next = temp->next;
        free(temp);
    }
}

void display(struct Node *head) {
    while (head) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}

int main() {
    struct Node *head = NULL;
    insert(&head, 3);
    insert(&head, 2);
    insert(&head, 1);
    delete_node(&head, 2);
    display(head);
    return 0;
}

#include <stdio.h>
#define MAX 100

int stack[MAX], top = -1;

void push(int val) {
    if (top >= MAX - 1) {
        printf("Stack overflow\n");
        return;
    }
    stack[++top] = val;
}

int pop() {
    if (top < 0) {
        printf("Stack underflow\n");
        return -1;
    }
    return stack[top--];
}

int main() {
    push(10);
    push(20);
    push(30);
    printf("%d\n", pop());
    return 0;
}

#include <stdio.h>
#define MAX 5

int queue[MAX], front = -1, rear = -1;

void enqueue(int val) {
    if ((rear + 1) % MAX == front) {
        printf("Queue is full\n");
        return;
    }
    if (front == -1) front = 0;
    rear = (rear + 1) % MAX;
    queue[rear] = val;
}

int dequeue() {
    if (front == -1) {
        printf("Queue is empty\n");
        return -1;
    }
    int val = queue[front];
    if (front == rear) {
        front = -1;
        rear = -1;
    } else {
        front = (front + 1) % MAX;
    }
    return val;
}

int main() {
    enqueue(1);
    enqueue(2);
    enqueue(3);
    printf("%d ", dequeue());
    printf("%d\n", dequeue());
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int data;
    struct TreeNode *left, *right;
};

struct TreeNode* new_node(int data) {
    struct TreeNode *node = malloc(sizeof(struct TreeNode));
    node->data = data;
    node->left = node->right = NULL;
    return node;
}

void inorder(struct TreeNode *root) {
    if (!root) return;
    inorder(root->left);
    printf("%d ", root->data);
    inorder(root->right);
}

int main() {
    struct TreeNode *root = new_node(1);
    root->left = new_node(2);
    root->right = new_node(3);
    root->left->left = new_node(4);
    root->left->right = new_node(5);
    inorder(root);
    printf("\n");
    return 0;
}

#include <stdio.h>

void bubble_sort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int swapped = 0;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = 1;
            }
        }
        if (!swapped) break;
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, n);
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

#include <stdio.h>

void selection_sort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++)
            if (arr[j] < arr[min_idx])
                min_idx = j;
        if (min_idx != i) {
            int temp = arr[i];
            arr[i] = arr[min_idx];
            arr[min_idx] = temp;
        }
    }
}

int main() {
    int arr[] = {29, 10, 14, 37, 13};
    int n = sizeof(arr) / sizeof(arr[0]);
    selection_sort(arr, n);
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

#include <stdio.h>

void insertion_sort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {12, 11, 13, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    insertion_sort(arr, n);
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1, n2 = r - m;
    int *L = malloc(n1 * sizeof(int));
    int *R = malloc(n2 * sizeof(int));
    for (int i = 0; i < n1; i++) L[i] = arr[l + i];
    for (int j = 0; j < n2; j++) R[j] = arr[m + 1 + j];
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2)
        arr[k++] = (L[i] <= R[j]) ? L[i++] : R[j++];
    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = R[j++];
    free(L);
    free(R);
}

void merge_sort(int arr[], int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        merge_sort(arr, l, m);
        merge_sort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

int main() {
    int arr[] = {38, 27, 43, 3, 9, 82, 10};
    int n = sizeof(arr) / sizeof(arr[0]);
    merge_sort(arr, 0, n - 1);
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return i + 1;
}

void quick_sort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quick_sort(arr, low, pi - 1);
        quick_sort(arr, pi + 1, high);
    }
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quick_sort(arr, 0, n - 1);
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    return 0;
}

#include <stdio.h>

int binary_search(int arr[], int n, int target) {
    int left = 0, right = n - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target)
            return mid;
        else if (arr[mid] < target)
            left = mid + 1;
        else
            right = mid - 1;
    }
    return -1;
}

int main() {
    int arr[] = {2, 3, 4, 10, 40};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", binary_search(arr, n, 10));
    return 0;
}

#include <stdio.h>

int count_char(const char *str, char c) {
    int count = 0;
    while (*str) {
        if (*str == c) count++;
        str++;
    }
    return count;
}

void substring(const char *src, char *dst, int start, int len) {
    int i;
    for (i = 0; i < len && src[start + i]; i++)
        dst[i] = src[start + i];
    dst[i] = '\0';
}

int main() {
    printf("%d\n", count_char("hello world", 'l'));
    char sub[20];
    substring("hello world", sub, 6, 5);
    printf("%s\n", sub);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n = 5;
    int *arr = malloc(n * sizeof(int));
    if (!arr) {
        perror("malloc failed");
        return 1;
    }
    for (int i = 0; i < n; i++)
        arr[i] = i * 10;
    n = 10;
    int *temp = realloc(arr, n * sizeof(int));
    if (!temp) {
        free(arr);
        perror("realloc failed");
        return 1;
    }
    arr = temp;
    for (int i = 5; i < n; i++)
        arr[i] = i * 10;
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);
    printf("\n");
    free(arr);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main() {
    FILE *fp = fopen("/tmp/test.txt", "w");
    if (!fp) {
        perror("Failed to open file");
        return 1;
    }
    fprintf(fp, "Hello\nWorld\n");
    fclose(fp);

    fp = fopen("/tmp/test.txt", "r");
    if (!fp) {
        perror("Failed to open file");
        return 1;
    }
    char buffer[256];
    while (fgets(buffer, sizeof(buffer), fp))
        printf("%s", buffer);
    fclose(fp);
    return 0;
}

#include <iostream>
#include <string>
#include <algorithm>

std::string reverse_string(std::string s) {
    std::reverse(s.begin(), s.end());
    return s;
}

int main() {
    std::cout << reverse_string("hello") << std::endl;
    return 0;
}

#include <iostream>
#include <string>

bool is_palindrome(const std::string &s) {
    int left = 0, right = s.size() - 1;
    while (left < right)
        if (s[left++] != s[right--])
            return false;
    return true;
}

int main() {
    std::cout << std::boolalpha << is_palindrome("racecar") << std::endl;
    return 0;
}

#include <iostream>

long long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

int main() {
    std::cout << factorial(10) << std::endl;
    return 0;
}

#include <iostream>
#include <vector>

long long fib(int n, std::vector<long long> &memo) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];
    memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
    return memo[n];
}

int main() {
    int n = 10;
    std::vector<long long> memo(n + 1, -1);
    std::cout << fib(n, memo) << std::endl;
    return 0;
}

#include <iostream>
#include <cmath>

bool is_prime(int n) {
    if (n < 2) return false;
    if (n < 4) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    for (int i = 5; i <= std::sqrt(n); i += 6)
        if (n % i == 0 || n % (i + 2) == 0)
            return false;
    return true;
}

int main() {
    std::cout << std::boolalpha << is_prime(29) << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> v = {5, 3, 1, 4, 2};
    std::sort(v.begin(), v.end());
    auto it = std::find(v.begin(), v.end(), 3);
    if (it != v.end())
        v.erase(it);
    for (int x : v)
        std::cout << x << " ";
    std::cout << std::endl;
    return 0;
}

#include <iostream>

struct Node {
    int data;
    Node *next;
    Node(int val) : data(val), next(nullptr) {}
};

Node* reverse(Node *head) {
    Node *prev = nullptr, *curr = head;
    while (curr) {
        Node *next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

void print(Node *head) {
    while (head) {
        std::cout << head->data << " ";
        head = head->next;
    }
    std::cout << std::endl;
}

int main() {
    Node *head = new Node(1);
    head->next = new Node(2);
    head->next->next = new Node(3);
    head->next->next->next = new Node(4);
    head->next->next->next->next = new Node(5);
    head = reverse(head);
    print(head);
    return 0;
}

#include <iostream>
#include <stack>

class MinStack {
    std::stack<int> main_stack;
    std::stack<int> min_stack;
public:
    void push(int val) {
        main_stack.push(val);
        if (min_stack.empty() || val <= min_stack.top())
            min_stack.push(val);
    }
    void pop() {
        if (main_stack.top() == min_stack.top())
            min_stack.pop();
        main_stack.pop();
    }
    int top() { return main_stack.top(); }
    int getMin() { return min_stack.top(); }
};

int main() {
    MinStack ms;
    ms.push(3); ms.push(1); ms.push(5);
    std::cout << ms.getMin() << std::endl;
    ms.pop();
    std::cout << ms.getMin() << std::endl;
    return 0;
}

#include <iostream>
#include <stack>

class Queue {
    std::stack<int> s1, s2;
    void transfer() {
        while (!s1.empty()) {
            s2.push(s1.top());
            s1.pop();
        }
    }
public:
    void enqueue(int val) { s1.push(val); }
    int dequeue() {
        if (s2.empty()) transfer();
        int val = s2.top();
        s2.pop();
        return val;
    }
};

int main() {
    Queue q;
    q.enqueue(1); q.enqueue(2);
    std::cout << q.dequeue() << std::endl;
    q.enqueue(3);
    std::cout << q.dequeue() << std::endl;
    return 0;
}

#include <iostream>

struct TreeNode {
    int val;
    TreeNode *left, *right;
    TreeNode(int v) : val(v), left(nullptr), right(nullptr) {}
};

TreeNode* insert(TreeNode *root, int val) {
    if (!root) return new TreeNode(val);
    if (val < root->val) root->left = insert(root->left, val);
    else root->right = insert(root->right, val);
    return root;
}

bool search(TreeNode *root, int val) {
    if (!root) return false;
    if (root->val == val) return true;
    return val < root->val ? search(root->left, val) : search(root->right, val);
}

void inorder(TreeNode *root) {
    if (!root) return;
    inorder(root->left);
    std::cout << root->val << " ";
    inorder(root->right);
}

int main() {
    TreeNode *root = nullptr;
    for (int v : {5, 3, 7, 1, 4, 6, 8})
        root = insert(root, v);
    inorder(root);
    std::cout << std::endl;
    std::cout << std::boolalpha << search(root, 4) << std::endl;
    return 0;
}

#include <iostream>
#include <algorithm>

struct Node {
    int key, height;
    Node *left, *right;
    Node(int k) : key(k), height(1), left(nullptr), right(nullptr) {}
};

int height(Node *n) { return n ? n->height : 0; }
int balance(Node *n) { return n ? height(n->left) - height(n->right) : 0; }

Node* right_rotate(Node *y) {
    Node *x = y->left;
    y->left = x->right;
    x->right = y;
    y->height = std::max(height(y->left), height(y->right)) + 1;
    x->height = std::max(height(x->left), height(x->right)) + 1;
    return x;
}

Node* left_rotate(Node *x) {
    Node *y = x->right;
    x->right = y->left;
    y->left = x;
    x->height = std::max(height(x->left), height(x->right)) + 1;
    y->height = std::max(height(y->left), height(y->right)) + 1;
    return y;
}

Node* insert(Node *root, int key) {
    if (!root) return new Node(key);
    if (key < root->key) root->left = insert(root->left, key);
    else if (key > root->key) root->right = insert(root->right, key);
    else return root;
    root->height = 1 + std::max(height(root->left), height(root->right));
    int bal = balance(root);
    if (bal > 1 && key < root->left->key) return right_rotate(root);
    if (bal < -1 && key > root->right->key) return left_rotate(root);
    if (bal > 1 && key > root->left->key) {
        root->left = left_rotate(root->left);
        return right_rotate(root);
    }
    if (bal < -1 && key < root->right->key) {
        root->right = right_rotate(root->right);
        return left_rotate(root);
    }
    return root;
}

void inorder(Node *root) {
    if (!root) return;
    inorder(root->left);
    std::cout << root->key << " ";
    inorder(root->right);
}

int main() {
    Node *root = nullptr;
    for (int k : {10, 20, 30, 40, 50, 25})
        root = insert(root, k);
    inorder(root);
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <queue>

void bfs(const std::vector<std::vector<int>> &adj, int start) {
    std::vector<bool> visited(adj.size(), false);
    std::queue<int> q;
    visited[start] = true;
    q.push(start);
    while (!q.empty()) {
        int v = q.front(); q.pop();
        std::cout << v << " ";
        for (int u : adj[v]) {
            if (!visited[u]) {
                visited[u] = true;
                q.push(u);
            }
        }
    }
    std::cout << std::endl;
}

int main() {
    std::vector<std::vector<int>> adj(5);
    adj[0] = {1, 2}; adj[1] = {2}; adj[2] = {3}; adj[3] = {4};
    bfs(adj, 0);
    return 0;
}

#include <iostream>
#include <vector>
#include <stack>

void dfs(const std::vector<std::vector<int>> &adj, int start) {
    std::vector<bool> visited(adj.size(), false);
    std::stack<int> s;
    s.push(start);
    while (!s.empty()) {
        int v = s.top(); s.pop();
        if (visited[v]) continue;
        visited[v] = true;
        std::cout << v << " ";
        for (int i = adj[v].size() - 1; i >= 0; i--)
            if (!visited[adj[v][i]])
                s.push(adj[v][i]);
    }
    std::cout << std::endl;
}

int main() {
    std::vector<std::vector<int>> adj(4);
    adj[0] = {1, 2}; adj[1] = {2}; adj[2] = {0, 3}; adj[3] = {};
    dfs(adj, 0);
    return 0;
}

#include <iostream>
#include <vector>
#include <queue>
#include <climits>

void dijkstra(const std::vector<std::vector<std::pair<int,int>>> &adj, int src, int V) {
    std::vector<int> dist(V, INT_MAX);
    dist[src] = 0;
    std::priority_queue<std::pair<int,int>, std::vector<std::pair<int,int>>, std::greater<>> pq;
    pq.push({0, src});
    while (!pq.empty()) {
        auto [d, u] = pq.top(); pq.pop();
        if (d > dist[u]) continue;
        for (auto [v, w] : adj[u]) {
            if (dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
    for (int i = 0; i < V; i++)
        std::cout << i << ":" << dist[i] << " ";
    std::cout << std::endl;
}

int main() {
    int V = 4;
    std::vector<std::vector<std::pair<int,int>>> adj(V);
    adj[0].push_back({1, 1});
    adj[0].push_back({2, 4});
    adj[1].push_back({2, 2});
    adj[1].push_back({3, 6});
    adj[2].push_back({3, 3});
    dijkstra(adj, 0, V);
    return 0;
}

#include <iostream>
#include <vector>
#include <climits>

void floyd_warshall(std::vector<std::vector<int>> &dist, int V) {
    for (int k = 0; k < V; k++)
        for (int i = 0; i < V; i++)
            for (int j = 0; j < V; j++)
                if (dist[i][k] != INT_MAX && dist[k][j] != INT_MAX)
                    dist[i][j] = std::min(dist[i][j], dist[i][k] + dist[k][j]);
}

int main() {
    const int INF = INT_MAX;
    int V = 4;
    std::vector<std::vector<int>> dist = {
        {0, 3, INF, 7}, {8, 0, 2, INF}, {5, INF, 0, 1}, {2, INF, INF, 0}
    };
    floyd_warshall(dist, V);
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            if (dist[i][j] == INF) std::cout << "INF ";
            else std::cout << dist[i][j] << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

#include <iostream>
#include <vector>

void bubble_sort(std::vector<int> &arr) {
    int n = arr.size();
    for (int i = 0; i < n - 1; i++) {
        bool swapped = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j+1]) {
                std::swap(arr[j], arr[j+1]);
                swapped = true;
            }
        }
        if (!swapped) break;
    }
}

int main() {
    std::vector<int> arr = {5, 1, 4, 2, 8};
    bubble_sort(arr);
    for (int x : arr) std::cout << x << " ";
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <vector>

int partition(std::vector<int> &arr, int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    for (int j = low; j < high; j++) {
        if (arr[j] <= pivot) {
            i++;
            std::swap(arr[i], arr[j]);
        }
    }
    std::swap(arr[i + 1], arr[high]);
    return i + 1;
}

void quick_sort(std::vector<int> &arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quick_sort(arr, low, pi - 1);
        quick_sort(arr, pi + 1, high);
    }
}

int main() {
    std::vector<int> arr = {3, 6, 8, 10, 1, 2, 1};
    quick_sort(arr, 0, arr.size() - 1);
    for (int x : arr) std::cout << x << " ";
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <vector>

void merge(std::vector<int> &arr, int l, int m, int r) {
    std::vector<int> left(arr.begin() + l, arr.begin() + m + 1);
    std::vector<int> right(arr.begin() + m + 1, arr.begin() + r + 1);
    int i = 0, j = 0, k = l;
    while (i < (int)left.size() && j < (int)right.size())
        arr[k++] = (left[i] <= right[j]) ? left[i++] : right[j++];
    while (i < (int)left.size()) arr[k++] = left[i++];
    while (j < (int)right.size()) arr[k++] = right[j++];
}

void merge_sort(std::vector<int> &arr, int l, int r) {
    if (l < r) {
        int m = l + (r - l) / 2;
        merge_sort(arr, l, m);
        merge_sort(arr, m + 1, r);
        merge(arr, l, m, r);
    }
}

int main() {
    std::vector<int> arr = {12, 11, 13, 5, 6, 7};
    merge_sort(arr, 0, arr.size() - 1);
    for (int x : arr) std::cout << x << " ";
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <vector>

int lower_bound(const std::vector<int> &arr, int target) {
    int lo = 0, hi = arr.size();
    while (lo < hi) {
        int mid = lo + (hi - lo) / 2;
        if (arr[mid] < target) lo = mid + 1;
        else hi = mid;
    }
    return lo;
}

int upper_bound(const std::vector<int> &arr, int target) {
    int lo = 0, hi = arr.size();
    while (lo < hi) {
        int mid = lo + (hi - lo) / 2;
        if (arr[mid] <= target) lo = mid + 1;
        else hi = mid;
    }
    return lo;
}

int main() {
    std::vector<int> arr = {1, 2, 2, 2, 3, 4};
    std::cout << "lower_bound: " << lower_bound(arr, 2) << std::endl;
    std::cout << "upper_bound: " << upper_bound(arr, 2) << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int main() {
    std::vector<int> v = {5, 3, 1, 4, 2};
    std::sort(v.begin(), v.end());
    auto it = std::find(v.begin(), v.end(), 3);
    std::cout << "Found 3 at index: " << (it - v.begin()) << std::endl;
    auto cnt = std::count_if(v.begin(), v.end(), [](int x){ return x > 2; });
    std::cout << "Count > 2: " << cnt << std::endl;
    int sum = std::accumulate(v.begin(), v.end(), 0);
    std::cout << "Sum: " << sum << std::endl;
    std::vector<int> doubled(v.size());
    std::transform(v.begin(), v.end(), doubled.begin(), [](int x){ return x * 2; });
    for (int x : doubled) std::cout << x << " ";
    std::cout << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <string>

template <typename T>
int binary_search_generic(const std::vector<T> &arr, const T &target) {
    int lo = 0, hi = arr.size() - 1;
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;
        if (arr[mid] == target) return mid;
        else if (arr[mid] < target) lo = mid + 1;
        else hi = mid - 1;
    }
    return -1;
}

template <typename T1, typename T2>
class Pair {
    T1 first;
    T2 second;
public:
    Pair(T1 f, T2 s) : first(f), second(s) {}
    void print() const { std::cout << first << "=" << second << std::endl; }
};

int main() {
    std::vector<int> v = {1, 3, 5, 7, 9};
    std::cout << binary_search_generic(v, 5) << std::endl;
    Pair<std::string, int> p("age", 25);
    p.print();
    return 0;
}

#include <iostream>
#include <memory>
#include <string>

struct Resource {
    std::string name;
    Resource(std::string n) : name(n) { std::cout << "Created: " << name << std::endl; }
    ~Resource() { std::cout << "Destroyed: " << name << std::endl; }
};

int main() {
    {
        auto up = std::make_unique<Resource>("Unique");
        auto sp1 = std::make_shared<Resource>("Shared");
        std::cout << "sp1 use_count: " << sp1.use_count() << std::endl;
        {
            auto sp2 = sp1;
            std::cout << "sp1 use_count: " << sp1.use_count() << std::endl;
        }
        std::cout << "After scope: " << sp1.use_count() << std::endl;
    }
    std::cout << "All resources cleaned up" << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int main() {
    std::vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};
    std::sort(v.begin(), v.end());
    for (int x : v) std::cout << x << " ";
    std::cout << std::endl;
    int even_count = std::count_if(v.begin(), v.end(), [](int x){ return x % 2 == 0; });
    std::cout << "Even count: " << even_count << std::endl;
    std::vector<int> filtered;
    std::copy_if(v.begin(), v.end(), std::back_inserter(filtered), [](int x){ return x > 3; });
    for (int x : filtered) std::cout << x << " ";
    std::cout << std::endl;
    auto add = [](int a, int b) -> int { return a + b; };
    std::cout << "Add: " << add(3, 4) << std::endl;
    return 0;
}

#include <iostream>
#include <fstream>
#include <string>

int main() {
    {
        std::ofstream ofs("/tmp/cpp_test.txt");
        ofs << "Line 1" << std::endl;
        ofs << "Line 2" << std::endl;
        ofs << "Line 3" << std::endl;
    }
    std::ifstream ifs("/tmp/cpp_test.txt");
    std::string line;
    while (std::getline(ifs, line))
        std::cout << line << std::endl;
    ifs.close();
    std::remove("/tmp/cpp_test.txt");
    return 0;
}

#include <iostream>
#include <stdexcept>
#include <string>

class DivisionByZero : public std::runtime_error {
public:
    DivisionByZero() : std::runtime_error("Division by zero") {}
};

class InvalidOperation : public std::logic_error {
public:
    explicit InvalidOperation(const std::string &msg) : std::logic_error(msg) {}
};

double divide(int a, int b) {
    if (b == 0) throw DivisionByZero();
    return static_cast<double>(a) / b;
}

int main() {
    try {
        std::cout << divide(10, 0) << std::endl;
    } catch (const DivisionByZero &e) {
        std::cout << e.what() << std::endl;
    }
    try {
        throw InvalidOperation("Negative index");
    } catch (const std::exception &e) {
        std::cout << e.what() << std::endl;
    }
    return 0;
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Semantic Page</title>
</head>
<body>
    <header>
        <h1>My Website</h1>
        <nav>
            <ul>
                <li><a href="#home">Home</a></li>
                <li><a href="#about">About</a></li>
            </ul>
        </nav>
    </header>
    <main>
        <article>
            <h2>Article Title</h2>
            <p>Article content goes here.</p>
        </article>
        <aside>
            <h3>Related Links</h3>
            <p>Sidebar content</p>
        </aside>
    </main>
    <footer>
        <p>&copy; 2026 My Website</p>
    </footer>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Registration Form</title></head>
<body>
    <h1>Register</h1>
    <form action="/register" method="POST" novalidate>
        <fieldset>
            <legend>Account Details</legend>
            <div>
                <label for="name">Full Name:</label>
                <input type="text" id="name" name="name" required minlength="2" maxlength="50">
            </div>
            <div>
                <label for="email">Email:</label>
                <input type="email" id="email" name="email" required>
            </div>
            <div>
                <label for="password">Password:</label>
                <input type="password" id="password" name="password" required minlength="8">
            </div>
            <div>
                <label for="confirm">Confirm Password:</label>
                <input type="password" id="confirm" name="confirm" required>
            </div>
            <div>
                <input type="checkbox" id="terms" name="terms" required>
                <label for="terms">I agree to the terms</label>
            </div>
            <button type="submit">Register</button>
        </fieldset>
    </form>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Data Table</title></head>
<body>
    <table>
        <caption>Employee Information</caption>
        <thead>
            <tr>
                <th scope="col">Name</th>
                <th scope="col">Department</th>
                <th scope="col">Salary</th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <th scope="row">Alice</th>
                <td>Engineering</td>
                <td>$95,000</td>
            </tr>
            <tr>
                <th scope="row">Bob</th>
                <td>Marketing</td>
                <td>$72,000</td>
            </tr>
        </tbody>
        <tfoot>
            <tr>
                <td colspan="2">Average</td>
                <td>$83,500</td>
            </tr>
        </tfoot>
    </table>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Lists</title></head>
<body>
    <h2>Recipe: Pancakes</h2>
    <h3>Ingredients</h3>
    <ul>
        <li>Dry Ingredients
            <ol>
                <li>1 cup flour</li>
                <li>2 tbsp sugar</li>
                <li>1 tsp baking powder</li>
            </ol>
        </li>
        <li>Wet Ingredients
            <ul>
                <li>1 egg</li>
                <li>3/4 cup milk</li>
                <li>2 tbsp melted butter</li>
            </ul>
        </li>
    </ul>
    <h3>Steps</h3>
    <ol>
        <li>Mix dry ingredients</li>
        <li>Add wet ingredients and stir</li>
        <li>Pour batter on hot griddle</li>
        <li>Flip when bubbles form</li>
    </ol>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Links and Images</title></head>
<body>
    <nav>
        <a href="/" aria-label="Home">Home</a>
        <a href="/about" title="About Us">About</a>
        <a href="https://example.com" target="_blank" rel="noopener noreferrer">External</a>
        <a href="/docs#section-2">Section 2</a>
        <a href="mailto:test@example.com">Email Us</a>
    </nav>
    <figure>
        <picture>
            <source srcset="large.webp" type="image/webp" media="(min-width: 800px)">
            <source srcset="small.webp" type="image/webp">
            <img src="fallback.jpg" alt="Description of image" loading="lazy" width="800" height="600">
        </picture>
        <figcaption>Figure caption text</figcaption>
    </figure>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Document Structure</title></head>
<body>
    <h1>Main Title</h1>
    <p>Intro with <strong>bold</strong> and <em>italic</em> text.</p>
    <h2>First Section</h2>
    <p>Content with <mark>highlighted</mark> text.</p>
    <h3>Subsection</h3>
    <p>Content with <code>inline code</code> example.</p>
    <h2>Second Section</h2>
    <p>Content with <abbr title="Hypertext Markup Language">HTML</abbr> abbreviation.</p>
    <blockquote cite="https://example.com">
        <p>A quoted passage from an external source.</p>
    </blockquote>
    <pre><code>function hello() {
    console.log("Hello World");
}</code></pre>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Blog Post</title></head>
<body>
    <header>
        <h1>My Blog</h1>
        <nav aria-label="Main">
            <a href="/posts">Posts</a>
            <a href="/about">About</a>
        </nav>
    </header>
    <main>
        <article>
            <header>
                <h2>Post Title</h2>
                <time datetime="2026-01-15">January 15, 2026</time>
            </header>
            <section>
                <h3>Introduction</h3>
                <p>Post body content here...</p>
            </section>
            <footer>
                <p>Tags: <a href="/tag/html">HTML</a>, <a href="/tag/web">Web</a></p>
            </footer>
        </article>
    </main>
    <aside aria-label="Related">
        <h3>Related Posts</h3>
        <ul>
            <li><a href="/post/2">Another Post</a></li>
        </ul>
    </aside>
    <footer>
        <p>&copy; 2026 My Blog</p>
    </footer>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Dialog Example</title></head>
<body>
    <button id="open-btn">Open Dialog</button>
    <dialog id="my-dialog">
        <h2>Confirm Action</h2>
        <p>Are you sure you want to proceed?</p>
        <form method="dialog">
            <button value="cancel">Cancel</button>
            <button value="confirm">Confirm</button>
        </form>
    </dialog>
    <p id="result"></p>
    <script>
        const dialog = document.getElementById('my-dialog');
        const result = document.getElementById('result');
        document.getElementById('open-btn').addEventListener('click', () => {
            dialog.showModal();
        });
        dialog.addEventListener('close', () => {
            result.textContent = 'Result: ' + dialog.returnValue;
        });
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>FAQ</title></head>
<body>
    <h1>Frequently Asked Questions</h1>
    <details>
        <summary>What is HTML?</summary>
        <p>HTML stands for HyperText Markup Language.</p>
    </details>
    <details open>
        <summary>What is HTML5?</summary>
        <p>HTML5 is the latest version with new semantic elements.</p>
    </details>
    <details>
        <summary>Do I need JavaScript for accordions?</summary>
        <p>No, details and summary provide native accordion functionality.</p>
    </details>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Web Storage</title></head>
<body>
    <h1>Notes App</h1>
    <textarea id="note" placeholder="Type your note..."></textarea><br>
    <button onclick="saveNote()">Save</button>
    <button onclick="loadNote()">Load</button>
    <button onclick="deleteNote()">Delete</button>
    <button onclick="showAll()">Show All Keys</button>
    <p id="status"></p>
    <pre id="output"></pre>
    <script>
        function saveNote() {
            const note = document.getElementById('note').value;
            localStorage.setItem('myNote', note);
            localStorage.setItem('noteTimestamp', new Date().toISOString());
            document.getElementById('status').textContent = 'Saved!';
        }
        function loadNote() {
            const note = localStorage.getItem('myNote');
            const timestamp = localStorage.getItem('noteTimestamp');
            document.getElementById('note').value = note || '';
            document.getElementById('status').textContent = timestamp ? 'Last saved: ' + timestamp : 'No note found';
        }
        function deleteNote() {
            localStorage.removeItem('myNote');
            localStorage.removeItem('noteTimestamp');
            document.getElementById('note').value = '';
            document.getElementById('status').textContent = 'Deleted!';
        }
        function showAll() {
            let items = [];
            for (let i = 0; i < localStorage.length; i++) {
                const key = localStorage.key(i);
                items.push(key + ': ' + localStorage.getItem(key));
            }
            document.getElementById('output').textContent = items.join('\n');
        }
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Media Elements</title></head>
<body>
    <h2>Video</h2>
    <video width="640" height="360" controls preload="metadata" poster="poster.jpg">
        <source src="video.mp4" type="video/mp4">
        <source src="video.webm" type="video/webm">
        <track src="subtitles.vtt" kind="subtitles" srclang="en" label="English" default>
        <p>Your browser does not support HTML video. <a href="video.mp4">Download the video</a>.</p>
    </video>
    <h2>Audio</h2>
    <audio controls preload="none">
        <source src="audio.mp3" type="audio/mpeg">
        <source src="audio.ogg" type="audio/ogg">
        <p>Your browser does not support HTML audio. <a href="audio.mp3">Download the audio</a>.</p>
    </audio>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Canvas Drawing</title></head>
<body>
    <canvas id="myCanvas" width="500" height="300" aria-label="Canvas drawing demo"></canvas>
    <script>
        const canvas = document.getElementById('myCanvas');
        const ctx = canvas.getContext('2d');
        ctx.fillStyle = '#f0f0f0';
        ctx.fillRect(0, 0, 500, 300);
        ctx.fillStyle = '#3498db';
        ctx.fillRect(20, 20, 150, 100);
        ctx.strokeStyle = '#e74c3c';
        ctx.lineWidth = 3;
        ctx.strokeRect(200, 20, 150, 100);
        ctx.beginPath();
        ctx.arc(430, 70, 50, 0, Math.PI * 2);
        ctx.fillStyle = '#2ecc71';
        ctx.fill();
        ctx.beginPath();
        ctx.moveTo(20, 180);
        ctx.lineTo(480, 180);
        ctx.strokeStyle = '#9b59b6';
        ctx.stroke();
        ctx.fillStyle = '#2c3e50';
        ctx.font = 'bold 24px Arial';
        ctx.fillText('Hello Canvas!', 150, 240);
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Data Attributes</title></head>
<body>
    <div class="user-card" data-user-id="42" data-role="admin" data-joined="2024-01-15">
        <h3>Alice Smith</h3>
    </div>
    <div class="user-card" data-user-id="73" data-role="editor" data-joined="2025-06-20">
        <h3>Bob Jones</h3>
    </div>
    <div id="output"></div>
    <script>
        const cards = document.querySelectorAll('.user-card');
        const output = document.getElementById('output');
        cards.forEach(card => {
            const userId = card.dataset.userId;
            const role = card.dataset.role;
            const joined = card.dataset.joined;
            output.innerHTML += `User ${userId}: Role=${role}, Joined=${joined}<br>`;
        });
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <title>Block vs Inline</title>
    <style>
        .block { display: block; background: #e74c3c; padding: 10px; margin: 5px; }
        .inline { display: inline; background: #3498db; padding: 10px; margin: 5px; }
        .inline-block { display: inline-block; background: #2ecc71; padding: 10px; margin: 5px; width: 150px; }
    </style>
</head>
<body>
    <h2>Block Elements</h2>
    <div class="block">Block 1</div>
    <div class="block">Block 2</div>
    <h2>Inline Elements</h2>
    <span class="inline">Inline 1</span>
    <span class="inline">Inline 2</span>
    <span class="inline">Inline 3</span>
    <h2>Inline-Block Elements</h2>
    <div class="inline-block">IB 1</div>
    <div class="inline-block">IB 2</div>
    <div class="inline-block">IB 3</div>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Accessible Tabs</title></head>
<body>
    <div role="tablist" aria-label="Sample Tabs">
        <button role="tab" id="tab1" aria-selected="true" aria-controls="panel1" tabindex="0">Tab 1</button>
        <button role="tab" id="tab2" aria-selected="false" aria-controls="panel2" tabindex="-1">Tab 2</button>
        <button role="tab" id="tab3" aria-selected="false" aria-controls="panel3" tabindex="-1">Tab 3</button>
    </div>
    <div role="tabpanel" id="panel1" aria-labelledby="tab1">
        <p>Content for Tab 1</p>
    </div>
    <div role="tabpanel" id="panel2" aria-labelledby="tab2" hidden>
        <p>Content for Tab 2</p>
    </div>
    <div role="tabpanel" id="panel3" aria-labelledby="tab3" hidden>
        <p>Content for Tab 3</p>
    </div>
    <script>
        const tabs = document.querySelectorAll('[role="tab"]');
        tabs.forEach(tab => {
            tab.addEventListener('click', () => {
                tabs.forEach(t => {
                    t.setAttribute('aria-selected', 'false');
                    t.setAttribute('tabindex', '-1');
                    document.getElementById(t.getAttribute('aria-controls')).hidden = true;
                });
                tab.setAttribute('aria-selected', 'true');
                tab.setAttribute('tabindex', '0');
                document.getElementById(tab.getAttribute('aria-controls')).hidden = false;
                tab.focus();
            });
        });
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Template Element</title></head>
<body>
    <template id="user-template">
        <article class="user-card">
            <h3 class="user-name"></h3>
            <p class="user-email"></p>
            <span class="user-role"></span>
        </article>
    </template>
    <div id="users-container"></div>
    <script>
        const users = [
            { name: 'Alice', email: 'alice@example.com', role: 'Admin' },
            { name: 'Bob', email: 'bob@example.com', role: 'Editor' },
            { name: 'Carol', email: 'carol@example.com', role: 'Viewer' }
        ];
        const template = document.getElementById('user-template');
        const container = document.getElementById('users-container');
        users.forEach(user => {
            const clone = template.content.cloneNode(true);
            clone.querySelector('.user-name').textContent = user.name;
            clone.querySelector('.user-email').textContent = user.email;
            clone.querySelector('.user-role').textContent = user.role;
            container.appendChild(clone);
        });
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="description" content="A comprehensive guide to HTML meta tags for SEO and social sharing.">
    <meta name="keywords" content="HTML, meta tags, SEO, web development">
    <meta name="author" content="Jane Doe">
    <meta name="robots" content="index, follow">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="theme-color" content="#4285f4">
    <meta property="og:title" content="HTML Meta Tags Guide">
    <meta property="og:description" content="A comprehensive guide to HTML meta tags.">
    <meta property="og:image" content="https://example.com/image.jpg">
    <meta property="og:url" content="https://example.com/page">
    <meta property="og:type" content="article">
    <meta name="twitter:card" content="summary_large_image">
    <meta name="twitter:title" content="HTML Meta Tags Guide">
    <link rel="canonical" href="https://example.com/page">
    <title>Meta Tags Guide</title>
</head>
<body>
    <h1>Meta Tags Guide</h1>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <title>Form Validation</title>
    <style>
        input:invalid { border-color: red; }
        input:valid { border-color: green; }
        .error { color: red; font-size: 0.85em; }
    </style>
</head>
<body>
    <form id="contact-form" novalidate>
        <div>
            <label for="name">Name (min 2 chars):</label>
            <input type="text" id="name" required minlength="2" maxlength="50">
            <span class="error"></span>
        </div>
        <div>
            <label for="email">Email:</label>
            <input type="email" id="email" required>
            <span class="error"></span>
        </div>
        <div>
            <label for="phone">Phone (10 digits):</label>
            <input type="tel" id="phone" pattern="\\d{10}" required>
            <span class="error"></span>
        </div>
        <div>
            <label for="website">Website (optional):</label>
            <input type="url" id="website" placeholder="https://example.com">
            <span class="error"></span>
        </div>
        <button type="submit">Submit</button>
    </form>
    <script>
        const form = document.getElementById('contact-form');
        form.addEventListener('submit', (e) => {
            e.preventDefault();
            let valid = true;
            form.querySelectorAll('input[required]').forEach(input => {
                const error = input.nextElementSibling;
                if (!input.validity.valid) {
                    error.textContent = input.validationMessage;
                    valid = false;
                } else {
                    error.textContent = '';
                }
            });
            if (valid) alert('Form is valid!');
        });
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <title>Skip Link Example</title>
    <style>
        .skip-link {
            position: absolute;
            top: -40px;
            left: 0;
            background: #000;
            color: white;
            padding: 8px;
            z-index: 100;
            transition: top 0.3s;
        }
        .skip-link:focus {
            top: 0;
        }
    </style>
</head>
<body>
    <a href="#main-content" class="skip-link">Skip to main content</a>
    <header>
        <nav aria-label="Main">
            <ul>
                <li><a href="/">Home</a></li>
                <li><a href="/about">About</a></li>
                <li><a href="/contact">Contact</a></li>
            </ul>
        </nav>
    </header>
    <main id="main-content" tabindex="-1">
        <h1>Page Content</h1>
        <p>Main content starts here.</p>
    </main>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head><title>Progress and Meter</title></head>
<body>
    <h2>File Upload Progress</h2>
    <progress id="upload-progress" value="0" max="100">0%</progress>
    <span id="progress-text">0%</span>

    <h2>Exam Scores</h2>
    <label>Alice: </label>
    <meter value="0.92" min="0" max="1" low="0.5" high="0.8" optimum="1">92%</meter>
    <br>
    <label>Bob: </label>
    <meter value="0.65" min="0" max="1" low="0.5" high="0.8" optimum="1">65%</meter>
    <br>
    <label>Carol: </label>
    <meter value="0.35" min="0" max="1" low="0.5" high="0.8" optimum="1">35%</meter>

    <h2>Task Completion</h2>
    <progress id="task-progress" value="3" max="10">3/10</progress>
    <span id="task-text">3 of 10 tasks</span>

    <script>
        let progress = 0;
        const interval = setInterval(() => {
            progress += Math.random() * 15;
            if (progress >= 100) {
                progress = 100;
                clearInterval(interval);
            }
            document.getElementById('upload-progress').value = progress;
            document.getElementById('progress-text').textContent = Math.round(progress) + '%';
        }, 500);
    </script>
</body>
</html>

/* Navigation */
nav {
    display: flex;
    justify-content: space-between;
    align-items: center;
    padding: 1rem 2rem;
    background: #333;
    color: white;
}

nav ul {
    display: flex;
    list-style: none;
    gap: 1.5rem;
    margin: 0;
    padding: 0;
}

/* Card Grid */
.card-container {
    display: flex;
    flex-wrap: wrap;
    gap: 1rem;
    padding: 2rem;
}

.card {
    flex: 1 1 300px;
    padding: 1.5rem;
    border: 1px solid #ddd;
    border-radius: 8px;
    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}

/* Centering */
.center-content {
    display: flex;
    justify-content: center;
    align-items: center;
    min-height: 100vh;
}

/* Holy Grail Layout */
.holy-grail {
    display: flex;
    min-height: 100vh;
    flex-direction: column;
}
.holy-grail body {
    display: flex;
    flex: 1;
}
.holy-grail aside {
    flex: 0 0 200px;
    padding: 1rem;
}
.holy-grail main {
    flex: 1;
    padding: 1rem;
}

.grid-layout {
    display: grid;
    grid-template-areas:
        "header header header"
        "nav main aside"
        "footer footer footer";
    grid-template-columns: 200px 1fr 200px;
    grid-template-rows: auto 1fr auto;
    min-height: 100vh;
    gap: 1rem;
}

.header { grid-area: header; }
.nav { grid-area: nav; }
.main { grid-area: main; }
.aside { grid-area: aside; }
.footer { grid-area: footer; }

/* Responsive */
@media (max-width: 768px) {
    .grid-layout {
        grid-template-areas:
            "header"
            "nav"
            "main"
            "aside"
            "footer";
        grid-template-columns: 1fr;
    }
}

/* Grid with named lines */
.photo-grid {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
    gap: 1rem;
    padding: 1rem;
}

/* Subgrid */
.card-grid {
    display: grid;
    grid-template-columns: repeat(3, 1fr);
    gap: 1rem;
}
.card {
    display: grid;
    grid-template-rows: subgrid;
    grid-row: span 3;
}

/* Reset box model */
*, *::before, *::after {
    box-sizing: border-box;
}

/* Box model demo */
.box {
    width: 200px;
    padding: 20px;
    border: 2px solid #333;
    margin: 15px;
    background-color: #f0f0f0;
    /* Total width: 200px (border-box) */
}

/* Margin collapsing fix */
.parent {
    background: #eee;
    /* No padding/margin to demonstrate collapsing */
}
.parent .child {
    margin-top: 20px;
    margin-bottom: 30px;
    /* Collapsed: only 30px margin between siblings */
}

/* Prevent margin collapse with BFC */
.parent-fixed {
    overflow: hidden; /* Creates BFC */
    /* Or use padding: 1px; */
}

/* Centering with box model */
.centered {
    width: 80%;
    max-width: 600px;
    margin: 0 auto;
    padding: 2rem;
}

/* Negative margins */
.overlap {
    margin-top: -20px;
    /* Pulls element up to overlap */
}

/* Relative - relative to original position */
.relative {
    position: relative;
    top: 10px;
    left: 20px;
    /* Space reserved at original position */
}

/* Absolute - relative to nearest positioned ancestor */
.parent-positioned {
    position: relative; /* Creates positioning context */
}

.absolute {
    position: absolute;
    top: 0;
    right: 0;
    /* Removed from normal flow */
}

/* Fixed - relative to viewport */
.fixed-header {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    z-index: 1000;
    background: white;
    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}

/* Sticky - toggles between relative and fixed */
.sticky-nav {
    position: sticky;
    top: 0;
    background: white;
    z-index: 100;
}

/* Stacking context */
.overlay {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background: rgba(0,0,0,0.5);
    z-index: 999;
    display: flex;
    justify-content: center;
    align-items: center;
}

/* Mobile-first base styles */
.container {
    width: 100%;
    padding: 1rem;
    margin: 0 auto;
}

/* Fluid typography */
:root {
    --fluid-min: 1rem;
    --fluid-max: 2rem;
    --fluid-preferred: calc(var(--fluid-min) + (var(--fluid-max) - var(--fluid-min)) * ((100vw - 320px) / (1200 - 320)));
}

h1 {
    font-size: clamp(1.5rem, 4vw, 3rem);
}

p {
    font-size: clamp(1rem, 2.5vw, 1.25rem);
    line-height: 1.6;
}

/* Tablet breakpoint */
@media (min-width: 768px) {
    .container {
        max-width: 720px;
    }
    .grid-2 {
        display: grid;
        grid-template-columns: 1fr 1fr;
        gap: 2rem;
    }
}

/* Desktop breakpoint */
@media (min-width: 1024px) {
    .container {
        max-width: 960px;
    }
    .grid-3 {
        display: grid;
        grid-template-columns: repeat(3, 1fr);
        gap: 2rem;
    }
}

/* Large desktop */
@media (min-width: 1200px) {
    .container {
        max-width: 1140px;
    }
}

/* Responsive images */
img {
    max-width: 100%;
    height: auto;
}

/* Responsive video */
.video-wrapper {
    position: relative;
    padding-bottom: 56.25%; /* 16:9 */
    height: 0;
    overflow: hidden;
}
.video-wrapper iframe {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
}

/* Transitions */
.button {
    background: #3498db;
    color: white;
    padding: 0.75rem 1.5rem;
    border: none;
    border-radius: 4px;
    cursor: pointer;
    transition: background 0.3s ease, transform 0.2s ease, box-shadow 0.3s ease;
}
.button:hover {
    background: #2980b9;
    transform: translateY(-2px);
    box-shadow: 0 4px 8px rgba(0,0,0,0.2);
}
.button:active {
    transform: translateY(0);
}

/* Keyframe animation */
@keyframes fadeInUp {
    from {
        opacity: 0;
        transform: translateY(20px);
    }
    to {
        opacity: 1;
        transform: translateY(0);
    }
}

.animate-in {
    animation: fadeInUp 0.6s ease-out forwards;
    opacity: 0;
}

/* Staggered animation */
.stagger > *:nth-child(1) { animation-delay: 0.1s; }
.stagger > *:nth-child(2) { animation-delay: 0.2s; }
.stagger > *:nth-child(3) { animation-delay: 0.3s; }

/* Loading spinner */
@keyframes spin {
    to { transform: rotate(360deg); }
}
.spinner {
    width: 40px;
    height: 40px;
    border: 4px solid #f3f3f3;
    border-top: 4px solid #3498db;
    border-radius: 50%;
    animation: spin 1s linear infinite;
}

/* Pulse animation */
@keyframes pulse {
    0%, 100% { transform: scale(1); }
    50% { transform: scale(1.05); }
}
.pulse:hover {
    animation: pulse 0.5s ease-in-out;
}

/* Reduced motion */
@media (prefers-reduced-motion: reduce) {
    *, *::before, *::after {
        animation-duration: 0.01ms !important;
        transition-duration: 0.01ms !important;
    }
}

:root {
    --color-primary: #3498db;
    --color-secondary: #2ecc71;
    --color-text: #333;
    --color-bg: #ffffff;
    --color-surface: #f5f5f5;
    --spacing-unit: 8px;
    --border-radius: 4px;
    --font-size-base: 16px;
    --transition-speed: 0.3s;
}

[data-theme="dark"] {
    --color-text: #f5f5f5;
    --color-bg: #1a1a2e;
    --color-surface: #16213e;
}

body {
    font-size: var(--font-size-base);
    color: var(--color-text);
    background: var(--color-bg);
    transition: background var(--transition-speed), color var(--transition-speed);
}

.card {
    background: var(--color-surface);
    padding: calc(var(--spacing-unit) * 3);
    border-radius: var(--border-radius);
    margin-bottom: calc(var(--spacing-unit) * 2);
}

.button-primary {
    background: var(--color-primary);
    color: white;
    padding: var(--spacing-unit) calc(var(--spacing-unit) * 2);
    border: none;
    border-radius: var(--border-radius);
    cursor: pointer;
}

/* Dynamic value from JS */
.progress-bar {
    --progress: 0%;
    width: var(--progress);
    height: 20px;
    background: var(--color-primary);
    transition: width 0.3s ease;
}

@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');

:root {
    --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
    --font-mono: 'SF Mono', 'Fira Code', monospace;
    --font-size-xs: 0.75rem;
    --font-size-sm: 0.875rem;
    --font-size-base: 1rem;
    --font-size-lg: 1.125rem;
    --font-size-xl: 1.25rem;
    --font-size-2xl: 1.5rem;
    --font-size-3xl: 1.875rem;
    --line-height-tight: 1.25;
    --line-height-normal: 1.5;
    --line-height-relaxed: 1.75;
}

body {
    font-family: var(--font-sans);
    font-size: var(--font-size-base);
    line-height: var(--line-height-normal);
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
}

h1, h2, h3, h4, h5, h6 {
    line-height: var(--line-height-tight);
    font-weight: 700;
    margin-bottom: 0.5em;
}

h1 { font-size: var(--font-size-3xl); }
h2 { font-size: var(--font-size-2xl); }
h3 { font-size: var(--font-size-xl); }

p {
    margin-bottom: 1.5em;
    max-width: 65ch;
}

code {
    font-family: var(--font-mono);
    font-size: 0.9em;
    background: var(--color-surface);
    padding: 0.2em 0.4em;
    border-radius: 3px;
}

.text-sm { font-size: var(--font-size-sm); }
.text-xs { font-size: var(--font-size-xs); }
.uppercase { text-transform: uppercase; letter-spacing: 0.05em; }

:root {
    /* Modern color format */
    --primary: oklch(65% 0.25 265);
    --secondary: oklch(70% 0.15 145);
    --text: oklch(20% 0.02 265);
    --bg: oklch(98% 0.01 265);
    --surface: oklch(95% 0.01 265);
}

/* Gradients */
.gradient-hero {
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
}

.gradient-mesh {
    background:
        radial-gradient(at 40% 20%, oklch(75% 0.15 130) 0px, transparent 50%),
        radial-gradient(at 80% 0%, oklch(70% 0.2 300) 0px, transparent 50%),
        radial-gradient(at 0% 50%, oklch(80% 0.1 60) 0px, transparent 50%);
    background-color: var(--bg);
}

/* Color-mix for hover states */
.button {
    background: var(--primary);
    color: white;
}
.button:hover {
    background: color-mix(in oklch, var(--primary), black 20%);
}

/* Relative colors */
.card {
    --card-bg: var(--primary);
    background: oklch(from var(--card-bg) 98% 0.02 h);
    border: 1px solid oklch(from var(--card-bg) 80% 0.1 h);
}

/* Conic gradient */
.conic-wheel {
    width: 200px;
    height: 200px;
    border-radius: 50%;
    background: conic-gradient(
        oklch(70% 0.2 0),
        oklch(70% 0.2 60),
        oklch(70% 0.2 120),
        oklch(70% 0.2 180),
        oklch(70% 0.2 240),
        oklch(70% 0.2 300),
        oklch(70% 0.2 360)
    );
}

/* Decorative quotes */
.quote {
    position: relative;
    padding-left: 2rem;
    font-style: italic;
}
.quote::before {
    content: '\201C';
    position: absolute;
    left: 0;
    top: -0.5rem;
    font-size: 3rem;
    color: var(--color-primary);
    line-height: 1;
}

/* Underline effect */
.link-effect {
    position: relative;
    text-decoration: none;
    color: var(--color-primary);
}
.link-effect::after {
    content: '';
    position: absolute;
    bottom: -2px;
    left: 0;
    width: 0;
    height: 2px;
    background: var(--color-primary);
    transition: width 0.3s ease;
}
.link-effect:hover::after {
    width: 100%;
}

/* Ordered list counter */
.steps {
    counter-reset: step-counter;
    list-style: none;
    padding: 0;
}
.steps li {
    counter-increment: step-counter;
    padding-left: 3rem;
    position: relative;
    margin-bottom: 1.5rem;
}
.steps li::before {
    content: counter(step-counter);
    position: absolute;
    left: 0;
    width: 2rem;
    height: 2rem;
    background: var(--color-primary);
    color: white;
    border-radius: 50%;
    display: flex;
    align-items: center;
    justify-content: center;
    font-weight: bold;
}

/* Checkbox custom */
.custom-checkbox {
    position: relative;
    padding-left: 2rem;
    cursor: pointer;
}
.custom-checkbox::before {
    content: '';
    position: absolute;
    left: 0;
    top: 0;
    width: 1.2rem;
    height: 1.2rem;
    border: 2px solid #999;
    border-radius: 3px;
    transition: all 0.2s;
}
.custom-checkbox.checked::before {
    background: var(--color-primary);
    border-color: var(--color-primary);
}
.custom-checkbox.checked::after {
    content: '\2713';
    position: absolute;
    left: 0.3rem;
    top: -0.1rem;
    color: white;
    font-size: 0.9rem;
}

/* Tooltip */
.tooltip {
    position: relative;
}
.tooltip::after {
    content: attr(data-tooltip);
    position: absolute;
    bottom: 100%;
    left: 50%;
    transform: translateX(-50%);
    background: #333;
    color: white;
    padding: 0.5rem;
    border-radius: 4px;
    font-size: 0.85rem;
    white-space: nowrap;
    opacity: 0;
    pointer-events: none;
    transition: opacity 0.2s;
}
.tooltip:hover::after {
    opacity: 1;
}

/* Child combinator */
.nav > li {
    display: inline-block;
}

/* Sibling combinator */
h2 + p {
    font-size: 1.2rem;
    font-weight: 500;
}

/* General sibling */
h2 ~ p {
    color: #666;
}

/* Attribute selectors */
a[href^="https"]::after {
    content: ' \2197';
}
a[href$=".pdf"]::after {
    content: ' [PDF]';
}
input[type="email"] {
    border-color: blue;
}
input[name*="search"] {
    border-radius: 20px;
}

/* Negation pseudo-class */
.card:not(.disabled) {
    opacity: 1;
}
.card.disabled {
    opacity: 0.5;
}

/* nth-child patterns */
:nth-child(odd) { background: #f9f9f9; }
:nth-child(3n) { margin-right: 0; }
:nth-last-child(-n+3) { font-weight: bold; }

/* :is() and :where() for specificity */
:where(h1, h2, h3, h4) {
    line-height: 1.2;
}
:is(.card, .panel) > h2 {
    margin-top: 0;
}

/* :has() - parent selector */
.card:has(img) {
    display: grid;
    grid-template-columns: 200px 1fr;
}
form:has(:invalid) button[type="submit"] {
    opacity: 0.5;
    pointer-events: none;
}

/* Native CSS Nesting */
.card {
    background: white;
    border-radius: 8px;
    padding: 1.5rem;
    box-shadow: 0 2px 4px rgba(0,0,0,0.1);

    & .card-header {
        display: flex;
        justify-content: space-between;
        align-items: center;
        margin-bottom: 1rem;

        & h3 {
            margin: 0;
            font-size: 1.25rem;
        }
    }

    & .card-body {
        color: #555;
        line-height: 1.6;
    }

    & .card-footer {
        margin-top: 1rem;
        padding-top: 1rem;
        border-top: 1px solid #eee;
        display: flex;
        gap: 0.5rem;
    }

    &:hover {
        box-shadow: 0 4px 8px rgba(0,0,0,0.15);
    }

    @media (min-width: 768px) {
        & .card-body {
            font-size: 1.1rem;
        }
    }
}

/* Nesting with @layer */
@layer base, components, utilities;

@layer base {
    body { font-family: system-ui; }
}

@layer components {
    .button {
        padding: 0.5rem 1rem;
        border: none;
        border-radius: 4px;

        &.primary { background: blue; color: white; }
        &.danger { background: red; color: white; }
    }
}

@layer utilities {
    .hidden { display: none; }
    .sr-only { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0,0,0,0); }
}

/* Horizontal scroll snap */
.carousel {
    display: flex;
    overflow-x: auto;
    scroll-snap-type: x mandatory;
    gap: 1rem;
    padding: 1rem;
    -webkit-overflow-scrolling: touch;
    scrollbar-width: none;
}
.carousel::-webkit-scrollbar {
    display: none;
}
.carousel .slide {
    flex: 0 0 300px;
    scroll-snap-align: center;
    background: white;
    border-radius: 8px;
    padding: 2rem;
    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}

/* Vertical scroll snap */
.fullpage {
    height: 100vh;
    overflow-y: auto;
    scroll-snap-type: y mandatory;
}
.fullpage section {
    min-height: 100vh;
    scroll-snap-align: start;
    display: flex;
    align-items: center;
    justify-content: center;
}

/* Mandatory vs proximity */
.proximity-snap {
    scroll-snap-type: y proximity;
}
.proximity-snap section {\    scroll-snap-align: start;
    scroll-padding-top: 60px; /* Account for fixed header */
}

/* Basic shapes */
.circle {
    clip-path: circle(50% at center);
}

.triangle {
    clip-path: polygon(50% 0%, 0% 100%, 100% 100%);
}

.hexagon {
    clip-path: polygon(25% 0%, 75% 0%, 100% 50%, 75% 100%, 25% 100%, 0% 50%);
}

/* Image shape */
.avatar {
    width: 100px;
    height: 100px;
    clip-path: circle(45% at 50% 50%);
    object-fit: cover;
}

/* Hover reveal effect */
.reveal-card {
    position: relative;
    overflow: hidden;
    border-radius: 8px;
}
.reveal-card .overlay {
    position: absolute;
    inset: 0;
    background: rgba(0,0,0,0.7);
    color: white;
    display: flex;
    align-items: center;
    justify-content: center;
    clip-path: circle(0% at 50% 50%);
    transition: clip-path 0.5s ease;
}
.reveal-card:hover .overlay {
    clip-path: circle(100% at 50% 50%);
}

/* Animated border */
@keyframes morph {
    0% { clip-path: polygon(0% 0%, 100% 0%, 100% 100%, 0% 100%); }
    25% { clip-path: polygon(5% 5%, 95% 5%, 95% 95%, 5% 95%); }
    50% { clip-path: polygon(10% 0%, 100% 0%, 90% 100%, 0% 100%); }
    100% { clip-path: polygon(0% 0%, 100% 0%, 100% 100%, 0% 100%); }
}
.morph-shape {
    animation: morph 4s ease-in-out infinite;
}

/* Frosted glass navigation */
.glass-nav {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    z-index: 100;
    background: rgba(255, 255, 255, 0.1);
    backdrop-filter: blur(10px);
    -webkit-backdrop-filter: blur(10px);
    border-bottom: 1px solid rgba(255, 255, 255, 0.2);
    padding: 1rem 2rem;
}

/* Glass card */
.glass-card {
    background: rgba(255, 255, 255, 0.15);
    backdrop-filter: blur(12px);
    -webkit-backdrop-filter: blur(12px);
    border: 1px solid rgba(255, 255, 255, 0.2);
    border-radius: 16px;
    padding: 2rem;
    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
}

/* Modal overlay */
.modal-overlay {
    position: fixed;
    inset: 0;
    background: rgba(0, 0, 0, 0.3);
    backdrop-filter: blur(4px);
    -webkit-backdrop-filter: blur(4px);
    display: flex;
    align-items: center;
    justify-content: center;
    z-index: 1000;
}

/* Dark glass */
.dark-glass {
    background: rgba(0, 0, 0, 0.4);
    backdrop-filter: blur(10px) saturate(150%);
    -webkit-backdrop-filter: blur(10px) saturate(150%);
    color: white;
    border: 1px solid rgba(255, 255, 255, 0.1);
    border-radius: 12px;
}

/* Fallback for no support */
@supports not (backdrop-filter: blur(1px)) {
    .glass-card {
        background: rgba(255, 255, 255, 0.9);
    }
}

/* Define container */
.sidebar {
    container-type: inline-size;
    container-name: sidebar;
}

.main-content {
    container-type: inline-size;
    container-name: main;
}

/* Container query */
.card {
    display: flex;
    flex-direction: column;
    padding: 1rem;
    border: 1px solid #ddd;
    border-radius: 8px;
}

.card .card-image {
    width: 100%;
    height: 200px;
    object-fit: cover;
    border-radius: 4px;
}

@container (min-width: 400px) {
    .card {
        flex-direction: row;
        gap: 1rem;
    }
    .card .card-image {
        width: 150px;
        height: auto;
    }
}

@container sidebar (max-width: 300px) {
    .card .card-title {
        font-size: 0.9rem;
    }
    .card .card-meta {
        display: none;
    }
}

/* Container query units */
.responsive-text {
    font-size: clamp(1rem, 3cqi, 1.5rem);
    /* cqi = container query inline size */
}

/* Fallback */
@supports not (container-type: inline-size) {
    @media (min-width: 768px) {
        .card {
            flex-direction: row;
        }
    }
}

/* Parent grid */
.card-grid {
    display: grid;
    grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
    gap: 1.5rem;
    padding: 1.5rem;
}

/* Cards use subgrid */
.card {
    display: grid;
    grid-template-rows: subgrid;
    grid-row: span 3;
    border: 1px solid #ddd;
    border-radius: 8px;
    overflow: hidden;
}

.card-header {
    padding: 1rem;
    background: #f5f5f5;
    font-weight: 600;
}

.card-body {
    padding: 1rem;
    flex: 1;
}

.card-footer {
    padding: 1rem;
    border-top: 1px solid #eee;
    display: flex;
    justify-content: flex-end;
    gap: 0.5rem;
}

/* Fallback for no subgrid support */
@supports not (grid-template-rows: subgrid) {
    .card {
        display: flex;
        flex-direction: column;
    }
    .card-body {
        flex: 1;
    }
    .card-footer {
        margin-top: auto;
    }
}

/* Alignment across columns */
.data-table {
    display: grid;
    grid-template-columns: 2fr 1fr 1fr 1fr;
    gap: 0;
}
.data-row {
    display: grid;
    grid-column: 1 / -1;
    grid-template-columns: subgrid;
    border-bottom: 1px solid #eee;
    padding: 0.5rem 0;
}

/* Define layer order (lowest to highest specificity) */
@layer reset, base, components, utilities;

/* Reset layer */
@layer reset {
    *, *::before, *::after {
        box-sizing: border-box;
        margin: 0;
        padding: 0;
    }
}

/* Base layer */
@layer base {
    body {
        font-family: system-ui, sans-serif;
        line-height: 1.6;
        color: #333;
    }
    a {
        color: inherit;
        text-decoration: none;
    }
    img {
        max-width: 100%;
        display: block;
    }
}

/* Components layer */
@layer components {
    .button {
        display: inline-flex;
        align-items: center;
        padding: 0.5rem 1rem;
        border: 1px solid transparent;
        border-radius: 4px;
        font-size: 1rem;
        cursor: pointer;
        transition: all 0.2s;
    }
    .button-primary {
        background: #3498db;
        color: white;
    }
    .button-primary:hover {
        background: #2980b9;
    }
}

/* Utilities layer (highest specificity) */
@layer utilities {
    .hidden { display: none !important; }
    .sr-only {
        position: absolute;
        width: 1px;
        height: 1px;
        padding: 0;
        margin: -1px;
        overflow: hidden;
        clip: rect(0, 0, 0, 0);
        border: 0;
    }
    .text-center { text-align: center; }
    .mt-1 { margin-top: 0.25rem; }
    .mt-2 { margin-top: 0.5rem; }
    .mt-4 { margin-top: 1rem; }
}

/* Unlayered styles beat all layers */
.urgent {
    color: red !important;
}

/* Card with image gets different layout */
.card:has(img) {
    display: grid;
    grid-template-columns: 200px 1fr;
    gap: 1rem;
}

/* Form validation styling */
form:has(:invalid) .submit-btn {
    opacity: 0.5;
    pointer-events: none;
}

form:has(:focus) .form-group {
    background: #f8f9fa;
}

/* Empty state */
.list-container:has(.list-item:empty) {
    display: flex;
    align-items: center;
    justify-content: center;
    min-height: 200px;
}

.list-container:not(:has(.list-item))::after {
    content: 'No items found';
    color: #999;
    font-style: italic;
}

/* Section with video gets special treatment */
section:has(video) {
    background: #000;
    color: white;
    padding: 0;
}

/* Navigation with dropdown */
nav:has(.dropdown) {
    position: relative;
}

/* Conditional styling based on sibling content */
article:has(h1, h2) > .subtitle {
    font-size: 1.2rem;
    color: #666;
}

/* Responsive without media queries */
.container:has(.sidebar) {
    display: grid;
    grid-template-columns: 250px 1fr;
    gap: 2rem;
}

.container:not(:has(.sidebar)) {
    max-width: 800px;
    margin: 0 auto;
}

/* Fluid typography system */
:root {
    /* Fluid font sizes using clamp */
    --text-xs: clamp(0.7rem, 0.65rem + 0.25vw, 0.8rem);
    --text-sm: clamp(0.8rem, 0.75rem + 0.25vw, 0.9rem);
    --text-base: clamp(0.95rem, 0.9rem + 0.25vw, 1.1rem);
    --text-lg: clamp(1.1rem, 1rem + 0.5vw, 1.35rem);
    --text-xl: clamp(1.25rem, 1.1rem + 0.75vw, 1.75rem);
    --text-2xl: clamp(1.5rem, 1.2rem + 1.5vw, 2.25rem);
    --text-3xl: clamp(1.875rem, 1.4rem + 2.375vw, 3rem);
    --text-4xl: clamp(2.25rem, 1.5rem + 3.75vw, 4rem);

    /* Fluid spacing */
    --space-xs: clamp(0.25rem, 0.2rem + 0.25vw, 0.5rem);
    --space-sm: clamp(0.5rem, 0.4rem + 0.5vw, 1rem);
    --space-md: clamp(1rem, 0.8rem + 1vw, 2rem);
    --space-lg: clamp(2rem, 1.5rem + 2.5vw, 4rem);
}

body {
    font-size: var(--text-base);
    line-height: 1.6;
}

h1 { font-size: var(--text-4xl); line-height: 1.1; margin-bottom: var(--space-md); }
h2 { font-size: var(--text-3xl); line-height: 1.2; margin-bottom: var(--space-sm); }
h3 { font-size: var(--text-2xl); line-height: 1.25; }
h4 { font-size: var(--text-xl); line-height: 1.3; }

.lead {
    font-size: var(--text-lg);
    line-height: 1.7;
    max-width: 65ch;
}

.caption {
    font-size: var(--text-sm);
    line-height: 1.4;
}

/* Line length control */
.prose {
    max-width: 65ch;
    margin: 0 auto;
}

/* Vertical rhythm */
.prose > * + * {
    margin-top: 1.5em;
}

/* Responsive measure */
@media (max-width: 40em) {
    .prose {
        max-width: 100%;
        padding: 0 var(--space-sm);
    }
}

/* Reduced motion */
@media (prefers-reduced-motion: reduce) {
    * {
        transition: none !important;
    }
}

function reverseString(str) {
    return str.split('').reverse().join('');
}

// Manual approach
function reverseStringManual(str) {
    let result = '';
    for (let i = str.length - 1; i >= 0; i--) {
        result += str[i];
    }
    return result;
}

console.log(reverseString('hello'));
console.log(reverseStringManual('hello'));

function isPalindrome(str) {
    const cleaned = str.toLowerCase().replace(/[^a-z0-9]/g, '');
    let left = 0, right = cleaned.length - 1;
    while (left < right) {
        if (cleaned[left] !== cleaned[right]) return false;
        left++;
        right--;
    }
    return true;
}

console.log(isPalindrome('A man a plan a canal Panama'));
console.log(isPalindrome('racecar'));
console.log(isPalindrome('hello'));

function factorial(n) {
    if (n < 0) throw new Error('Negative input not allowed');
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

// Tail-recursive version
function factorialTail(n, acc = 1) {
    if (n <= 1) return acc;
    return factorialTail(n - 1, n * acc);
}

console.log(factorial(5));
console.log(factorialTail(10));

// Naive recursion - O(2^n)
function fibNaive(n) {
    if (n <= 1) return n;
    return fibNaive(n - 1) + fibNaive(n - 2);
}

// Memoized - O(n)
function fibMemo(n, memo = {}) {
    if (n in memo) return memo[n];
    if (n <= 1) return n;
    memo[n] = fibMemo(n - 1, memo) + fibMemo(n - 2, memo);
    return memo[n];
}

// Iterative - O(n) time, O(1) space
function fibIterative(n) {
    if (n <= 1) return n;
    let a = 0, b = 1;
    for (let i = 2; i <= n; i++) {
        [a, b] = [b, a + b];
    }
    return b;
}

console.log(fibMemo(10));
console.log(fibIterative(50));

// Counter using closure
function createCounter(initial = 0) {
    let count = initial;
    return {
        increment: () => ++count,
        decrement: () => --count,
        getCount: () => count,
        reset: () => { count = initial; return count; }
    };
}

const counter = createCounter(10);
console.log(counter.increment()); // 11
console.log(counter.increment()); // 12
console.log(counter.decrement()); // 11
console.log(counter.getCount());  // 11

// Private variables
function createPerson(name, age) {
    return {
        getName: () => name,
        getAge: () => age,
        setAge: (newAge) => {
            if (newAge >= 0 && newAge < 150) age = newAge;
        }
    };
}

// Function factory
function multiplier(factor) {
    return (number) => number * factor;
}
const double = multiplier(2);
const triple = multiplier(3);
console.log(double(5));  // 10
console.log(triple(5));  // 15

function debounce(fn, delay) {
    let timeoutId;
    return function(...args) {
        clearTimeout(timeoutId);
        timeoutId = setTimeout(() => {
            fn.apply(this, args);
        }, delay);
    };
}

// Usage
function handleSearch(query) {
    console.log('Searching for:', query);
}

const debouncedSearch = debounce(handleSearch, 300);
// These rapid calls result in only one execution
// debouncedSearch('a');
// debouncedSearch('ab');
// debouncedSearch('abc'); -> executes after 300ms

// Leading edge debounce
function debounceLeading(fn, delay) {
    let lastCall = 0;
    return function(...args) {
        const now = Date.now();
        if (now - lastCall >= delay) {
            lastCall = now;
            fn.apply(this, args);
        }
    };
}

function throttle(fn, interval) {
    let lastTime = 0;
    let timeoutId = null;
    return function(...args) {
        const now = Date.now();
        const remaining = interval - (now - lastTime);
        if (remaining <= 0) {
            if (timeoutId) {
                clearTimeout(timeoutId);
                timeoutId = null;
            }
            lastTime = now;
            fn.apply(this, args);
        } else if (!timeoutId) {
            timeoutId = setTimeout(() => {
                lastTime = Date.now();
                timeoutId = null;
                fn.apply(this, args);
            }, remaining);
        }
    };
}

// Usage
function handleScroll(event) {
    console.log('Scroll position:', window.scrollY);
}

const throttledScroll = throttle(handleScroll, 200);
window.addEventListener('scroll', throttledScroll);

class MyPromise {
    constructor(executor) {
        this.state = 'pending';
        this.value = undefined;
        this.callbacks = [];
        const resolve = (value) => {
            if (this.state !== 'pending') return;
            this.state = 'fulfilled';
            this.value = value;
            this.callbacks.forEach(cb => cb.onFulfilled(value));
        };
        const reject = (reason) => {
            if (this.state !== 'pending') return;
            this.state = 'rejected';
            this.value = reason;
            this.callbacks.forEach(cb => cb.onRejected(reason));
        };
        try {
            executor(resolve, reject);
        } catch (err) {
            reject(err);
        }
    }
    then(onFulfilled, onRejected) {
        return new MyPromise((resolve, reject) => {
            const handle = (callback, fallback) => {
                return (value) => {
                    try {
                        const result = callback ? callback(value) : fallback(value);
                        if (result instanceof MyPromise) {
                            result.then(resolve, reject);
                        } else {
                            resolve(result);
                        }
                    } catch (err) {
                        reject(err);
                    }
                };
            };
            const fulfilled = handle(onFulfilled, v => v);
            const rejected = handle(onRejected, v => { throw v; });
            if (this.state === 'fulfilled') fulfilled(this.value);
            else if (this.state === 'rejected') rejected(this.value);
            else this.callbacks.push({ onFulfilled: fulfilled, onRejected: rejected });
        });
    }
    catch(onRejected) {
        return this.then(null, onRejected);
    }
    static resolve(value) {
        return new MyPromise(resolve => resolve(value));
    }
    static reject(reason) {
        return new MyPromise((_, reject) => reject(reason));
    }
}

// Usage
new MyPromise((resolve) => {
    setTimeout(() => resolve(42), 100);
}).then(value => {
    console.log(value); // 42
    return value * 2;
}).then(value => {
    console.log(value); // 84
});

// Sequential execution
async function fetchSequential(urls) {
    const results = [];
    for (const url of urls) {
        try {
            const response = await fetch(url);
            const data = await response.json();
            results.push(data);
        } catch (error) {
            console.error(`Failed to fetch ${url}:`, error.message);
            results.push(null);
        }
    }
    return results;
}

// Parallel execution
async function fetchParallel(urls) {
    const promises = urls.map(async (url) => {
        try {
            const response = await fetch(url);
            return await response.json();
        } catch (error) {
            console.error(`Failed to fetch ${url}:`, error.message);
            return null;
        }
    });
    return Promise.all(promises);
}

// Parallel with limit
async function fetchWithLimit(urls, limit = 5) {
    const results = [];
    const executing = new Set();
    for (const url of urls) {
        const promise = fetch(url).then(r => r.json()).catch(() => null);
        executing.add(promise);
        executing.add(promise.then(() => executing.delete(promise)));
        if (executing.size >= limit) {
            await Promise.race(executing);
        }
        results.push(await promise);
    }
    return results;
}

// Race with timeout
async function fetchWithTimeout(url, timeout = 5000) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), timeout);
    try {
        const response = await fetch(url, { signal: controller.signal });
        return await response.json();
    } finally {
        clearTimeout(timeoutId);
    }
}

// Create elements efficiently
function createListItem(text) {
    const li = document.createElement('li');
    li.className = 'list-item';
    li.setAttribute('data-id', Date.now());

    const span = document.createElement('span');
    span.textContent = text;
    li.appendChild(span);

    const deleteBtn = document.createElement('button');
    deleteBtn.textContent = 'X';
    deleteBtn.className = 'delete-btn';
    deleteBtn.addEventListener('click', () => li.remove());
    li.appendChild(deleteBtn);

    return li;
}

// Add item
function addItem(text) {
    const list = document.getElementById('my-list');
    list.appendChild(createListItem(text));
}

// Document fragment for batch operations
function addMultipleItems(items) {
    const list = document.getElementById('my-list');
    const fragment = document.createDocumentFragment();
    items.forEach(item => {
        fragment.appendChild(createListItem(item));
    });
    list.appendChild(fragment);
}

// Safe innerHTML alternative
function setSafeHTML(element, html) {
    const div = document.createElement('div');
    div.textContent = html;
    element.appendChild(div);
}

// Efficient list update with diffing
function updateList(container, newItems, keyFn) {
    const existing = new Map();
    container.querySelectorAll('[data-id]').forEach(el => {
        existing.set(el.getAttribute('data-id'), el);
    });

    const fragment = document.createDocumentFragment();
    newItems.forEach(item => {
        const key = keyFn(item);
        if (existing.has(key)) {
            fragment.appendChild(existing.get(key));
            existing.delete(key);
        } else {
            fragment.appendChild(createListItem(item.text));
        }
    });

    existing.forEach(el => el.remove());
    container.appendChild(fragment);
}

// Event delegation
const todoList = document.getElementById('todo-list');
todoList.addEventListener('click', (event) => {
    const target = event.target;

    // Handle delete button
    if (target.matches('.delete-btn')) {
        const item = target.closest('.todo-item');
        item.remove();
        return;
    }

    // Handle checkbox
    if (target.matches('.todo-checkbox')) {
        const item = target.closest('.todo-item');
        item.classList.toggle('completed', target.checked);
        return;
    }

    // Handle edit button
    if (target.matches('.edit-btn')) {
        const item = target.closest('.todo-item');
        const span = item.querySelector('.todo-text');
        const input = document.createElement('input');
        input.type = 'text';
        input.value = span.textContent;
        input.className = 'edit-input';
        span.replaceWith(input);
        input.focus();

        input.addEventListener('blur', () => {
            const newSpan = document.createElement('span');
            newSpan.className = 'todo-text';
            newSpan.textContent = input.value;
            input.replaceWith(newSpan);
        }, { once: true });
        return;
    }
});

// Custom event for communication
function dispatchCustomEvent(element, eventName, detail) {
    const event = new CustomEvent(eventName, {
        bubbles: true,
        detail: detail
    });
    element.dispatchEvent(event);
}

// Listen for custom event
document.addEventListener('todoAdded', (event) => {
    console.log('New todo:', event.detail.text);
});

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// Map - transform each element
const doubled = numbers.map(n => n * 2);
console.log('Doubled:', doubled);

// Filter - keep elements matching condition
const evens = numbers.filter(n => n % 2 === 0);
console.log('Evens:', evens);

// Reduce - accumulate into single value
const sum = numbers.reduce((acc, n) => acc + n, 0);
console.log('Sum:', sum);

// Find - first matching element
const firstLarge = numbers.find(n => n > 7);
console.log('First > 7:', firstLarge);

// some/every - boolean checks
const hasNegative = numbers.some(n => n < 0);
const allPositive = numbers.every(n => n > 0);
console.log('Has negative:', hasNegative);
console.log('All positive:', allPositive);

// flatMap - map and flatten
const sentences = ['Hello World', 'Foo Bar'];
const words = sentences.flatMap(s => s.split(' '));\console.log('Words:', words);

// Chaining
const result = numbers
    .filter(n => n % 2 === 0)
    .map(n => n ** 2)
    .reduce((acc, n) => acc + n, 0);
console.log('Sum of squares of evens:', result);

// Object from array
const users = [
    { name: 'Alice', age: 25 },
    { name: 'Bob', age: 30 },
    { name: 'Carol', age: 25 }
];
const grouped = users.reduce((acc, user) => {
    (acc[user.age] = acc[user.age] || []).push(user);
    return acc;
}, {});

const user = {
    name: 'Alice',
    age: 30,
    address: {
        street: '123 Main St',
        city: 'Springfield',
        state: 'IL'
    },
    hobbies: ['reading', 'hiking', 'coding']
};

// Basic destructuring
const { name, age } = user;
console.log(name, age);

// Renaming
const { name: userName, age: userAge } = user;
console.log(userName, userAge);

// Defaults
const { name, age, email = 'N/A' } = user;
console.log(email);

// Nested destructuring
const { address: { city, state } } = user;
console.log(city, state);

// Array destructuring
const [first, second, ...rest] = user.hobbies;
console.log(first, second, rest);

// Swap variables
let a = 1, b = 2;
[a, b] = [b, a];
console.log(a, b);

// Function parameter destructuring
function greet({ name, age = 0 }) {
    return `Hello ${name}, age ${age}`;
}
console.log(greet(user));

// Computed property names
const key = 'name';
const { [key]: value } = user;
console.log(value);

// Spread with arrays
const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const merged = [...arr1, ...arr2];
console.log(merged);

// Shallow copy
const copy = [...arr1];

// Spread with objects
const defaults = { color: 'blue', size: 'medium', theme: 'light' };
const userPrefs = { color: 'red', theme: 'dark' };
const config = { ...defaults, ...userPrefs };
console.log(config);

// Rest in function parameters
function sum(...numbers) {
    return numbers.reduce((acc, n) => acc + n, 0);
}
console.log(sum(1, 2, 3, 4));

// Rest with destructuring
const [first, second, ...remaining] = [1, 2, 3, 4, 5];
console.log(first, second, remaining);

// Spread for shallow clone with modifications
const original = { a: 1, b: { c: 2 } };
const modified = { ...original, b: { ...original.b, c: 3 } };
console.log(modified.b.c); // 3
console.log(original.b.c); // 2

// Spread in function calls
const numbers = [3, 1, 4, 1, 5, 9, 2, 6];
console.log(Math.max(...numbers));

class Shape {
    #color;

    constructor(color = 'black') {
        if (new.target === Shape) {
            throw new Error('Shape cannot be instantiated directly');
        }
        this.#color = color;
    }

    get color() {
        return this.#color;
    }

    set color(value) {
        if (typeof value !== 'string') throw new TypeError('Color must be a string');
        this.#color = value;
    }

    get area() {
        throw new Error('area() must be implemented by subclass');
    }

    toString() {
        return `${this.constructor.name} (color: ${this.#color}, area: ${this.area.toFixed(2)})`;
    }

    static fromJSON(json) {
        const data = JSON.parse(json);
        return new Shape(data.color);
    }
}

class Circle extends Shape {
    #radius;

    constructor(radius, color) {
        super(color);
        this.#radius = radius;
    }

    get radius() { return this.#radius; }

    get area() {
        return Math.PI * this.#radius ** 2;
    }

    get circumference() {
        return 2 * Math.PI * this.#radius;
    }
}

class Rectangle extends Shape {
    #width;
    #height;

    constructor(width, height, color) {
        super(color);
        this.#width = width;
        this.#height = height;
    }

    get area() {
        return this.#width * this.#height;
    }

    get isSquare() {
        return this.#width === this.#height;
    }

    static fromSquares(size, color) {
        return new Rectangle(size, size, color);
    }
}

const circle = new Circle(5, 'red');
console.log(circle.toString());
const rect = new Rectangle(4, 6, 'blue');
console.log(rect.toString(), rect.isSquare);

// Constructor function pattern
function Animal(name) {
    this.name = name;
}
Animal.prototype.speak = function() {
    return `${this.name} makes a sound`;
};

function Dog(name, breed) {
    Animal.call(this, name);
    this.breed = breed;
}
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;
Dog.prototype.speak = function() {
    return `${this.name} barks`;
};
Dog.prototype.fetch = function(item) {
    return `${this.name} fetches the ${item}`;
};

const rex = new Dog('Rex', 'German Shepherd');
console.log(rex.speak());
console.log(rex.fetch('ball'));
console.log(rex instanceof Dog);
console.log(rex instanceof Animal);

// Object.create for prototypal inheritance
const vehicle = {
    init(type) {
        this.type = type;
        return this;
    },
    describe() {
        return `Vehicle: ${this.type}`;
    }
};

const car = Object.create(vehicle);
car.init = function(make) {
    vehicle.init.call(this, 'car');
    this.make = make;
    return this;
};
car.describe = function() {
    return `${this.make} ${this.type}`;
};

const myCar = Object.create(car).init('Toyota');
console.log(myCar.describe());

// Manual currying
function curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        }
        return function(...args2) {
            return curried.apply(this, args.concat(args2));
        };
    };
}

// Generic curry with placeholder support
curry.placeholder = Symbol('placeholder');

function add(a, b, c) {
    return a + b + c;
}

const curriedAdd = curry(add);
console.log(curriedAdd(1)(2)(3));     // 6
console.log(curriedAdd(1, 2)(3));     // 6
console.log(curriedAdd(1)(2, 3));     // 6

// Practical examples
function log(level, timestamp, message) {
    return `[${level}] ${timestamp}: ${message}`;
}

const errorLog = curry(log)('ERROR');
const timestampedError = errorLog(new Date().toISOString());
console.log(timestampedError('Something went wrong'));

// Curried pipeline
const pipeline = curry((fn, value) => fn(value));
const transform = curry((...fns) => (value) => fns.reduce((acc, fn) => fn(acc), value));

const process = transform(
    x => x.trim(),
    x => x.toLowerCase(),
    x => x.replace(/\s+/g, '-')
);
console.log(process('  Hello World  ')); // 'hello-world'

// Basic memoization
function memoize(fn) {
    const cache = new Map();
    return function(...args) {
        const key = JSON.stringify(args);
        if (cache.has(key)) {
            return cache.get(key);
        }
        const result = fn.apply(this, args);
        cache.set(key, result);
        return result;
    };
}

// LRU Cache version
class LRUCache {
    constructor(maxSize = 100) {
        this.maxSize = maxSize;
        this.cache = new Map();
    }
    get(key) {
        if (!this.cache.has(key)) return undefined;
        const value = this.cache.get(key);
        this.cache.delete(key);
        this.cache.set(key, value);
        return value;
    }
    set(key, value) {
        if (this.cache.has(key)) this.cache.delete(key);
        else if (this.cache.size >= this.maxSize) {
            this.cache.delete(this.cache.keys().next().value);
        }
        this.cache.set(key, value);
    }
}

// Memoize with LRU
function memoizeLRU(fn, maxSize = 100) {
    const cache = new LRUCache(maxSize);
    return function(...args) {
        const key = JSON.stringify(args);
        let result = cache.get(key);
        if (result === undefined) {
            result = fn.apply(this, args);
            cache.set(key, result);
        }
        return result;
    };
}

// Usage
function expensiveCalculation(n) {
    console.log('Computing...');
    return n * n * n;
}

const memoized = memoize(expensiveCalculation);
console.log(memoized(5));  // Computing... 125
console.log(memoized(5));  // 125 (cached)
console.log(memoized(6));  // Computing... 216

// Simple deep clone
function deepClone(obj) {
    if (obj === null || typeof obj !== 'object') return obj;
    if (obj instanceof Date) return new Date(obj);
    if (obj instanceof RegExp) return new RegExp(obj);
    if (obj instanceof Map) return new Map([...obj].map(([k, v]) => [deepClone(k), deepClone(v)]));
    if (obj instanceof Set) return new Set([...obj].map(v => deepClone(v)));

    const clone = Array.isArray(obj) ? [] : {};
    for (const key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
            clone[key] = deepClone(obj[key]);
        }
    }
    return Object.setPrototypeOf(clone, Object.getPrototypeOf(obj));
}

// Deep clone with circular reference support
function deepCloneAdvanced(obj, seen = new WeakMap()) {
    if (obj === null || typeof obj !== 'object') return obj;
    if (seen.has(obj)) return seen.get(obj);
    if (obj instanceof Date) return new Date(obj);
    if (obj instanceof RegExp) return new RegExp(obj);

    const clone = Array.isArray(obj) ? [] : {};
    seen.set(obj, clone);
    for (const key of Reflect.ownKeys(obj)) {
        clone[key] = deepCloneAdvanced(obj[key], seen);
    }
    return clone;
}

// Usage
const original = {
    name: 'Alice',
    scores: [90, 85, 92],
    address: { city: 'Springfield', state: 'IL' },
    createdAt: new Date()
};
const cloned = deepClone(original);
cloned.scores.push(100);
console.log(original.scores.length); // 3 (unchanged)
console.log(cloned.scores.length);   // 4

// Recursive flatten
function flatten(arr, depth = Infinity) {
    return arr.reduce((acc, val) => {
        if (Array.isArray(val) && depth > 0) {
            acc.push(...flatten(val, depth - 1));
        } else {
            acc.push(val);
        }
        return acc;
    }, []);
}

// Iterative flatten
function flattenIterative(arr) {
    const stack = [...arr];
    const result = [];
    while (stack.length) {
        const item = stack.pop();
        if (Array.isArray(item)) {
            stack.push(...item);
        } else {
            result.unshift(item);
        }
    }
    return result;
}

// Flatten with depth limit
function flattenDepth(arr, depth) {
    if (depth <= 0) return arr.slice();
    return arr.reduce((acc, val) => {
        if (Array.isArray(val)) {
            acc.push(...flattenDepth(val, depth - 1));
        } else {
            acc.push(val);
        }
        return acc;
    }, []);
}

console.log(flatten([1, [2, [3, [4]], 5]]));
console.log(flattenDepth([1, [2, [3, [4]], 5]], 1)); // [1, 2, [3, [4]], 5]
console.log(flattenDepth([1, [2, [3, [4]], 5]], 2)); // [1, 2, 3, [4], 5]

// Using built-in (flat)
console.log([1, [2, [3, [4]], 5]].flat(Infinity));

// Parse URL parameters
function parseURLParams(url) {
    const params = new URLSearchParams(new URL(url).search);
    const result = {};
    for (const [key, value] of params) {
        if (result[key]) {
            if (Array.isArray(result[key])) {
                result[key].push(value);
            } else {
                result[key] = [result[key], value];
            }
        } else {
            result[key] = value;
        }
    }
    return result;
}

// Build URL with parameters
function buildURL(base, params) {
    const url = new URL(base);
    for (const [key, value] of Object.entries(params)) {
        if (value !== undefined && value !== null) {
            if (Array.isArray(value)) {
                value.forEach(v => url.searchParams.append(key, v));
            } else {
                url.searchParams.set(key, value);
            }
        }
    }
    return url.toString();
}

// Usage
const url = 'https://example.com/search?q=hello&lang=en&tag=js&tag=web';
console.log(parseURLParams(url));

console.log(buildURL('https://api.example.com/users', {
    page: 1,
    limit: 10,
    sort: 'name'
}));

// Remove parameter
function removeParam(url, param) {
    const urlObj = new URL(url);
    urlObj.searchParams.delete(param);
    return urlObj.toString();
}

console.log(removeParam(url, 'tag'));

const Storage = {
    set(key, value, ttlMs = null) {
        try {
            const item = {
                value,
                timestamp: Date.now(),
                ttl: ttlMs
            };
            localStorage.setItem(key, JSON.stringify(item));
            return true;
        } catch (e) {
            if (e.name === 'QuotaExceededError') {
                console.error('Storage quota exceeded');
            }
            return false;
        }
    },

    get(key) {
        try {
            const item = JSON.parse(localStorage.getItem(key));
            if (!item) return null;
            if (item.ttl && Date.now() - item.timestamp > item.ttl) {
                this.remove(key);
                return null;
            }
            return item.value;
        } catch (e) {
            return null;
        }
    },

    remove(key) {
        localStorage.removeItem(key);
    },

    clear() {
        localStorage.clear();
    },

    keys() {
        return Object.keys(localStorage);
    },

    has(key) {
        return this.get(key) !== null;
    },

    size() {
        let total = 0;
        for (const key in localStorage) {
            if (localStorage.hasOwnProperty(key)) {
                total += localStorage[key].length * 2; // UTF-16
            }
        }
        return total;
    }
};

// Usage
Storage.set('user', { name: 'Alice', age: 30 });
Storage.set('token', 'abc123', 3600000); // 1 hour TTL
console.log(Storage.get('user'));

// Basic fetch with error handling
async function fetchJSON(url, options = {}) {
    const response = await fetch(url, {
        headers: { 'Content-Type': 'application/json', ...options.headers },
        ...options
    });
    if (!response.ok) {
        const error = new Error(`HTTP ${response.status}`);
        error.status = response.status;
        error.response = response;
        throw error;
    }
    return response.json();
}

// Fetch with retry
async function fetchWithRetry(url, options = {}, retries = 3, delay = 1000) {
    for (let i = 0; i <= retries; i++) {
        try {
            return await fetchJSON(url, options);
        } catch (error) {
            if (i === retries || (error.status && error.status < 500)) {
                throw error;
            }
            await new Promise(r => setTimeout(r, delay * Math.pow(2, i)));
        }
    }
}

// Fetch with timeout
async function fetchWithTimeout(url, options = {}, timeout = 5000) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), timeout);
    try {
        return await fetchJSON(url, { ...options, signal: controller.signal });
    } finally {
        clearTimeout(timeoutId);
    }
}

// Abortable fetch hook (for React)
function useFetch(url) {
    const [data, setData] = React.useState(null);
    const [error, setError] = React.useState(null);
    const [loading, setLoading] = React.useState(true);

    React.useEffect(() => {
        const controller = new AbortController();
        fetchJSON(url, { signal: controller.signal })
            .then(setData)
            .catch(setError)
            .finally(() => setLoading(false));
        return () => controller.abort();
    }, [url]);

    return { data, error, loading };
}

class FormValidator {
    constructor(form, rules) {
        this.form = form;
        this.rules = rules;
        this.errors = {};
        this.init();
    }

    init() {
        this.form.addEventListener('submit', (e) => {
            e.preventDefault();
            if (this.validate()) {
                this.onSubmit();
            }
        });

        Object.keys(this.rules).forEach(fieldName => {
            const field = this.form.querySelector(`[name="${fieldName}"]`);
            if (field) {
                field.addEventListener('blur', () => this.validateField(fieldName));
                field.addEventListener('input', () => {
                    if (this.errors[fieldName]) this.validateField(fieldName);
                });
            }
        });
    }

    validate() {
        this.errors = {};
        Object.keys(this.rules).forEach(fieldName => {
            this.validateField(fieldName);
        });
        return Object.keys(this.errors).length === 0;
    }

    validateField(fieldName) {
        const field = this.form.querySelector(`[name="${fieldName}"]`);
        const value = field?.value;
        const fieldRules = this.rules[fieldName];
        delete this.errors[fieldName];

        for (const rule of fieldRules) {
            const error = rule(value, this.form);
            if (error) {
                this.errors[fieldName] = error;
                this.showError(fieldName, error);
                return false;
            }
        }
        this.clearError(fieldName);
        return true;
    }

    showError(fieldName, message) {
        const field = this.form.querySelector(`[name="${fieldName}"]`);
        const errorEl = field?.parentElement.querySelector('.error');
        if (errorEl) errorEl.textContent = message;
        field?.classList.add('error');
    }

    clearError(fieldName) {
        const field = this.form.querySelector(`[name="${fieldName}"]`);
        const errorEl = field?.parentElement.querySelector('.error');
        if (errorEl) errorEl.textContent = '';
        field?.classList.remove('error');
    }

    onSubmit() {
        console.log('Form submitted:', new FormData(this.form));
    }
}

// Rules
const required = (v) => !v?.trim() ? 'Required' : null;
const email = (v) => v && !/^[^@]+@[^@]+$/.test(v) ? 'Invalid email' : null;
const minLength = (min) => (v) => v && v.length < min ? `Min ${min} chars` : null;
const matches = (field) => (v, form) => v !== form.querySelector(`[name="${field}"]`).value ? 'Does not match' : null;

// Basic animation loop
class Animation {
    constructor(element, properties, duration, easing = 'easeInOut') {
        this.element = element;
        this.properties = properties;
        this.duration = duration;
        this.easing = easing;
        this.startTime = null;
        this.startValues = {};
        this.running = false;
    }

    easingFunctions = {
        linear: t => t,
        easeIn: t => t * t,
        easeOut: t => t * (2 - t),
        easeInOut: t => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
        bounce: t => {
            if (t < 1/2.75) return 7.5625 * t * t;
            if (t < 2/2.75) return 7.5625 * (t -= 1.5/2.75) * t + 0.75;
            if (t < 2.5/2.75) return 7.5625 * (t -= 2.25/2.75) * t + 0.9375;
            return 7.5625 * (t -= 2.625/2.75) * t + 0.984375;
        }
    };

    start() {
        this.running = true;
        this.startTime = performance.now();
        for (const prop in this.properties) {
            this.startValues[prop] = parseFloat(getComputedStyle(this.element)[prop]);
        }
        this.animate();
    }

    animate() {
        if (!this.running) return;
        const elapsed = performance.now() - this.startTime;
        const progress = Math.min(elapsed / this.duration, 1);
        const easedProgress = this.easingFunctions[this.easing](progress);

        for (const prop in this.properties) {
            const start = this.startValues[prop];
            const end = this.properties[prop];
            const current = start + (end - start) * easedProgress;
            this.element.style[prop] = current + 'px';
        }

        if (progress < 1) {
            requestAnimationFrame(() => this.animate());
        } else {
            this.running = false;
        }
    }

    stop() {
        this.running = false;
    }
}

// Usage
const box = document.getElementById('animated-box');
const anim = new Animation(box, { left: 500, top: 300 }, 2000, 'bounce');
anim.start();

// Scroll animation
function animateOnScroll() {
    const elements = document.querySelectorAll('.animate-on-scroll');
    elements.forEach(el => {
        const rect = el.getBoundingClientRect();
        if (rect.top < window.innerHeight * 0.8) {
            el.classList.add('animated');
        }
    });
    requestAnimationFrame(animateOnScroll);
}
requestAnimationFrame(animateOnScroll);

<?php
function reverseString(string $str): string {
    return strrev($str);
}

function reverseStringManual(string $str): string {
    $result = '';
    $len = strlen($str);
    for ($i = $len - 1; $i >= 0; $i--) {
        $result .= $str[$i];
    }
    return $result;
}

echo reverseString('hello') . PHP_EOL;
echo reverseStringManual('hello') . PHP_EOL;

<?php
function isPalindrome(string $str): bool {
    $cleaned = strtolower(preg_replace('/[^a-zA-Z0-9]/', '', $str));
    $len = strlen($cleaned);
    for ($i = 0; $i < $len / 2; $i++) {
        if ($cleaned[$i] !== $cleaned[$len - 1 - $i]) {
            return false;
        }
    }
    return true;
}

echo var_export(isPalindrome('racecar'), true) . PHP_EOL;
echo var_export(isPalindrome('A man a plan a canal Panama'), true) . PHP_EOL;

<?php
function factorial(int $n): int {
    if ($n < 0) throw new InvalidArgumentException('Negative input');
    if ($n <= 1) return 1;
    $result = 1;
    for ($i = 2; $i <= $n; $i++) {
        $result *= $i;
    }
    return $result;
}

function factorialRecursive(int $n): int {
    if ($n <= 1) return 1;
    return $n * factorialRecursive($n - 1);
}

echo factorial(5) . PHP_EOL;
echo factorialRecursive(10) . PHP_EOL;

<?php
function fibonacci(int $n): array {
    if ($n <= 0) return [];
    $fib = [0];
    if ($n === 1) return $fib;
    $fib[] = 1;
    for ($i = 2; $i < $n; $i++) {
        $fib[] = $fib[$i - 1] + $fib[$i - 2];
    }
    return $fib;
}

echo implode(' ', fibonacci(10)) . PHP_EOL;

<?php
function isPrime(int $n): bool {
    if ($n < 2) return false;
    if ($n < 4) return true;
    if ($n % 2 === 0 || $n % 3 === 0) return false;
    for ($i = 5; $i * $i <= $n; $i += 6) {
        if ($n % $i === 0 || $n % ($i + 2) === 0) return false;
    }
    return true;
}

echo var_export(isPrime(17), true) . PHP_EOL;
echo var_export(isPrime(1), true) . PHP_EOL;

<?php
$numbers = [3, 1, 4, 1, 5, 9, 2, 6];

// Map
$squared = array_map(fn($n) => $n ** 2, $numbers);
echo 'Squared: ' . implode(', ', $squared) . PHP_EOL;

// Filter
$evens = array_filter($numbers, fn($n) => $n % 2 === 0);
echo 'Evens: ' . implode(', ', $evens) . PHP_EOL;

// Reduce
$sum = array_reduce($numbers, fn($carry, $n) => $carry + $n, 0);
echo 'Sum: ' . $sum . PHP_EOL;

// Sort
$sorted = $numbers;
sort($sorted);
echo 'Sorted: ' . implode(', ', $sorted) . PHP_EOL;

// Associative operations
$prices = ['apple' => 1.50, 'banana' => 0.75, 'cherry' => 3.00];
$expensive = array_filter($prices, fn($p) => $p > 1.00);
echo 'Expensive: ' . implode(', ', $expensive) . PHP_EOL;

// Merge
$a = [1, 2, 3];
$b = [4, 5, 6];
$merged = array_merge($a, $b);
echo 'Merged: ' . implode(', ', $merged) . PHP_EOL;