Question 1

What is the difference between stack and heap memory?

Accepted Answer

In short: The stack holds method call frames — parameters, local value-type variables and references — per thread; allocation and cleanup are automatic and very fast (push/pop) but it is small (≈1 MB per thread). The heap holds objects created with new , shared by all threads, larger, and in .NET cleaned by the garbage collector. Stack overflow comes from too-deep recursion; heap problems are leaks and fragmentation.

Question 2

What is the difference between a process and a thread?

Accepted Answer

In short: A process is a running program with its own isolated virtual memory and resources. A thread is an execution path inside a process; threads of the same process share its heap and resources but each has its own stack and registers. Processes are isolated and heavier; threads are lighter but need synchronisation for shared data, and an unhandled exception in one thread kills the whole process.

Question 3

What is RAM and why is it faster than disk? What is a cache?

Accepted Answer

In short: RAM is volatile main memory accessed electronically in ~100 ns; SSDs take tens of microseconds and HDDs milliseconds because of slower technology (and seek mechanics for HDDs). A cache is a small, faster copy of frequently used data closer to where it s needed — CPU L1/L2/L3 caches over RAM, SQL Server s buffer pool over disk, Redis over a database. Caches work because of locality: recently or nearby used data is likely to be used again.

Question 4

What is virtual memory?

Accepted Answer

In short: An OS + CPU mechanism that gives each process its own large, private address space, mapped page by page (usually 4 KB) to physical RAM or to disk (page file/swap). It isolates processes, lets programs use more memory than physically available, and loads pages lazily. Accessing a page not in RAM causes a page fault; heavy paging (thrashing) makes a system extremely slow.

Question 5

What is a race condition and how do you prevent it?

Accepted Answer

In short: When the result depends on the timing of threads accessing shared data, e.g. two threads doing count++ (read, add, write) and one update is lost. Prevent it with mutual exclusion ( lock , SemaphoreSlim ), atomic operations ( Interlocked ), thread-safe collections ( ConcurrentDictionary ), immutable data, or by not sharing state (message passing). In databases, transactions and isolation levels play the same role.

Question 6

What is a deadlock? How do you avoid it?

Accepted Answer

In short: Two or more threads (or transactions) each hold a resource the other needs and wait forever. Conditions: mutual exclusion, hold-and-wait, no preemption, circular wait. Avoid by acquiring locks in a consistent order, holding locks briefly, using timeouts ( Monitor.TryEnter , SemaphoreSlim.WaitAsync(timeout) ), and avoiding sync-over-async ( .Result ) in .NET. SQL Server detects deadlocks and kills one victim transaction.

Question 7

A server has 16 GB RAM but the app is very slow and disk activity is constantly 100%. What might be happening?

Accepted Answer

In short: Probably memory pressure and paging: processes (or SQL Server with no max memory limit, or a leaking app) use more than physical RAM, so the OS keeps swapping pages to disk (thrashing). Check memory usage per process, page faults/sec and page file usage; set SQL Server max server memory, fix leaks, reduce caching, or add RAM. Also check whether the disk activity is actually database reads due to missing indexes.

Question 8

What is Big-O notation? Give examples.

Accepted Answer

In short: It describes how an algorithm s time or memory grows with input size n, ignoring constants and smaller terms. O(1) dictionary lookup, O(log n) binary search, O(n) one loop, O(n log n) good sorts, O(n²) nested loops over the same data, O(2ⁿ) all subsets. It lets you predict whether a solution scales — e.g. O(n²) on a million items is ~10¹² operations, too slow.

Question 9

Array vs linked list — when do you use each?

Accepted Answer

In short: Arrays (and List T ) store elements contiguously: O(1) index access, cache-friendly iteration, but O(n) inserts/removes in the middle. Linked lists store nodes with pointers: O(1) insert/remove at a known node, but O(n) access by position and poor cache locality. In practice List T wins most of the time; linked lists suit frequent middle insertions with a node reference (LRU caches pair a linked list with a dictionary).

Question 10

How does a hash table (Dictionary) work?

Accepted Answer

