/* Glassmorphism Effect */
.card {
    background: rgba(255, 255, 255, 0.25);
    backdrop-filter: blur(4px);
    border: 1px solid rgba(255, 255, 255, 0.18);
    border-radius: 10px;
}

/* Gradient Text */
.highlight {
    background: linear-gradient(120deg, #6366f1, #a855f7);
    background-clip: text;
    -webkit-background-clip: text;
    -webkit-text-fill-color: transparent;
}

/* Modal Dialog System */
function openModal(modalId) {
    document.getElementById(modalId).style.display = 'flex';
    document.body.style.overflow = 'hidden';
}

// Console Color Implementation
public class Hangman {
    // ANSI Color Codes
    public static final String RED = "\u001B[31m";
    public static final String GREEN = "\u001B[32m";
    public static final String YELLOW = "\u001B[33m";
    public static final String CYAN = "\u001B[36m";
    public static final String RESET = "\u001B[0m";
    
    // Nested class for word management
    public static class WordReader {
        public static String getRandomWordFromFile(String filename) 
            throws IOException {
            // Resource loading from JAR
            try (InputStream is = 
                Hangman.class.getResourceAsStream("/" + filename)) {
                // Stream processing for efficiency
            }
        }
    }
}

# Optimized win detection using direction vectors
def winning_move(board, piece):
    # Check all possible winning locations
    # Directions: horizontal, vertical, positive/negative diagonal
    directions = [(0, 1), (1, 0), (1, 1), (1, -1)]
    
    for r_start in range(ROW_COUNT):
        for c_start in range(COLUMN_COUNT):
            for dr, dc in directions:
                # Check if 4 consecutive pieces exist
                if 0 <= r_start + 3*dr < ROW_COUNT and \
                   0 <= c_start + 3*dc < COLUMN_COUNT:
                    if all(board[r_start + i*dr][c_start + i*dc] == piece 
                           for i in range(4)):
                        return True
    return False

// Main Game Loop with Color Support
#include <windows.h>

void setColor(int color) {
    SetConsoleTextAttribute(
        GetStdHandle(STD_OUTPUT_HANDLE), color);
}

int main() {
    char playAgain;
    srand(time(0));
    
    do {
        char spaces[9] = {' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '};
        bool running = true;
        
        while(running) {
            playerMove(spaces, player);
            drawBoard(spaces);
            if(checkWinner(spaces, player, computer)) {
                running = false;
            }
            
            computerMove(spaces, computer);
            drawBoard(spaces);
        }
        
        cout << "Play again? (Y/N): ";
        cin >> playAgain;
    } while(playAgain == 'Y' || playAgain == 'y');
    
    return 0;
}

// My Learning Workflow
1. Watch Striver's video for problem pattern (5-15 min)
2. Understand the pattern/approach explained
3. Attempt problem applying that pattern
4. If stuck, look at editorial
5. Re-implement independently

// Multiple Solutions Per Problem
- Solve with brute force first
- Analyze time-space complexity
- Optimize using learned patterns
- Compare approaches

// Example: Contains Duplicate
Solution 1: HashSet with contains() - O(n) time, O(n) space
Solution 2: Sort then check adjacent - O(n log n) [BAD - SLOW]
Solution 3: HashSet using add() return - O(n) [GOOD - Optimized]