Microsoft Interview Questions

Stack: automatic memory for local variables, LIFO allocation, fast, fixed size, deallocated when function returns. Heap: dynamic memory for objects, programmer-controlled (or garbage collected), slower, variable size, persists until explicitly freed. Stack overflow occurs when too much stack memory is used (e.g., deep recursion).

Polymorphism means "many forms." Compile-time (static): method overloading, operator overloading. Runtime (dynamic): method overriding using virtual functions. Example: Animal base class with speak() method, Dog and Cat override it differently. Enables writing code against interfaces, not implementations.

S: Single Responsibility - one reason to change. O: Open/Closed - open for extension, closed for modification. L: Liskov Substitution - subtypes must be substitutable. I: Interface Segregation - many specific interfaces over one general. D: Dependency Inversion - depend on abstractions, not concretions.

REST: multiple endpoints, fixed response structure, over/under-fetching issues, HTTP semantics. GraphQL: single endpoint, client specifies exact data needed, eliminates over-fetching, typed schema, requires more setup. Microsoft uses both; Azure has strong REST APIs while some newer services use GraphQL.

Garbage collection automatically reclaims unused memory. Types: Reference counting (counts references, cyclic reference issues), Mark-and-sweep (marks reachable objects, sweeps unmarked), Generational (objects in generations, young collected frequently). .NET uses generational GC with three generations; Java HotSpot uses G1GC.

Deadlock: circular wait where processes hold resources while waiting for others. Four conditions: mutual exclusion, hold and wait, no preemption, circular wait. Prevention: break any condition - lock ordering, timeout, try-lock with backoff, avoid holding multiple locks.

HTTP/1.1: text-based, one request per connection, head-of-line blocking. HTTP/2: binary framing, multiplexing, header compression, server push. HTTP/3: uses QUIC over UDP, faster handshakes, better mobile performance, no head-of-line blocking at transport layer. Azure optimizes for HTTP/2 and HTTP/3.

DI is passing dependencies to a class rather than creating them internally. Benefits: testability (mock dependencies), loose coupling, flexibility (swap implementations). Types: constructor injection (preferred), setter injection, interface injection. .NET Core has built-in DI container.

App Service: managed PaaS for web apps, easy deployment, auto-scaling. Azure Functions: serverless, event-driven, pay-per-execution, short-lived. AKS: managed Kubernetes, full container orchestration, complex but flexible. Choose based on: control needs, scaling patterns, cost model, existing containerization.

Authentication: verifying identity (who you are) - passwords, MFA, OAuth tokens. Authorization: verifying permissions (what you can do) - RBAC, claims, policies. Microsoft uses Azure AD for identity, supports OAuth 2.0, OpenID Connect. Always authenticate first, then authorize.

Structure: current role, key achievements, why transition to Microsoft. Research Microsoft's mission ("empower every person and organization") and connect it to your values. Mention specific products or initiatives that excite you - Azure, Windows, Teams, AI (Copilot).

Use STAR method focusing on technical and interpersonal challenges. Show problem-solving, collaboration, and learning. Microsoft values "growth mindset" - include what you learned and would do differently. Quantify impact where possible.

Describe a specific disagreement. Show: active listening, understanding their perspective, data-driven discussion, willingness to be wrong, commitment to the final decision. Microsoft values "disagree and commit" - constructive conflict leads to better outcomes.

Share a genuine failure, not a humble brag. Focus on: what happened, your accountability, what you learned, how you applied that learning. Microsoft's growth mindset culture values learning from failures. Show resilience and self-awareness.

Describe specific learning methods: online courses, documentation, side projects, conferences, communities. Give recent examples of technologies learned. Microsoft looks for lifelong learners who adapt to fast-changing tech landscape.

Focus on: understanding their perspective, finding common ground, professional communication, achieving results despite friction. Don't be negative about others. Microsoft values collaboration and "One Microsoft" culture.