In short: It computes the key s hash code, maps it to a bucket ( hash % size ), and stores the entry there; lookups recompute the hash, go to the bucket and compare with Equals . Collisions are handled by chaining or probing; when the load factor grows, it resizes and rehashes. Average O(1) insert/lookup/delete, worst O(n) if many keys collide. Keys must have consistent Equals / GetHashCode and shouldn t change while stored.

Question 11

Stack vs queue — examples of where each is used?

Accepted Answer

In short: Stack is LIFO: function call stack, undo/redo, browser back button, expression evaluation, DFS. Queue is FIFO: print jobs, request/message queues, thread-pool work items, BFS. Both have O(1) push/pop or enqueue/dequeue.

Question 12

Explain binary search. What is required to use it?

Accepted Answer

In short: The data must be sorted. Compare the target with the middle element; if smaller, search the left half, otherwise the right half; repeat until found or the range is empty — O(log n). Compute the middle as lo + (hi - lo) / 2 to avoid overflow. Database index seeks work on the same principle over B-tree pages.

Question 13

Compare quicksort and merge sort.

Accepted Answer

In short: Both average O(n log n). Merge sort is always O(n log n), stable, but needs O(n) extra memory — good for linked lists and external sorting of huge data. Quicksort sorts in place (O(log n) stack), is usually faster in practice thanks to cache locality, but is O(n²) in the worst case with bad pivots and is not stable. .NET s Array.Sort uses introsort to avoid the worst case.

Question 14

What is a binary search tree? What happens if it becomes unbalanced?

Accepted Answer

In short: A binary tree where every node s left subtree has smaller keys and right subtree larger keys, so search/insert/delete follow one path: O(height). Balanced height is log n; inserting sorted data into a plain BST makes it a linked list with O(n) operations. Self-balancing trees (AVL, red-black) and B-trees keep the height logarithmic — SQL Server indexes are B+ trees.

Question 15

BFS vs DFS?

Accepted Answer

In short: BFS explores level by level using a queue — finds the shortest path in unweighted graphs, uses memory proportional to the widest level. DFS goes as deep as possible using recursion or a stack — good for connectivity, cycle detection, topological sort and backtracking, uses memory proportional to depth. Both are O(V + E).

Question 16

What is dynamic programming? How is it different from recursion?

Accepted Answer

In short: DP solves problems with overlapping subproblems and optimal substructure by storing subproblem results (memoisation top-down, or a table bottom-up) so each is computed once. Plain recursion may recompute the same subproblem exponentially many times (naive Fibonacci O(2ⁿ) vs DP O(n)). Typical DP problems: coin change, knapsack, longest common subsequence, edit distance, climbing stairs.

Question 17

A report compares two lists of 200,000 customer ids with nested loops and takes 20 minutes. Fix it.

Accepted Answer

In short: Nested loops are O(n × m) ≈ 4 × 10¹⁰ comparisons. Put one list into a HashSet int (O(m)) and check each id of the other list with Contains (O(1) average) — O(n + m), milliseconds. Or sort both and merge with two pointers (O(n log n)), or let SQL do it with an indexed JOIN/EXISTS.

Question 18

An autocomplete box queries WHERE Name LIKE '%term%' on 5 million products and is slow. How would you improve it?

Accepted Answer

In short: A leading wildcard can t use a B-tree index, so every keystroke scans the table. Options: prefix search LIKE term% on an indexed column (index seek), a trie or sorted in-memory list of names for prefix lookups, full-text search (SQL Server full-text index, Azure AI Search, Elasticsearch) for word matches, debounce keystrokes and limit to top 10, cache popular prefixes.

Question 19

Reverse a string without using built-in Reverse.

Accepted Answer

Convert to a char[] , swap from both ends towards the middle with two pointers, then build a new string. O(n) time, O(n) space for the array (strings are immutable, so you can t do it in place). csharp Copy static string Reverse ( string s ) { var c = s.ToCharArray(); for ( int i = 0 , j = c.Length - 1 ; i j; i++, j--) (c[i], c[j]) = (c[j], c[i]); return new string (c); } Mention: for user-visible text with emoji or combining characters, use StringInfo text elements.

Question 20

Check whether a string is a palindrome.

Accepted Answer

