Interview Q&A

public int EvaluateInfix(string expression) {

Stack<int> operands = new Stack<int>();

Stack<char> operators = new Stack<char>();

int i = 0;

while (i < expression.Length) {

if (char.IsWhiteSpace(expression[i])) {

i++;

continue;

if (char.IsDigit(expression[i])) {

int val = 0;

while (i < expression.Length &&

char.IsDigit(expression[i])) {

val = val * 10 + (expression[i] - '0');

i++;

operands.Push(val);

continue;

if (expression[i] == '(') {

operators.Push(expression[i]);

else if (expression[i] == ')') {

while (operators.Peek() != '(') {

ApplyOp(operands, operators);

operators.Pop(); // remove '('

Follow on:

else if (IsOperator(expression[i])) {

while (operators.Count > 0 &&

Precedence(operators.Peek()) >= Precedence(expression[i])) {

ApplyOp(operands, operators);

operators.Push(expression[i]);

i++;

while (operators.Count > 0) {

ApplyOp(operands, operators);

return operands.Pop();

bool IsOperator(char c) {

return c == '+' || c == '-' || c == '*' || c == '/';

int Precedence(char op) {

if (op == '+' || op == '-') return 1;

if (op == '*' || op == '/') return 2;

return 0;

void ApplyOp(Stack<int> operands, Stack<char> operators) {

int b = operands.Pop();

int a = operands.Pop();

char op = operators.Pop();

int result = 0;

switch (op) {

case '+': result = a + b; break;

case '-': result = a - b; break;

case '*': result = a * b; break;

Follow on:

case '/': result = a / b; break;

operands.Push(result);

Explanation:

Standard two-stack algorithm for evaluating infix expressions considering operator

precedence and parentheses.

ListNode ReverseBetween(ListNode head, int m, int n) {
if (head == null || m == n) return head;
ListNode dummy = new ListNode(0);
dummy.next = head;
ListNode prev = dummy;

// Move prev to one before m-th node

for (int i = 1; i < m; i++) prev = prev.next;
ListNode start = prev.next;
ListNode then = start.next;

// Reverse the sublist

for (int i = 0; i < n - m; i++) {

Follow on:

start.next = then.next;
then.next = prev.next;
prev.next = then;
then = start.next;
}
return dummy.next;
}

Explanation:

Use a dummy node to simplify edge cases. Reverse nodes between m and n by changing

pointers.

(Repeated here for convenience)

string LongestPalindrome(string s)
{
if (string.IsNullOrEmpty(s)) return "";
int start = 0, maxLen = 1;
for (int i = 0; i < s.Length; i++)
{

ExpandAroundCenter(s, i, i, ref start, ref maxLen);

ExpandAroundCenter(s, i, i + 1, ref start, ref maxLen);

}
return s.Substring(start, maxLen);
}

void ExpandAroundCenter(string s, int left, int right, ref int

start, ref int maxLen)

{

while (left >= 0 && right < s.Length && s[left] == s[right])

{

Follow on:

if (right - left + 1 > maxLen)
{
start = left;
maxLen = right - left + 1;
}

left--;

right++;

}
}

Answer: int LCM(int a, int b) { return a / GCD(a, b) * b; } Explanation: LCM × GCD = product of the two numbers.

What interviewers expect

• A clear definition tied to Coding in C# Coding Interview projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# Coding Interview application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# Coding Interview architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

void MergeSort(int[] arr, int left, int right)

if (left < right)

int mid = (left + right) / 2;

MergeSort(arr, left, mid);

MergeSort(arr, mid + 1, right);

Follow on:

Merge(arr, left, mid, right);

void Merge(int[] arr, int left, int mid, int right)

int n1 = mid - left + 1;

int n2 = right - mid;

int[] L = new int[n1];

int[] R = new int[n2];

Array.Copy(arr, left, L, 0, n1);

Array.Copy(arr, mid + 1, R, 0, n2);

int i = 0, j = 0, k = left;

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++];

Explanation:

Divide array, sort left & right halves, then merge sorted halves.

int Knapsack(int[] weights, int[] values, int W)
{
int n = weights.Length;
int[,] dp = new int[n + 1, W + 1];
for (int i = 1; i <= n; i++)
{
for (int w = 1; w <= W; w++)
{
if (weights[i - 1] <= w)

dp[i, w] = Math.Max(dp[i - 1, w], values[i - 1] +

dp[i - 1, w - weights[i - 1]]);

else

dp[i, w] = dp[i - 1, w];
}
}
return dp[n, W];
}

Explanation:

Build table where dp[i,w] = max value using first i items and capacity w.

Follow on:

Logic

• Convert to char array.
• Swap characters from both ends.

string str = "dotnet";
char[] chars = str.ToCharArray();
int left = 0, right = chars.Length - 1;

while (left < right)

{
char temp = chars[left];
chars[left] = chars[right];
chars[right] = temp;

left++;

right--;

}
string reversed = new string(chars);

public double Power(double x, int n) {
if (n == 0) return 1;
double half = Power(x, n / 2);
if (n % 2 == 0)
return half * half;

else

return n > 0 ? x * half * half : (half * half) / x;
}

Explanation:

Uses fast exponentiation (divide and conquer) to calculate x^n in O(log n).

t j

return IsMatchHelper(s, p, i, j + 2) ||

(firstMatch && IsMatchHelper(s, p, i + 1, j));

}

else

{
return firstMatch && IsMatchHelper(s, p, i + 1, j + 1);
}

Follow on:

}

Explanation:

Recursively matches strings supporting '.' (any char) and '*' (zero or more of preceding).

Answer: public bool HaveOppositeSigns(int x, int y) { return (x ^ y) &lt; 0; } Explanation: XOR of two numbers with opposite signs has the sign bit set (negative number).

What interviewers expect

• A clear definition tied to Coding in C# Coding Interview projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# Coding Interview application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# Coding Interview architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

public class NestedIterator {
private Queue<int> queue;
public NestedIterator(IList<NestedInteger> nestedList) {
queue = new Queue<int>();

Flatten(nestedList);

}
private void Flatten(IList<NestedInteger> nestedList) {
foreach (var ni in nestedList) {
if (ni.IsInteger()) queue.Enqueue(ni.GetInteger());

else Flatten(ni.GetList());

}
}
public bool HasNext() {
return queue.Count > 0;
}
public int Next() {
return queue.Dequeue();
}
}

Note:

NestedInteger is an interface with methods: IsInteger(), GetInteger(),

GetList().

Explanation:

Pre-flatten the nested list into a queue and iterate over it.

Follow on:

Answer: x * half * half : (half * half) / x; Explanation: Uses fast exponentiation (divide and conquer) to calculate x^n in O(log n).

What interviewers expect

• A clear definition tied to Coding in C# Coding Interview projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# Coding Interview application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# Coding Interview architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

public class MedianFinder {
private PriorityQueue<int, int> maxHeap; // lower half (max

heap)

Follow on:

private PriorityQueue<int, int> minHeap; // upper half (min

heap)

public MedianFinder() {

maxHeap = new PriorityQueue<int,

int>(Comparer<int>.Create((a, b) => b.CompareTo(a)));
minHeap = new PriorityQueue<int, int>();
}
public void AddNum(int num) {

maxHeap.Enqueue(num, num);

minHeap.Enqueue(maxHeap.Dequeue(), maxHeap.Peek());

if (maxHeap.Count < minHeap.Count)

maxHeap.Enqueue(minHeap.Dequeue(), minHeap.Peek());

}
public double FindMedian() {
if (maxHeap.Count > minHeap.Count)
return maxHeap.Peek();
return (maxHeap.Peek() + minHeap.Peek()) / 2.0;
}
}

Explanation:

Maintain two heaps: maxHeap for lower half, minHeap for upper half. Balance their sizes.

int HouseRobber(int[] nums) {
if (nums.Length == 0) return 0;
if (nums.Length == 1) return nums[0];
int prev1 = 0, prev2 = 0;
foreach (var num in nums) {
int temp = prev1;
prev1 = Math.Max(prev2 + num, prev1);
prev2 = temp;
}
return prev1;
}

public class Edge {
public int Source, Dest, Weight;
public Edge(int s, int d, int w) {
Source = s; Dest = d; Weight = w;
}
}
int[] BellmanFord(int vertices, List<Edge> edges, int source) {
int[] dist = new int[vertices];
for (int i = 0; i < vertices; i++) dist[i] = int.MaxValue;
dist[source] = 0;

Follow on:

for (int i = 1; i < vertices; i++) {
foreach (var edge in edges) {
if (dist[edge.Source] != int.MaxValue &&

dist[edge.Source] + edge.Weight < dist[edge.Dest]) {

dist[edge.Dest] = dist[edge.Source] + edge.Weight;
}
}
}

// Detect negative weight cycle (optional)

foreach (var edge in edges) {
if (dist[edge.Source] != int.MaxValue && dist[edge.Source] +

edge.Weight < dist[edge.Dest]) {

throw new Exception("Graph contains negative weight

cycle");

}
}
return dist;
}

Explanation:

Relax edges V-1 times, then check for negative weight cycles.

TreeNode prev = null;

void Flatten(TreeNode root) {

if (root == null) return;

Flatten(root.right);

Flatten(root.left);

root.right = prev;
root.left = null;
prev = root;
}

Explanation:

Postorder traversal (right-left-root) to flatten tree in place.

int[] NextGreaterElements(int[] nums) {
int n = nums.Length;
int[] result = new int[n];
Stack<int> stack = new Stack<int>();
for (int i = n - 1; i >= 0; i--) {

while (stack.Count > 0 && stack.Peek() <= nums[i]) {

stack.Pop();

}
result[i] = stack.Count == 0 ? -1 : stack.Peek();

stack.Push(nums[i]);

}
return result;
}

Explanation:

Traverse from right to left, use stack to keep track of next greater elements in O(n).

ListNode MergeKLists(ListNode[] lists) {
if (lists == null || lists.Length == 0) return null;

PriorityQueue<ListNode, int> pq = new PriorityQueue<ListNode,

int>();
foreach (var list in lists)
if (list != null)

pq.Enqueue(list, list.val);

ListNode dummy = new ListNode(0);
ListNode current = dummy;

while (pq.Count > 0) {

var node = pq.Dequeue();
current.next = node;
current = current.next;
if (node.next != null)

pq.Enqueue(node.next, node.next.val);

}
return dummy.next;
}

Follow on:

Explanation:

Use a min-heap (priority queue) to always pick the smallest head node among k lists.

bool IsMatch(string s, string p)

return IsMatchHelper(s, p, 0, 0);

bool IsMatchHelper(string s, string p, int i, int j)

if (j == p.Length) return i == s.Length;

bool firstMatch = (i < s.Length) && (p[j] == s[i] || p[j] ==

'.');

if (j + 1 < p.Length && p[j + 1] == '*')

// Two cases:

// 1) Use zero occurrence of p[j] (skip)

// 2) If firstMatch, consume one char in s and keep pattern

at j

return IsMatchHelper(s, p, i, j + 2) ||

(firstMatch && IsMatchHelper(s, p, i + 1, j));

else

return firstMatch && IsMatchHelper(s, p, i + 1, j + 1);

Follow on:

Explanation:

Recursively matches strings supporting '.' (any char) and '*' (zero or more of preceding).

List<List<int>> Subsets(int[] nums)
{
List<List<int>> result = new List<List<int>>();

GenerateSubsets(nums, 0, new List<int>(), result);

return result;
}

void GenerateSubsets(int[] nums, int index, List<int> current,

List<List<int>> result)
{
if (index == nums.Length)
{

result.Add(new List<int>(current));

return;
}

// Exclude nums[index]

GenerateSubsets(nums, index + 1, current, result);

// Include nums[index]

current.Add(nums[index]);

GenerateSubsets(nums, index + 1, current, result);

current.RemoveAt(current.Count - 1);

Follow on:

}

Explanation:

Backtracking approach includes/excludes each element.

bool IsPrime(int n)

{
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i += 6)
{
if (n % i == 0 || n % (i + 2) == 0)
return false;

Follow on:

}
return true;
}

Explanation:

Check divisibility by 2, 3, then test possible divisors of form 6k ± 1 up to √n.

int FirstOccurrence(int[] arr, int target)
{
int low = 0, high = arr.Length - 1, result = -1;

while (low <= high)

{
int mid = low + (high - low) / 2;
if (arr[mid] == target)
{
result = mid;

Follow on:

high = mid - 1; // search left side
}

else if (arr[mid] < target)

low = mid + 1;

else

high = mid - 1;
}
return result;
}

Explanation:

Binary search but continue left to find first occurrence.

int LCS(string s1, string s2)
{
int m = s1.Length, n = s2.Length;
int[,] dp = new int[m + 1, n + 1];
for (int i = 1; i <= m; i++)
{
for (int j = 1; j <= n; j++)
{
if (s1[i - 1] == s2[j - 1])
dp[i, j] = dp[i - 1, j - 1] + 1;

else

dp[i, j] = Math.Max(dp[i - 1, j], dp[i, j - 1]);
}
}
return dp[m, n];
}

Explanation:

Build DP table comparing chars; find longest subsequence common to both strings.

Follow on:

Logic

• Same length
• Same character frequency

bool IsAnagram(string s1, string s2)

{
if (s1.Length != s2.Length) return false;
int[] count = new int[256];
foreach (char c in s1) count[c]++;
foreach (char c in s2) count[c]--;
foreach (int i in count)
if (i != 0) return false;
return true;
}

Answer: = (a == null) ? headB : a.next; b = (b == null) ? headA : b.next; } return a; // either intersection or null } Explanation: Two pointers traverse both lists; if no intersection, both will reach null simultaneously.

What interviewers expect

• A clear definition tied to Coding in C# Coding Interview projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# Coding Interview application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# Coding Interview architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.