Explain your framework: business impact, stakeholder needs, dependencies, quick wins vs long-term. Give a specific example. Show communication with stakeholders about tradeoffs. Microsoft operates at scale; prioritization is crucial.

Ask thoughtful questions: team culture, current challenges, tech stack, growth opportunities, how success is measured. Avoid salary/benefits in technical rounds. Show genuine curiosity about the role and opportunity to contribute.

// Iterative
function reverseListIterative(head) {
  let prev = null;
  let current = head;
  
  while (current) {
    const next = current.next;
    current.next = prev;
    prev = current;
    current = next;
  }
  
  return prev;
}

// Recursive
function reverseListRecursive(head) {
  if (!head || !head.next) return head;
  
  const newHead = reverseListRecursive(head.next);
  head.next.next = head;
  head.next = null;
  
  return newHead;
}

// Time: O(n), Space: O(1) iterative, O(n) recursive

// Using QuickSelect (average O(n))
function findKthLargest(nums, k) {
  const target = nums.length - k;
  
  function quickSelect(left, right) {
    const pivot = nums[right];
    let i = left;
    
    for (let j = left; j < right; j++) {
      if (nums[j] <= pivot) {
        [nums[i], nums[j]] = [nums[j], nums[i]];
        i++;
      }
    }
    
    [nums[i], nums[right]] = [nums[right], nums[i]];
    
    if (i === target) return nums[i];
    if (i < target) return quickSelect(i + 1, right);
    return quickSelect(left, i - 1);
  }
  
  return quickSelect(0, nums.length - 1);
}

// Average: O(n), Worst: O(n²)
// Alternative: Use min-heap of size k for O(n log k)

class TreeNode {
  constructor(val) {
    this.val = val;
    this.left = this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }
  
  insert(val) {
    const node = new TreeNode(val);
    if (!this.root) {
      this.root = node;
      return;
    }
    
    let current = this.root;
    while (true) {
      if (val < current.val) {
        if (!current.left) {
          current.left = node;
          return;
        }
        current = current.left;
      } else {
        if (!current.right) {
          current.right = node;
          return;
        }
        current = current.right;
      }
    }
  }
  
  search(val) {
    let current = this.root;
    while (current) {
      if (val === current.val) return true;
      current = val < current.val ? current.left : current.right;
    }
    return false;
  }
  
  // Delete: handle 3 cases (no child, one child, two children)
}

// Time: O(log n) average, O(n) worst for skewed tree

function detectCycle(head) {
  if (!head || !head.next) return null;
  
  let slow = head;
  let fast = head;
  
  // Detect cycle
  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next.next;
    
    if (slow === fast) {
      // Find cycle start
      slow = head;
      while (slow !== fast) {
        slow = slow.next;
        fast = fast.next;
      }
      return slow;
    }
  }
  
  return null;
}

// Floyd's Cycle Detection (Tortoise and Hare)
// Time: O(n), Space: O(1)

class MinStack {
  constructor() {
    this.stack = [];
    this.minStack = [];
  }
  
  push(val) {
    this.stack.push(val);
    
    if (!this.minStack.length || val <= this.getMin()) {
      this.minStack.push(val);
    }
  }
  
  pop() {
    const val = this.stack.pop();
    
    if (val === this.getMin()) {
      this.minStack.pop();
    }
    
    return val;
  }
  
  top() {
    return this.stack[this.stack.length - 1];
  }
  
  getMin() {
    return this.minStack[this.minStack.length - 1];
  }
}

// All operations O(1) time
// Space: O(n) for both stacks

function cloneGraph(node) {
  if (!node) return null;
  
  const visited = new Map();
  
  function dfs(original) {
    if (visited.has(original)) {
      return visited.get(original);
    }
    
    const copy = new Node(original.val);
    visited.set(original, copy);
    
    for (const neighbor of original.neighbors) {
      copy.neighbors.push(dfs(neighbor));
    }
    
    return copy;
  }
  
  return dfs(node);
}

// Map prevents infinite loops on cycles
// Time: O(V + E), Space: O(V)