Two pointers from both ends, skip non-alphanumerics, compare case-insensitively. O(n) time, O(1) space. Simple version: s == new string(s.Reverse().ToArray()) , which is O(n) extra space. csharp Copy static bool IsPal ( string s ) { for ( int i = 0 , j = s.Length - 1 ; i j; i++, j--) if ( char .ToLower(s[i]) != char .ToLower(s[j])) return false ; return true ; }

Question 21

Print the Fibonacci series up to n terms.

Accepted Answer

csharp Copy long a = 0 , b = 1 ; for ( int i = 0 ; i n; i++) { Console.Write( $ {a} ); (a, b) = (b, a + b); } Iterative is O(n) time and O(1) space. Naive recursion F(n-1)+F(n-2) is O(2ⁿ) — mention memoisation if asked for recursion.

Question 22

Find duplicate elements in an array.

Accepted Answer

Use a HashSet int : Add returns false when the item already exists. O(n) time, O(n) space. LINQ alternative: arr.GroupBy(x = x).Where(g = g.Count() 1).Select(g = g.Key) . If O(1) space is required and the array can be modified: sort first (O(n log n)) and compare neighbours. csharp Copy var seen = new HashSet int (); var dups = arr.Where(x = !seen.Add(x)).Distinct().ToList();

Question 23

Count the occurrences of each character in a string.

Accepted Answer

csharp Copy var counts = new Dictionary char , int (); foreach ( var c in s) counts[c] = counts.GetValueOrDefault(c) + 1 ; // LINQ: s.GroupBy(c = c).ToDictionary(g = g.Key, g = g.Count()); // .NET 9: s.CountBy(c = c) O(n) time, O(k) space where k = distinct characters.

Question 24

Find the second largest number in an array.

Accepted Answer

In short: Single pass tracking first and second (skip values equal to first if distinct values are needed). O(n), O(1). Sorting is simpler but O(n log n): arr.Distinct().OrderByDescending(x = x).Skip(1).First() . Clarify: what if all elements are the same or there s only one?

Question 25

Two Sum: return indexes of two numbers that add up to a target.

Accepted Answer

Brute force: two loops, O(n²). Optimal: one pass with a Dictionary value, index . For each number, check whether target - number was seen. O(n) time, O(n) space. If the array is sorted, use two pointers in O(1) space. csharp Copy var seen = new Dictionary int , int (); for ( int i = 0 ; i nums.Length; i++) { if (seen.TryGetValue(target - nums[i], out var j)) return [j, i]; seen[nums[i]] = i; }

Question 26

Find the length of the longest substring without repeating characters.

Accepted Answer

In short: Sliding window: keep the last index of each character. When a repeat appears inside the window, move start past its previous position, and track the max window length. O(n) time, O(k) space. Example: abcabcbb → 3 ( abc ).

Question 27

