Computer Science Engineering

Use a hash map to store complements. For each number, check if (target - number) exists in the map. If yes, return the pair. Otherwise, add the current number to the map. Time complexity: O(n), Space complexity: O(n). This is better than the brute force O(n^2) approach of checking all pairs. For sorted arrays, use two-pointer technique for O(n) time with O(1) space.

Key components: 1) Use Base62 encoding (a-z, A-Z, 0-9) to generate short URLs from unique IDs. 2) Use a distributed ID generator (Twitter Snowflake) to avoid collisions. 3) Cache frequently accessed URLs in Redis with LRU eviction. 4) Use consistent hashing to distribute data across multiple database shards. 5) Read replicas for scaling reads (100:1 read/write ratio). 6) CDN for global distribution. 7) Rate limiting per API key. For high availability, deploy across multiple regions with active-active setup and async replication.

A process is an independent execution unit with its own memory space (heap, stack, code), while threads are lightweight units within a process sharing the same memory but with separate stacks. Use processes for isolation (security, fault tolerance) - like microservices where one crash shouldn't affect others. Use threads for concurrent operations within an application - like handling multiple HTTP requests in a web server. Threads have lower overhead (no context switch of address space) but require careful synchronization (mutexes, semaphores) to avoid race conditions. Modern approaches include green threads (Go goroutines), async/await (Node.js, Python asyncio), and actor models (Erlang/Akka).

Use modified binary search. At each step, determine which half is sorted by comparing arr[mid] with arr[start]. If target lies in the sorted half's range, search there; otherwise, search the other half. Key insight: at least one half is always sorted in a rotated sorted array. Implementation: if arr[mid] == target, return mid. If arr[start] <= arr[mid], left half is sorted - check if target is in [start, mid) range. Otherwise, right half is sorted. Edge case: with duplicates, worst case becomes O(n) when arr[start] == arr[mid] == arr[end].

Algorithms: 1) Token Bucket - tokens added at fixed rate, requests consume tokens, allows bursts up to bucket capacity. 2) Sliding Window Log - store timestamps in sorted set, count requests in rolling window, most accurate but memory-intensive. 3) Sliding Window Counter - approximation using current + previous window weighted by time. For distributed systems: Use Redis for centralized counting with atomic operations (INCR with EXPIRE, or Lua scripts for sliding window). Handle race conditions with MULTI/EXEC or Lua scripts for atomicity. Consider: client identification (IP, API key, user ID), graceful degradation (return 429 with Retry-After header), separate limits for different endpoints/tiers, and local caching with sync for reduced latency.