Find the maximum subarray sum (Kadane's algorithm).

Accepted Answer

In short: At each element, either extend the current subarray or start fresh: cur = max(a[i], cur + a[i]) , and best = max(best, cur) . O(n) time, O(1) space. Works with all-negative arrays if you initialise with a[0] . Example: [-2,1,-3,4,-1,2,1,-5,4] → 6 ([4,-1,2,1]).

Question 28

Check for balanced parentheses.

Accepted Answer

In short: Push opening brackets on a Stack char . For each closing bracket, the stack must be non-empty and the top must match. At the end the stack must be empty. O(n) time and space.

Question 29

Reverse a linked list.

Accepted Answer

In short: Iterate with three pointers: prev , current , next . Save next , point current.Next to prev , advance both. Return prev . O(n) time, O(1) space. Recursive version: O(n) stack space.

Question 30

Detect a loop in a linked list.

Accepted Answer

In short: Floyd s cycle detection: slow pointer moves one step, fast moves two. If they meet, there is a cycle; if fast reaches null, there isn t. O(n) time, O(1) space. To find the cycle start, reset one pointer to head and move both one step at a time until they meet. Alternative: a HashSet of visited nodes (O(n) space).

Question 31

Implement binary search. What is its complexity?

Accepted Answer

In short: On a sorted array, compare with the middle element and discard half each time: O(log n) time, O(1) space iteratively. Compute mid = lo + (hi - lo) / 2 to avoid overflow. Variants: first/last occurrence, search in a rotated array, lower bound.

Question 32

Design and implement an LRU cache with O(1) get and put.

Accepted Answer

In short: Combine a Dictionary key, LinkedListNode for O(1) lookup with a doubly LinkedList ordered by recency. On get: move the node to the front. On put: update and move to the front, or insert at the front. If over capacity, remove the last node and its dictionary entry. Thread safety: wrap in a lock or use per-key strategies. In production use MemoryCache with a size limit.

Question 33

You are given 10 million log lines and must find the top 10 most frequent IP addresses with limited memory. How?

Accepted Answer

In short: If the distinct IPs fit in memory: stream the file line by line ( File.ReadLines ), count in a Dictionary string,int , then keep a min-heap of size 10, O(n log 10). If not: partition by hash of the IP into N temp files so each file s distinct IPs fit in memory, count each file, and merge the per-file top-10s. For a stream with bounded error, use a Count-Min Sketch or the Space-Saving algorithm. In practice you d load the data into SQL/Kusto and `GROUP BY ... ORDER BY COUNT(*) DESC`.

Question 34

The interviewer says your O(n²) solution works — "can you do better?" What's your approach?

Accepted Answer

In short: Find the repeated work in the inner loop. Usual upgrades: (1) a hash map/set to replace an inner search, O(n²) → O(n); (2) sort + two pointers , O(n log n); (3) a sliding window for contiguous subarray/substring problems; (4) prefix sums for range sums; (5) a heap for top-K; (6) binary search on a sorted structure or on the answer; (7) memoisation/DP for overlapping subproblems. Say the trade-off (more memory for less time).

Question 35

What happens when you type a URL in the browser and press Enter?

Accepted Answer

In short: URL parsed → browser/OS caches checked → DNS resolves the host to an IP (resolver → root → TLD → authoritative) → TCP three-way handshake to port 443 (or QUIC for HTTP/3) → TLS handshake validates the certificate and sets up encryption → HTTP request sent with headers/cookies → CDN/load balancer/reverse proxy route it → web server and application handle it (auth, routing, controller, database) → HTTP response with status, headers, body → browser parses HTML into the DOM, loads CSS/JS/images, builds the render tree, lays out and paints the page; further requests reuse the connection.

Question 36

What is DNS and what are A, CNAME and MX records?

Accepted Answer

In short: DNS translates domain names to IP addresses through a hierarchy of servers with caching (TTL). An A record maps a name to an IPv4 address (AAAA for IPv6); a CNAME makes a name an alias of another name (e.g. www → shop.azurewebsites.net ); an MX record lists the mail servers for the domain. TXT records are used for verification and email security (SPF, DKIM, DMARC).

Question 37

What is the difference between HTTP and HTTPS?

Accepted Answer

In short: HTTPS is HTTP over TLS: the connection is encrypted (confidentiality), protected from tampering (integrity), and the server proves its identity with a certificate signed by a trusted certificate authority (authentication). Default ports 80 vs 443. HTTPS is required for modern browser features, SEO and any login or personal data.

Question 38

TCP vs UDP?

Accepted Answer

In short: TCP is connection-oriented and reliable: handshake, acknowledgements, retransmission, ordering, flow and congestion control — used for the web, databases, email. UDP is connectionless with no delivery guarantees but lower latency and overhead — used for DNS, voice/video, games and QUIC (HTTP/3), where the application handles reliability.

Question 39

What are the main HTTP methods and status codes?

Accepted Answer

In short: GET (read), POST (create/action), PUT (replace, idempotent), PATCH (partial update), DELETE (remove, idempotent), OPTIONS/HEAD. Status: 200 OK, 201 Created, 204 No Content, 301/302 redirects, 304 Not Modified, 400 Bad Request, 401 Unauthorized, 403 Forbidden, 404 Not Found, 409 Conflict, 429 Too Many Requests, 500 Internal Server Error, 502 Bad Gateway, 503 Service Unavailable, 504 Gateway Timeout.

Question 40

What is a load balancer? What algorithms does it use?

Accepted Answer

In short: A component that distributes incoming traffic across several servers for scalability and availability, using health probes to skip unhealthy instances. Algorithms: round robin, weighted round robin, least connections, IP hash/sticky sessions, least response time. Layer 4 balancers route by IP/port (fast); layer 7 balancers understand HTTP and can route by path, host or header and terminate TLS.

Question 41

What is a CDN and how does it improve performance?

Accepted Answer

In short: A Content Delivery Network caches content at edge servers around the world, so users download from a nearby location: lower latency, less load on the origin, protection against traffic spikes and DDoS, often a WAF and free TLS. Best for static assets with long cache headers and fingerprinted file names; dynamic content can also be accelerated.

Question 42

Forward proxy vs reverse proxy?

Accepted Answer

In short: A forward proxy acts for clients (they connect out through it — corporate filtering, anonymity). A reverse proxy acts for servers (clients connect to it and it forwards to backend servers — TLS termination, load balancing, caching, compression, hiding internal servers). Nginx, IIS ARR, YARP and Azure Application Gateway are reverse proxies.

Question 43

How is an ASP.NET Core app hosted on IIS?

Accepted Answer

In short: Install the .NET Hosting Bundle (runtime + ASP.NET Core Module). IIS receives requests via HTTP.sys and the app pool s w3wp.exe ; the ASP.NET Core Module runs the app in-process (inside w3wp, fastest) or out-of-process (proxying to Kestrel). The app pool uses No Managed Code ; web.config (generated on publish) configures the module; bindings and certificates are set in IIS.

Question 44

Users report your site is down, but it works on your machine. How do you troubleshoot?

Accepted Answer

In short: Check from outside (another network, downforeveryoneorjustme, mobile data). DNS: nslookup from different resolvers — wrong/expired record or propagation. Connectivity: Test-NetConnection host -Port 443 , firewall/NSG, load balancer health probes. TLS: expired certificate or missing intermediate (SSL Labs). Server: app pool/process running, logs (Event Viewer, stdout, Application Insights), 5xx errors, resource limits. Recent changes: deployment, certificate renewal, DNS edits. Your machine may use a cached DNS entry or hosts-file entry.

Question 45

After moving the site to a new server, some users still reach the old server for hours. Why?

Accepted Answer

In short: DNS caching: resolvers and clients cache the old A record until its TTL expires (and some ignore TTLs). Next time lower the TTL (e.g. to 300 s) a day before the move, then change the record, keep the old server running (or redirecting) until traffic drains, and raise the TTL afterwards.

Question 46

What is the difference between HLD and LLD?

Accepted Answer

In short: HLD shows the architecture of the whole system: components (clients, load balancers, services, databases, caches, queues, CDN), how they interact, data flow, scaling and failure handling. LLD details the inside of components: classes, interfaces, methods, design patterns, database tables and APIs. HLD answers what pieces and how they connect ; LLD answers how each piece is built .

Question 47

Vertical vs horizontal scaling?

Accepted Answer

In short: Vertical: give one machine more CPU/RAM — simple, no code change, but limited and a single point of failure. Horizontal: add more machines behind a load balancer — almost unlimited and fault tolerant, but services must be stateless and data must be replicated/partitioned. Typical path: scale up first, then out.

Question 48

What is caching? Explain cache-aside.

Accepted Answer

In short: Storing frequently read data in faster storage (memory/Redis/CDN) to reduce latency and database load. Cache-aside: on read, check the cache; on miss, read from the database and put the result in the cache with a TTL; on write, update the database and delete (or update) the cache key. Watch for stale data, stampedes and hot keys.

Question 49

What does a load balancer do?

Accepted Answer

In short: Distributes requests across multiple servers to increase capacity and availability, performs health checks to stop sending traffic to failed servers, and can terminate TLS and route by URL (L7). Algorithms: round robin, least connections, IP hash/consistent hashing, weighted.

Question 50

Explain the CAP theorem with examples.

Accepted Answer

In short: In a distributed system, during a network partition you can t have both strong consistency and full availability. CP systems reject or delay requests to avoid stale data (bank balances, configuration stores like etcd); AP systems keep answering and reconcile later (social feeds, DNS, carts in Dynamo-style stores). When there is no partition, the trade-off is latency vs consistency (PACELC).

Question 51

SQL or NoSQL — how do you choose?

Accepted Answer

In short: Start from the data and access patterns. SQL for structured, related data needing transactions, joins and constraints (orders, payments). NoSQL when you need massive horizontal scale for simple key-based access, flexible schemas, very high write throughput, or special models (documents, graphs, time-series). Many systems combine them: SQL as the source of truth, Redis cache, search index, blob storage.

Question 52

What is sharding? How do you choose a shard key?

Accepted Answer

In short: Splitting a dataset horizontally across multiple database nodes so each stores a subset, increasing capacity and throughput. A good shard key has high cardinality, spreads reads and writes evenly (no hot shard) and matches the main query pattern so most queries hit one shard (e.g. customer id for orders). Use consistent hashing or a directory to allow adding shards with minimal data movement.

Question 53

What is consistent hashing and why is it useful?

Accepted Answer

In short: Nodes and keys are placed on a hash ring; each key belongs to the next node clockwise. When a node is added or removed, only the keys between it and its neighbour move (~1/N of keys), unlike hash % N where almost all keys move. Virtual nodes (many points per server) spread load evenly. Used in distributed caches and databases (Dynamo, Cassandra) and load balancers.

Question 54

Why use a message queue in system design?

Accepted Answer

In short: To decouple services (the producer doesn t wait for or depend on the consumer being up), absorb traffic spikes (load levelling), process work asynchronously (emails, video encoding), retry failures with dead-letter queues, and fan out events to multiple subscribers. Consumers must be idempotent because delivery is at-least-once.

Question 55

Design a URL shortener (high level).

Accepted Answer

In short: Write API creates a short code (base62 of a unique id or random 7 chars with collision check) and stores code → long URL in a key-value store or SQL with a unique index; read path GET /{code} checks Redis, then the store, and returns a 301/302 redirect. Reads dominate (100:1) → cache and CDN/edge. Analytics: send click events to a queue/stream and aggregate asynchronously. Scale: shard by code; custom aliases, expiry and abuse checks as extras.

Question 56

Design a news feed. Push or pull?

Accepted Answer

In short: Fan-out on write pushes post ids into followers precomputed feeds (fast reads, expensive for celebrities); fan-out on read builds the feed at read time (cheap writes, slow reads). Use a hybrid: push for normal users, pull and merge for celebrity accounts. Store feeds in Redis lists, posts in a sharded store, media via CDN, use cursor pagination, and rank asynchronously.

Question 57

Your read-heavy API's database is at 90 % CPU. What steps do you take, in order?

Accepted Answer

In short: Measure the top queries first; add/fix indexes and remove N+1 queries; add caching (in-memory/Redis) for hot data and HTTP caching/CDN where possible; route reads to read replicas; reduce payloads with projection and paging; scale the database up as a quick fix; finally partition/shard if data or write volume demands it. Monitor after each step.

Question 58

A flash sale will bring 50× normal traffic for 10 minutes. How do you prepare?

Accepted Answer

In short: Load test beforehand; pre-scale and warm caches; serve static content from the CDN; put a virtual waiting room/queue in front of checkout; rate limit per user; make inventory reservation atomic (conditional update) to prevent overselling; move non-critical work (emails, analytics) to queues; use feature flags to switch off expensive features; monitor dashboards and have a rollback plan.

Question 59

How do you approach an LLD question?

Accepted Answer

Clarify requirements and scope → list use cases → find entities (nouns) and behaviours (verbs) → define relationships (composition, inheritance, interfaces) → draw a class diagram → apply SOLID and suitable patterns (Strategy, State, Factory, Observer) → write code for the main flows → discuss edge cases, concurrency, extensibility, testing and persistence.

Question 60

Composition vs inheritance — which do you prefer in LLD and why?

Accepted Answer

In short: Prefer composition ( has-a ) because it keeps classes small and flexible: behaviour can be swapped at runtime via interfaces (Strategy) and changes don t ripple through a hierarchy. Use inheritance only for genuine is-a relationships with shared behaviour and substitutability (Liskov). Deep inheritance trees become rigid and fragile.

Fundamentals: DSA, System Design & LLD — Interview Questions