codementor

Code review publisher

Public Key

npub1u69qs4hfpkve0v0hy85s2fycjeqjm4ts8xdfs7ew3l270l87yfuspv0yg2

Profile Code

nprofile1qqswdzsg2m5smxvhk8mjr6g9yjvfvsfd64crnx5c0vhgl408lnlzy7gpzemhxue69uhhyetvv9ujuurjd9kkzmpwdejhgqgdwaehxw309ahx7uewd3hkcsr5gt0

Publishing to

Author Public Key

npub1u69qs4hfpkve0v0hy85s2fycjeqjm4ts8xdfs7ew3l270l87yfuspv0yg2

Show more details

Last Notes

2026-10-08 15:37:25 GMT

Learn: Starvation
Starvation: a thread is ready to work but never gets the resource or CPU time, because others keep taking it. Unlike a deadlock, the program still moves; one part just never does.
Classic example: a lock that is not fair. Monitor (lock) doesn't promise first come, first served, so under heavy use one thread can keep losing.
In .NET servers, a related problem is thread-pool starvation: blocking calls (.Result, .Wait()) hold pool threads, so new requests wait.
Read more: https://learn.microsoft.com/en-us/dotnet/standard/threading/managed-threading-best-practices
#tip · TIP-080

2026-10-05 14:07:22 GMT

- reply

Sort + two pointers: O(n log n) time, because of the sort (the docs call Array.Sort "an O(n log n) operation"). Little extra memory if you may sort in place, but the original indexes are lost.
Dictionary: O(n) time on average, O(n) extra memory, and it keeps the indexes.
If you need the indexes, or speed matters most, use the Dictionary.
Source: https://learn.microsoft.com/en-us/dotnet/api/system.array.sort
#arr004 · ARR-004-A2

2026-10-05 14:07:22 GMT

Question: The array is NOT sorted. You need two numbers that add up to a target. Compare: sort it and use two pointers, or use a Dictionary. What does each cost?
Try to answer before you open the reply.
#arr004 · ARR-004-Q2

2026-10-05 11:37:23 GMT

Learn: Bubble sort
What: walk the array and swap neighbors that are in the wrong order; repeat until nothing moves. The biggest item "bubbles" to the end each pass.
Cost: O(n²). With an early stop when a pass makes no swap, O(n) on already sorted data.
Use it when: teaching, or tiny arrays. In real code use Array.Sort, which is O(n log n).
```csharp
int[] a = { 5, 1, 4, 2 };
for (int end = a.Length - 1; end > 0; end--)
{
bool swapped = false;
for (int i = 0; i < end; i++)
if (a[i] > a[i + 1]) { (a[i], a[i + 1]) = (a[i + 1], a[i]); swapped = true; }
if (!swapped) break; // already sorted: stop early
}
Console.WriteLine(string.Join(" ", a));
```
It prints 1 2 4 5.
Read more: https://www.geeksforgeeks.org/dsa/bubble-sort-algorithm/
#tip · TIP-035

2026-10-05 11:07:18 GMT

Learn: Interface or abstract class?
Interface: a contract with no instance fields (since C# 8 it can have default method bodies). Many per class. Best for "can do": IComparable, IDisposable, services you inject.
Abstract class: a partial implementation. Only one base class. Best for "is a" families that share code and state.
A common interview answer: start with an interface; add an abstract base class when several implementations repeat the same code.
#tip · TIP-050

2026-10-05 10:37:20 GMT

Learn: SOLID in one post
S: Single responsibility. One class, one reason to change.
O: Open/closed. Add behavior with new code, not by editing working code.
L: Liskov substitution. A subclass must work anywhere its base class works.
I: Interface segregation. Many small interfaces beat one huge one.
D: Dependency inversion. Depend on interfaces, not concrete classes (this is what DI makes easy).
In an interview, give one real example for each letter you mention.
Read more: https://roadmap.sh/software-design-architecture
#tip · TIP-071

2026-10-05 10:07:28 GMT

- reply

A 0 you just wrote looks exactly like an original 0. When the scan reaches it, it clears another row and column, and soon everything is 0.
Fix: first record which rows and columns have a zero, then clear them in a second pass.
```csharp
int[,] m = { { 1, 2, 3 }, { 4, 0, 6 }, { 7, 8, 9 } };
int rows = m.GetLength(0), cols = m.GetLength(1);
var zeroRow = new bool[rows]; var zeroCol = new bool[cols];
for (int i = 0; i < rows; i++)
for (int j = 0; j < cols; j++)
if (m[i, j] == 0) { zeroRow[i] = true; zeroCol[j] = true; }
for (int i = 0; i < rows; i++)
for (int j = 0; j < cols; j++)
if (zeroRow[i] || zeroCol[j]) m[i, j] = 0;
Console.WriteLine(string.Join(" ", m.Cast<int>()));
```
It prints 1 0 3 0 0 0 7 0 9: row 2 and column 2 are cleared.
#arr012 · ARR-012-A1

2026-10-05 10:07:28 GMT

Question: In a matrix, if a cell is 0, set its whole row and whole column to 0.
Why is it a bug to write the zeros while you are still scanning for zeros? How do you fix it?
(CtCI 1.8)
Try to answer before you open the reply.
#arr012 · ARR-012-Q1

2026-10-05 09:37:28 GMT

Learn: The three pattern families
Creational: how objects get created. Singleton, Factory, Builder.
Structural: how objects are put together. Decorator, Adapter, Facade.
Behavioral: how objects talk and share work. Strategy, Observer, Command.
In an interview, don't just name a pattern: say the problem it solves and where you used it.
Read more: https://www.geeksforgeeks.org/system-design/software-design-patterns/
#tip · TIP-056

2026-10-05 08:37:17 GMT

Learn: PriorityQueue for "smallest first"
.NET has PriorityQueue<TElement, TPriority>. Dequeue always returns the item with the lowest priority value.
```csharp
var pq = new PriorityQueue<string, int>();
pq.Enqueue("low", 5); pq.Enqueue("urgent", 1); pq.Enqueue("mid", 3);
Console.WriteLine(pq.Dequeue());
```
It prints urgent. Use it for "top k" problems, merging k sorted lists, and Dijkstra's shortest path.
#tip · TIP-011

2026-10-05 08:07:30 GMT

Question: In the one-edit-away check, why can you return false right away when the lengths differ by 2 or more?
Try to answer before you open the reply.
#arr009 · ARR-009-Q2

2026-10-05 07:37:37 GMT

- reply

Learn: Designing a URL shortener
A step-by-step way to answer the classic system design question: requirements, API, short codes, storage, caching and scaling.
Read the full article: #naddr1qq…sdme
#tip · TIP-022

2026-10-05 07:07:19 GMT

Learn: Costs worth knowing by heart
Read array[i]: O(1)
Search an unsorted array: O(n)
Sort: O(n log n)
HashSet or Dictionary lookup: O(1) on average
Search a sorted array with binary search: O(log n)
When you state a solution in an interview, say its Big-O with it.
#tip · TIP-005

2026-10-05 06:07:31 GMT

- reply

Yes. Give each letter one bit of the int, and flip that bit every time the letter appears. At the end, a bit is 1 exactly when its letter has an odd count.
```csharp
Console.WriteLine(CanBePalindrome("carrace"));
static bool CanBePalindrome(string s)
{
int bits = 0;
foreach (char c in s) bits ^= 1 << (c - 'a'); // flip this letter's bit
return (bits & (bits - 1)) == 0; // at most one bit is set
}
```
It prints True. bits & (bits - 1) clears the lowest 1 bit, so the result is 0 only when at most one bit was set. O(n) time, O(1) memory.
#arr008 · ARR-008-A2

2026-10-05 06:07:31 GMT

Interviewer's follow-up: "The string has only the letters a to z. Can you solve it with a single int instead of a Dictionary?"
Try to answer before you open the reply.
#arr008 · ARR-008-Q2

2026-10-05 05:37:19 GMT

Learn: Thread-safe collections
List<T> and Dictionary<K, V> are not safe to change from several threads at once. For shared data use System.Collections.Concurrent: ConcurrentDictionary and ConcurrentQueue.
```csharp
var hits = new ConcurrentDictionary<string, int>();
Parallel.For(0, 1000, _ => hits.AddOrUpdate("home", 1, (_, n) => n + 1));
Console.WriteLine(hits["home"]);
```
It prints 1000: no update is lost. But your update function may run more than once, so keep it free of side effects. And hits["home"]++ is NOT safe: it is a read and a write.
Read more: https://learn.microsoft.com/en-us/dotnet/api/system.collections.concurrent.concurrentdictionary-2
#tip · TIP-081

2026-10-04 18:37:22 GMT

Learn: The middleware pipeline
Every request passes through a chain of middleware, in the order you add them in Program.cs, and the response comes back through them in reverse.
Each one can do work, then call the next, or stop the chain (short-circuit), like the static files middleware returning a file.
app.Use(...) adds a step that can call next; app.Run(context => ...) adds a final step (not the app.Run() that starts the server).
Order matters: exception handling first, then HTTPS, static files, routing, authentication, authorization, endpoints.
Read more: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/middleware/
#tip · TIP-095

2026-10-04 18:07:32 GMT

Learn: 2D arrays in C#
int[,] is a grid with rows and columns. Read a cell with m[row, column]. GetLength(0) is the number of rows and GetLength(1) the number of columns.
```csharp
int[,] m = { { 1, 2, 3 }, { 4, 5, 6 } };
Console.WriteLine($"{m.GetLength(0)} rows, {m.GetLength(1)} columns, m[1, 2] = {m[1, 2]}");
```
It prints 2 rows, 3 columns, m[1, 2] = 6. Indexes start at 0, so m[1, 2] is row 2, column 3. m.Length is the total number of cells, here 6.
There is also int[][], an array of arrays, where each row is its own array and rows can have different lengths.
#arr011 · ARR-011-N

2026-10-04 17:37:21 GMT

Learn: Never change a key while it is in a HashSet
A HashSet or Dictionary files each key by its hash code. If the key changes, its hash code changes, and the set looks in the wrong place.
```csharp
var p = new Point { X = 1 };
var set = new HashSet<Point> { p };
p.X = 2; // changes p's hash code
Console.WriteLine(set.Contains(p));
```
It prints False, even though p is in the set. Use keys that can't change, like strings, numbers or records without setters.
#tip · TIP-012

2026-10-04 17:07:34 GMT

Learn: The Lock type (.NET 9+)
.NET 9 added System.Threading.Lock, a type made only for locking, and lighter than locking on a plain object.
With the .NET 10 SDK it works in async methods too (older compilers may reject this), as long as there is no await inside the lock block:
```csharp
var gate = new Lock();
await Task.Yield();
lock (gate) { Console.WriteLine("inside"); }
```
It prints inside. An await inside the block is error CS1996, just like with any lock:
```csharp
var gate = new Lock();
lock (gate) { await Task.Delay(1); }
```
Need to await while holding a lock? Use SemaphoreSlim.
Read more: https://learn.microsoft.com/en-us/dotnet/api/system.threading.lock
#tip · TIP-075

2026-10-04 16:37:29 GMT

Learn: Sharding splits data by a key
When one database is too big or too busy, split the data across several databases (shards), for example by user ID.
The risk is a hot shard: if one key gets most of the traffic, one shard does most of the work. Choose a key that spreads load evenly.
#tip · TIP-016

2026-10-04 16:07:18 GMT

- reply

So that a range starting at index 0 needs no special case. The sum from index 0 to j is prefix[j + 1] - prefix[0], and prefix[0] is 0.
Without it, you would need an if for ranges that start at 0.
#arr003 · ARR-003-A2

2026-10-04 15:30:09 GMT

Learn: Repository and Unit of Work
Repository: hides data access behind an interface like IOrderRepository with GetById and Add, so the rest of the code doesn't know about SQL.
Unit of Work: collects changes and saves them together in one transaction.
Interview point: in EF Core, a DbSet already acts like a repository and the DbContext like a unit of work (SaveChanges). Add your own repository when you want to hide EF Core or make testing easier, not by habit.
Read more: https://www.geeksforgeeks.org/system-design/software-design-patterns/
#tip · TIP-070

2026-10-04 15:07:22 GMT

Bug hunt: This Two Sum should print the indexes of two numbers that add up to 10. The right answer is 1 2 (1 + 9).
```csharp
int[] a = { 5, 1, 9 };
int target = 10;
var seen = new Dictionary<int, int>();
for (int i = 0; i < a.Length; i++)
{
seen[a[i]] = i;
if (seen.TryGetValue(target - a[i], out int j))
{ Console.WriteLine($"{j} {i}"); break; }
}
```
What does it print, and which line causes the bug?
Try to answer before you open the reply.
#arr015 · ARR-015-Q1

2026-10-04 15:07:22 GMT

- reply

It prints 0 0.
The line seen[a[i]] = i; runs before the check. At i = 0 it stores 5, then looks for 10 - 5 = 5 and finds the 5 it just stored. The same item is used twice.
Fix: check first, then add.
```csharp
int[] a = { 5, 1, 9 };
int target = 10;
var seen = new Dictionary<int, int>();
for (int i = 0; i < a.Length; i++)
{
if (seen.TryGetValue(target - a[i], out int j))
{ Console.WriteLine($"{j} {i}"); break; }
seen[a[i]] = i;
}
```
It prints 1 2. Now the Dictionary holds only earlier items, so an item can't pair with itself.
#arr015 · ARR-015-A1

2026-10-04 14:37:19 GMT

Learn: Race condition
When two threads read and write the same data at once, the result depends on who gets there first. count++ looks like one step, but it is read, add, write: two threads can read the same old value and one update is lost.
```csharp
int count = 0;
Parallel.For(0, 100_000, _ => Interlocked.Increment(ref count));
Console.WriteLine(count);
```
It prints 100000 every time. With plain count++ it can print less. Fixes: Interlocked for simple counters, lock for more.
Read more: https://learn.microsoft.com/en-us/dotnet/standard/threading/managed-threading-best-practices
#tip · TIP-073

2026-10-04 14:07:30 GMT

Question: Rewrite the recursive Sum(n) with a loop. What is its space complexity now?
Try to answer before you open the reply.
#big003 · BIG-003-Q2

2026-10-04 14:07:30 GMT

- reply

```csharp
int total = 0;
for (int i = 1; i <= 5; i++) total += i;
Console.WriteLine(total);
```
It prints 15, like the recursive version.
Space: O(1). There is one running total and one counter, and no calls wait on the stack. Time is still O(n).
That matters in .NET: a stack overflow can't be caught, it ends the whole process.
#big003 · BIG-003-A2

2026-10-04 13:37:30 GMT

Learn: Strings
What: a sequence of characters. In C# a string can't change: every "change" makes a new string.
Interview favorites: reverse, palindrome, anagram, count characters, longest substring.
Tip: turn it into a char[] to change it in place, or use StringBuilder to build it.
```csharp
string s = "hello";
char[] a = s.ToCharArray();
Array.Reverse(a);
Console.WriteLine(new string(a));
```
It prints olleh.
Read more: https://www.geeksforgeeks.org/dsa/string-data-structure/
#tip · TIP-029

2026-10-04 13:07:26 GMT

Learn: Async mistakes interviewers ask about
async void: exceptions can't be caught by the caller and can crash the app. Use async Task (only event handlers are async void).
.Result or .Wait() in a request: blocks a pool thread; under load, thread-pool starvation.
Ignoring CancellationToken: when the user leaves, the work keeps running. Pass the request's token down.
Task.Run in a controller: moves work to another pool thread and gains nothing.
Read more: https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/
#tip · TIP-068

2026-10-04 12:37:28 GMT

Learn: Task vs Thread
A Thread is an operating system thread: expensive to create, and it holds memory the whole time.
A Task is a promise of a result. CPU work started with Task.Run runs on a shared pool of threads. A task waiting for I/O (a web call, a database) holds no thread at all while it waits.
In modern C#, use Task and async/await; create a Thread yourself only for rare long-running, dedicated work.
Read more: https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-based-asynchronous-programming
#tip · TIP-045

2026-10-04 12:07:24 GMT

Question: Rotate a square n×n matrix 90 degrees clockwise, in place.
(CtCI 1.7)
Try to answer before you open the reply.
#arr011 · ARR-011-Q1

2026-10-04 12:07:24 GMT

- reply

Step 1: transpose. Swap m[i, j] with m[j, i], so rows become columns. Step 2: reverse each row.
```csharp
int[,] m = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
int n = m.GetLength(0);
for (int i = 0; i < n; i++) // 1. transpose
for (int j = i + 1; j < n; j++) (m[i, j], m[j, i]) = (m[j, i], m[i, j]);
for (int i = 0; i < n; i++) // 2. reverse each row
for (int j = 0; j < n / 2; j++) (m[i, j], m[i, n - 1 - j]) = (m[i, n - 1 - j], m[i, j]);
for (int i = 0; i < n; i++)
Console.WriteLine(string.Join(" ", Enumerable.Range(0, n).Select(j => m[i, j])));
```
It prints 7 4 1 / 8 5 2 / 9 6 3.
Time O(n²), extra memory O(1): swaps only.
#arr011 · ARR-011-A1

2026-10-04 11:07:27 GMT

Learn: Test your code by hand
When your code is written, don't just say "done". Walk through it with a small example, line by line, and say the values out loud.
Then try the edge cases: an empty input, one item, and all items the same. Most bugs show up in these three.
#tip · TIP-004

2026-10-04 10:03:48 GMT

Question: Compress a string by writing each letter with how many times it repeats in a row. "aaabccdddd" becomes "a3b1c2d4". If the result is not shorter, return the original.
In C#, what should you use to build the result, and why?
(CtCI 1.6)
Try to answer before you open the reply.
#arr010 · ARR-010-Q1

2026-10-04 10:03:48 GMT

- reply

A StringBuilder. It adds characters into spare room instead of creating a new string each time.
```csharp
Console.WriteLine(Compress("aaabccdddd"));
Console.WriteLine(Compress("abc"));
static string Compress(string s)
{
var sb = new StringBuilder();
for (int i = 0, run = 1; i < s.Length; i++, run++)
if (i + 1 == s.Length || s[i] != s[i + 1]) { sb.Append(s[i]).Append(run); run = 0; }
return sb.Length < s.Length ? sb.ToString() : s;
}
```
It prints a3b1c2d4, then abc ("a1b1c1" would be longer).
The docs warn that because strings are immutable, repeated additions "can exact a significant performance penalty".
Source: https://learn.microsoft.com/en-us/dotnet/api/system.string
#arr010 · ARR-010-A1

2026-10-04 09:37:30 GMT

Learn: SemaphoreSlim, the async-friendly lock
A semaphore lets up to N callers in at a time. With N = 1 it is a lock that works with await.
```csharp
var gate = new SemaphoreSlim(1, 1); // one caller at a time, and it works with await
await gate.WaitAsync();
try { await Task.Delay(10); Console.WriteLine("saved"); }
finally { gate.Release(); }
```
It prints saved. Always release in finally.
Use it to protect code that awaits, or to limit concurrency: new SemaphoreSlim(5, 5) for "at most 5 downloads" (give both numbers, or an extra Release raises the limit). It is not reentrant: if the same caller calls WaitAsync again before Release, it waits forever. WaitAsync can also take a CancellationToken.
Read more: https://learn.microsoft.com/en-us/dotnet/standard/threading/overview-of-synchronization-primitives
#tip · TIP-077

2026-10-04 09:07:32 GMT

- reply

Learn: Data structures: which one when?
A one-page cheat sheet: what each basic data structure is good at, what it costs, and the C# type to use.
Read the full article: #naddr1qq…ytq7
#tip · TIP-032

2026-10-04 08:37:30 GMT

Learn: EF Core essentials
IQueryable vs IEnumerable: filter an IQueryable (db.Orders.Where(...)) and EF turns it into SQL. Call ToList() first and the filter runs in memory, after loading every row.
N+1 problem: load 100 orders, then query each order's customer inside a loop (or let lazy loading do it, if you turned it on) and you get 1 + 100 queries. Load them together with Include(o => o.Customer).
AsNoTracking(): for read-only queries, skip change tracking; it is faster.
Read more: https://learn.microsoft.com/en-us/ef/core/performance/efficient-querying
#tip · TIP-094

2026-10-04 08:07:56 GMT

Question: In the counting solution, why check the lengths first? And why is it enough to look for a count below zero?
Try to answer before you open the reply.
#arr006 · ARR-006-Q2

2026-10-04 08:07:56 GMT

- reply

Strings with different lengths can't have the same letters, so the answer is false at once.
With equal lengths, the second string subtracts exactly as much as the first one added. If no count ever goes below zero, then no count can be left above zero either. So every count ends at zero.
#arr006 · ARR-006-A2

2026-10-04 07:37:35 GMT

Learn: Scale up or scale out
Scale up (vertical): a bigger machine. Simple, but there is a limit, and it is still one machine that can fail.
Scale out (horizontal): more machines behind a load balancer. No hard limit, but the app must not keep user state on one server.
#tip · TIP-014

2026-10-04 07:07:19 GMT

Learn: Array
What: items stored side by side in memory, each at an index.
Cost: read or write a[i] in O(1); insert or delete in the middle O(n), because items must shift.
Use it when: you know the size, you read by position a lot, or you loop over everything.
```csharp
int[] a = { 10, 20, 30 };
Console.WriteLine(a[1]);
var list = new List<int>(a) { 40 };
Console.WriteLine(list.Count);
```
It prints 20, then 4. In C#, int[] has a fixed size; List<T> is an array that grows.
Read more: https://www.geeksforgeeks.org/dsa/array-data-structure-guide/
#tip · TIP-023

2026-10-04 06:37:28 GMT

Learn: Value types vs reference types
A value type (struct, int, bool, DateTime) holds its data directly; assigning it makes a copy.
A reference type (class, string, arrays) holds a reference; two variables can point to the same object.
```csharp
var p1 = new PointStruct { X = 1 }; var p2 = p1; p2.X = 9;
var c1 = new PointClass { X = 1 }; var c2 = c1; c2.X = 9;
Console.WriteLine($"{p1.X} {c1.X}");
struct PointStruct { public int X; }
class PointClass { public int X; }
```
It prints 1 9: changing the copied struct didn't touch the original, but both class variables see the change.
Boxing: putting a value type into an object (object o = 5) copies it to the heap. It is slower, so avoid it in hot loops.
Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/value-types
#tip · TIP-100

2026-10-04 06:07:33 GMT

Interviewer's follow-up: "Now solve it without a HashSet or any other extra data structure."
What can you do, and what does it cost?
Try to answer before you open the reply.
#arr005 · ARR-005-Q2

2026-10-04 05:37:16 GMT

Learn: Backtracking
Backtracking tries every choice step by step: choose, go deeper, then undo and try the next choice. Use it for "all possible" questions: subsets, permutations, sudoku, n-queens.
```csharp
var result = new List<string>();
var chosen = new List<char>();
Build(new[] { 'a', 'b', 'c' }, 0);
Console.WriteLine(string.Join(" ", result));
void Build(char[] items, int i)
{
if (i == items.Length) { result.Add($"[{string.Concat(chosen)}]"); return; }
chosen.Add(items[i]); Build(items, i + 1); chosen.RemoveAt(chosen.Count - 1); // choose, go deeper, undo
Build(items, i + 1); // skip it
}
```
It prints all 8 subsets of a, b, c. Each item is taken or skipped, so n items give 2ⁿ results. Pruning makes it faster in practice: stop early as soon as a partial choice can't work.
Read more: https://www.geeksforgeeks.org/dsa/recursion-algorithms/
#tip · TIP-098

2026-10-04 05:07:23 GMT

Learn: Bitwise tricks
Operators: & (and), | (or), ^ (xor), ~ (not), << and >> (shift).
```csharp
int n = 12; // 1100 in binary
Console.WriteLine(n & 1);
Console.WriteLine((n & (n - 1)) == 0);
Console.WriteLine(5 ^ 3 ^ 5);
Console.WriteLine(1 << 4);
```
n & 1 is 0 for even numbers. n > 0 && (n & (n - 1)) == 0 is true only for powers of two (.NET also has int.IsPow2). x ^ x is 0, so xor finds the one number without a pair. 1 << 4 is 16.
Use them for flags, compact sets of booleans, and these classic interview tricks.
Read more: https://www.geeksforgeeks.org/dsa/bitwise-algorithms/
#tip · TIP-042

2026-10-03 18:37:29 GMT

- reply

Learn: Concurrency in .NET: which tool when
A one-page map of .NET's concurrency tools, with the bugs each one prevents.
Read the full article: #naddr1qq…myvr
#tip · TIP-082

2026-10-03 18:07:29 GMT

Learn: Three kinds of edits
Edit problems use three operations:
Insert: "cat" to "cart" (add r).
Remove: "cat" to "at" (remove c).
Replace: "cat" to "cut" (a becomes u).
An insert makes a string 1 longer, a remove makes it 1 shorter, and a replace keeps its length. Comparing the lengths first often tells you which edit could have happened.
#arr009 · ARR-009-N

2026-10-03 17:34:56 GMT

Learn: Caching in one breath
A cache keeps a copy of slow data (like a database result) somewhere fast (like memory). Reads get much faster.
The hard part is staleness: when the real data changes, the copy is wrong. Common answers: an expiry time (TTL), or deleting the cached copy on every write.
#tip · TIP-013

2026-10-03 17:07:28 GMT

Learn: Matrix
What: a grid of rows and columns; m[row, col] reads one cell.
Cost: visiting every cell is O(rows × cols).
Use it when: data is naturally a grid: images, game boards, maps, seating plans, or a table of results in dynamic programming.
```csharp
int[,] grid = { { 1, 2 }, { 3, 4 } };
int sum = 0;
foreach (int x in grid) sum += x;
Console.WriteLine($"{grid.GetLength(0)}x{grid.GetLength(1)}, sum {sum}");
```
It prints 2x2, sum 10. Common interview moves: walk row by row, walk the diagonal, rotate, or spiral.
Read more: https://www.geeksforgeeks.org/dsa/matrix/
#tip · TIP-025

2026-10-03 16:37:19 GMT

Learn: Queue
What: first in, first out, like a line at a shop. Enqueue at the back (amortized O(1)), Dequeue from the front in O(1).
Use it when: work must be handled in arrival order: breadth-first search, task and print queues, messages between services.
```csharp
var line = new Queue<string>(new[] { "Ann", "Ben", "Cho" });
line.Enqueue("Dan");
Console.WriteLine($"{line.Dequeue()} is served, {line.Count} waiting");
```
It prints Ann is served, 3 waiting.
Read more: https://www.geeksforgeeks.org/dsa/queue-data-structure/
#tip · TIP-028

2026-10-03 15:07:27 GMT

- reply

n adds cost O(n²) in total, so one Add is O(n) on average.
A copy now happens every 100 adds, and each copy moves all items so far: 100 + 200 + 300 + ... up to n. That is about n²/200 items.
```csharp
int n = 10_000;
long byPlus100 = 0, byDoubling = 0;
for (int cap = 100; cap < n; cap += 100) byPlus100 += cap; // each full array is copied
for (int cap = 4; cap < n; cap *= 2) byDoubling += cap;
Console.WriteLine($"+100: {byPlus100} copies, x2: {byDoubling} copies");
```
It prints +100: 495000 copies, x2: 16380 copies. For n = 10,000, n²/200 is 500,000, but 2n is only 20,000.
With doubling, the copies are 4 + 8 + 16 + ..., which stays under 2n. That is why only multiplying the size gives amortized O(1).
#big012 · BIG-012-A1

2026-10-03 15:07:27 GMT

Interviewer's follow-up: "Your list does not double. When it is full, it grows by 100 slots. What do n adds cost in total now? And one Add on average?"
Try to answer before you open the reply.
#big012 · BIG-012-Q1

2026-10-03 14:07:26 GMT

Question: Two Sum with a Dictionary uses O(n) extra memory. When would you use two pointers instead?
Try to answer before you open the reply.
#arr002 · ARR-002-Q2

2026-10-03 14:07:26 GMT

- reply

When the array is already sorted. Then two pointers from both ends find the pair in O(n) time with O(1) memory.
If the array is not sorted, sorting first costs O(n log n), and you lose the original indexes unless you sort (value, index) pairs. So the Dictionary is usually better.
#arr002 · ARR-002-A2

2026-10-03 13:37:33 GMT

Learn: What a load balancer does
It spreads incoming requests over several servers, and stops sending traffic to a server that fails its health check.
Simple strategies: round robin (take turns) or least connections (send to the least busy server). In an interview, mention health checks and what happens when a server dies.
#tip · TIP-015

2026-10-03 13:07:21 GMT

Learn: Linear search
What: check the items one by one until you find the target.
Cost: O(n) in the worst case, O(1) extra memory.
Use it when: the data is not sorted, is small, or you search only once. Sorting first costs O(n log n), more than one linear search.
```csharp
int[] a = { 7, 3, 9, 1 };
Console.WriteLine(Array.IndexOf(a, 9));
Console.WriteLine(Array.IndexOf(a, 5));
```
It prints 2, then -1 (not found). Array.IndexOf and List<T>.Contains are linear searches.
Read more: https://www.geeksforgeeks.org/dsa/linear-search/
#tip · TIP-033

2026-10-03 12:37:23 GMT

2026-10-03 12:07:30 GMT

Question: You will add 1000 items to a list. What is the difference between new List<int>(1000) and new List<int>()?
Try to answer before you open the reply.
#big002 · BIG-002-Q2

2026-10-03 12:07:30 GMT

- reply

new List<int>(1000) makes room for 1000 items at the start, so no Add ever has to copy the array.
```csharp
var list = new List<int>(1000);
for (int i = 0; i < 1000; i++) list.Add(i);
Console.WriteLine(list.Capacity);
```
It prints 1000: the list never grew. The docs say "If Count is less than Capacity, this method is an O(1) operation."
Source: https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.list-1.add
#big002 · BIG-002-A2

2026-10-03 11:37:18 GMT

Learn: The lock statement
lock lets only one thread at a time run a block of code; the others wait.
```csharp
var sync = new object();
int total = 0;
Parallel.For(0, 1000, i => { lock (sync) total += i; });
Console.WriteLine(total);
```
It prints 499500 (0 + 1 + ... + 999) every time. On a plain object, lock is Monitor.Enter/Exit in a try/finally, so it is released even when an exception is thrown, and the same thread may enter it again (it is reentrant).
Rules: lock on a private object, never on this, a string or a type. Keep the block short. You can't await inside a lock.
Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/lock
#tip · TIP-074

2026-10-03 09:37:30 GMT

Learn: Binary search tree (BST)
What: a binary tree where everything left of a node is smaller and everything right is bigger.
Cost: search and insert are O(log n) when the tree is balanced, but O(n) if it becomes a long chain.
Use it when: you need data kept in sorted order while you add and remove, or ranges like "all values between 10 and 50".
```csharp
var set = new SortedSet<int> { 50, 20, 80, 10 };
Console.WriteLine(string.Join(" ", set));
Console.WriteLine(set.Min);
```
It prints 10 20 50 80, then 10. In C#: SortedSet<T> and SortedDictionary<K, V>.
Read more: https://www.geeksforgeeks.org/dsa/binary-search-tree-data-structure/
#tip · TIP-031

2026-10-03 09:07:23 GMT

2026-10-03 08:37:29 GMT

Learn: Interface
An interface is a contract: members a class must provide. It can't hold instance data (no fields); since C# 8 it may give a method a default body.
A class can implement many interfaces.
Use it when: different classes should be usable the same way, for DI and testing with fakes, or plug-ins.
```csharp
IShape[] shapes = { new Square(2), new Circle(1) };
foreach (var s in shapes) Console.WriteLine(s.Area().ToString("0.00"));
interface IShape { double Area(); }
record Square(double Side) : IShape { public double Area() => Side * Side; }
record Circle(double R) : IShape { public double Area() => Math.PI * R * R; }
```
It prints 4.00, then 3.14.
Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/interface
#tip · TIP-048

2026-10-03 08:07:19 GMT

Question: Two strings are "one edit away" if a single insert, remove or replace turns one into the other. Zero edits also counts.
"cat" and "cart": yes. "cat" and "dog": no. How do you check this in O(n)?
(CtCI 1.5)
Try to answer before you open the reply.
#arr009 · ARR-009-Q1

2026-10-03 07:37:19 GMT

- reply

Learn: Tree traversals
The four ways to visit a tree, when each one is useful, and how much memory they need.
Read the full article: #naddr1qq…fpl9
#tip · TIP-064

2026-10-03 07:04:05 GMT

2026-10-03 06:37:21 GMT

Learn: Two pointers
Two indexes walk the data instead of nested loops. Two common shapes:
From both ends of a sorted array, to find a pair with a given sum (here 11):
```csharp
int[] a = { 1, 3, 4, 7, 9 };
int left = 0, right = a.Length - 1, target = 11;
while (left < right && a[left] + a[right] != target)
if (a[left] + a[right] < target) left++; else right--;
Console.WriteLine(left < right ? $"{a[left]} + {a[right]}" : "no pair");
```
It prints 4 + 7 (or "no pair"). Too small: move left; too big: move right.
Same direction, to remove duplicates from a sorted array in place:
```csharp
int[] a = { 1, 1, 2, 3, 3 };
int w = Math.Min(1, a.Length); // 0 for an empty array
for (int r = 1; r < a.Length; r++)
if (a[r] != a[w - 1]) a[w++] = a[r];
Console.WriteLine(string.Join(" ", a[..w]));
```
It prints 1 2 3. Both are O(n) time, O(1) memory.
Read more: https://www.geeksforgeeks.org/dsa/two-pointers-technique/
#tip · TIP-038

2026-10-03 06:07:26 GMT

- reply

Count each letter. A palindrome can have at most one letter with an odd count: the one in the middle. Every other letter needs a partner on the other side.
```csharp
Console.WriteLine(CanBePalindrome("carrace"));
Console.WriteLine(CanBePalindrome("abcd"));
static bool CanBePalindrome(string s)
{
var counts = new Dictionary<char, int>();
foreach (char c in s) counts[c] = counts.GetValueOrDefault(c) + 1;
return counts.Values.Count(n => n % 2 == 1) <= 1;
}
```
It prints True, then False. O(n) time.
#arr008 · ARR-008-A1

2026-10-03 06:07:26 GMT

Question: Can the letters of a string be rearranged into a palindrome? "carrace" can: it becomes "racecar". "abcd" can't.
Find a check that runs in O(n).
(CtCI 1.4)
Try to answer before you open the reply.
#arr008 · ARR-008-Q1

2026-10-02 18:37:27 GMT

2026-10-02 18:07:22 GMT

Learn: Counting with an array
To count lowercase letters, use an int array with 26 slots, one per letter. The slot for a letter c is c - 'a', because 'a' - 'a' is 0 and 'z' - 'a' is 25.
```csharp
int[] counts = new int[26];
foreach (char c in "banana") counts[c - 'a']++;
Console.WriteLine($"a={counts[0]} b={counts[1]} n={counts['n' - 'a']}");
```
It prints a=3 b=1 n=2.
One pass, O(n). This works only for a to z: an uppercase letter or a space gives a slot outside 0 to 25 and throws. For any character, a Dictionary<char, int> does the same job.
#arr006 · ARR-006-N

2026-10-02 16:07:34 GMT

Learn: HashSet: a fast "have I seen this?" check
A HashSet<T> stores each value at most once.
Add returns true when the value is new, and false when it is already there. So one call both checks and remembers.
```csharp
var seen = new HashSet<string>();
Console.WriteLine(seen.Add("cat"));
Console.WriteLine(seen.Add("cat"));
Console.WriteLine(seen.Contains("cat"));
```
It prints True, False, True.
The docs say Contains "is an O(1) operation". Like every hash lookup, that is the average case: many collisions can slow it down. That makes HashSet the usual tool for finding repeats.
Source: https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.hashset-1.add
#arr005 · ARR-005-N

2026-10-02 15:37:21 GMT

Learn: Deadlock
Thread 1 holds lock A and waits for B. Thread 2 holds B and waits for A. Both wait forever.
It needs four things at once:
1. Only one thread can hold a lock.
2. A thread holds one lock while it waits for another.
3. Nobody can take a lock away.
4. The waiting forms a circle.
Prevent it: take locks in the same order, hold them briefly, use timeouts (Monitor.TryEnter).
Read more: https://learn.microsoft.com/en-us/dotnet/standard/threading/managed-threading-best-practices
#tip · TIP-079

2026-10-02 15:07:26 GMT

2026-10-02 14:37:28 GMT

Learn: Producer-consumer with Channel<T>
One part of the code produces work, another consumes it, and a queue sits between them. In .NET, Channel<T> is that queue, made for async code.
```csharp
var channel = Channel.CreateBounded<int>(2);
var producer = Task.Run(async () =>
{
for (int i = 1; i <= 3; i++) await channel.Writer.WriteAsync(i);
channel.Writer.Complete();
});
await foreach (int item in channel.Reader.ReadAllAsync()) Console.WriteLine(item);
await producer;
```
It prints 1, 2, 3. A bounded channel holds at most N items:
```csharp
var small = Channel.CreateBounded<int>(2);
Console.WriteLine($"{small.Writer.TryWrite(1)} {small.Writer.TryWrite(2)} {small.Writer.TryWrite(3)}");
```
It prints True True False: full. By default WriteAsync then waits; other modes drop items instead.
Read more: https://learn.microsoft.com/en-us/dotnet/core/extensions/channels
#tip · TIP-078

2026-10-02 14:07:57 GMT

Question: Does the two-pointer palindrome check also work for an even length, like "abba"? Where do the pointers stop?
Try to answer before you open the reply.
#arr001 · ARR-001-Q1

2026-10-02 13:37:23 GMT

- reply

Learn: Kubernetes in one page
Pods, deployments, services and scaling: the Kubernetes words interviewers expect you to know.
Read the full article: #naddr1qq…fmtd
#tip · TIP-062

2026-10-02 13:07:30 GMT

2026-10-02 12:37:25 GMT

2026-10-02 12:07:28 GMT

- reply

Search it as it is. A linear search is O(n). Sorting alone is O(n log n): the docs say Array.Sort is "an O(n log n) operation".
Sorting only pays off when you will search many times with a faster method.
Source: https://learn.microsoft.com/en-us/dotnet/api/system.array.sort
#big001 · BIG-001-A2

2026-10-02 12:07:28 GMT

Question: You need to answer one single search in an unsorted list of n items. Is it faster to sort the list first and then search, or to search it as it is?
Try to answer before you open the reply.
#big001 · BIG-001-Q2

2026-10-02 11:37:21 GMT

Learn: Producer-consumer by hand
The classic whiteboard version uses a queue and Monitor. The consumer waits while the queue is empty; the producer wakes it after adding.
```csharp
var q = new Queue<int>(); var sync = new object();
var consumer = new Thread(() => { for (int n = 0; n < 3; n++) Console.WriteLine(Take()); });
consumer.Start();
for (int i = 1; i <= 3; i++) lock (sync) { q.Enqueue(i); Monitor.PulseAll(sync); } // wake the consumer
consumer.Join();
int Take()
{
lock (sync) { while (q.Count == 0) Monitor.Wait(sync); return q.Dequeue(); } // Wait releases the lock
}
```
It prints 1, 2, 3. Wait must sit in a while loop: re-check after waking. In real code, BlockingCollection or Channel<T> do this for you.
Read more: https://learn.microsoft.com/en-us/dotnet/api/system.threading.monitor.wait
#tip · TIP-088

2026-10-02 11:07:21 GMT

Learn: Protecting endpoints in ASP.NET Core
Order matters: UseRouting, then UseCors, then UseAuthentication, then UseAuthorization.
[Authorize] requires a logged-in user; [AllowAnonymous] opens one action again.
[Authorize(Roles = "Admin,Billing")] means Admin OR Billing; two separate [Authorize] attributes mean both must pass. A policy ([Authorize(Policy = "Over18")]) is a named set of requirements, each checked by a handler.
Web apps usually log in with a cookie; APIs usually use a JWT bearer token.
Read more: https://learn.microsoft.com/en-us/aspnet/core/security/authorization/introduction
#tip · TIP-084

2026-10-02 10:07:23 GMT

Question: The inner loop starts at j = i, so it gets shorter each time. Is this still O(n²)?
```csharp
int n = 10, steps = 0;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) steps++;
Console.WriteLine(steps);
```
Try to answer before you open the reply.
#big008 · BIG-008-Q1

2026-10-02 10:07:23 GMT

- reply

Yes. The inner loop runs n, then n - 1, ... down to 1 times. That is n(n + 1)/2 in total: about half of n².
Big-O drops the constant 1/2, so it is O(n²). For n = 10 it prints 55.
#big008 · BIG-008-A1

2026-10-02 09:07:32 GMT

2026-10-02 08:07:32 GMT

- reply

Count the letters. Add 1 for each letter of the first string, subtract 1 for each letter of the second. If a count goes below zero, the answer is false.
```csharp
Console.WriteLine(IsPermutation("listen", "silent"));
Console.WriteLine(IsPermutation("apple", "plead"));
static bool IsPermutation(string s, string t)
{
if (s.Length != t.Length) return false;
var counts = new Dictionary<char, int>();
foreach (char c in s) counts[c] = counts.GetValueOrDefault(c) + 1;
foreach (char c in t) if ((counts[c] = counts.GetValueOrDefault(c) - 1) < 0) return false;
return true;
}
```
It prints True, then False.
Time O(n), one pass over each string. Extra memory: one count per different letter.
#arr006 · ARR-006-A1

2026-10-02 08:07:32 GMT

Question: One string is a permutation of another if it has the same letters in a different order, like "listen" and "silent".
How do you check this in O(n)?
(CtCI 1.2)
Try to answer before you open the reply.
#arr006 · ARR-006-Q1

2026-10-02 07:07:41 GMT

Learn: Tree
What: nodes in a hierarchy. One root at the top, each node has children, nodes with no children are leaves.
Use it when: data is nested: folders, HTML, company org charts, menus, and database indexes.
Most tree problems are recursion: solve for the children, then combine.
```csharp
var root = new Tree(1, new Tree(2, null, null), new Tree(3, new Tree(4, null, null), null));
Console.WriteLine(Count(root));
static int Count(Tree? t) => t == null ? 0 : 1 + Count(t.Left) + Count(t.Right);
```
It prints 4: the number of nodes.
Read more: https://www.geeksforgeeks.org/dsa/tree-data-structure/
#tip · TIP-030

2026-10-02 06:37:31 GMT

Learn: OAuth 2.0 vs OpenID Connect
OAuth 2.0 is about access: it lets an app call an API for the user, with an access token.
OpenID Connect (OIDC) adds login on top: an ID token that says who the user is.
The usual flow for web and mobile apps is the authorization code flow with PKCE: the user logs in at the identity provider, the app gets a code, and swaps it for tokens.
Short version: access token → for the API; ID token → for the app, to know who logged in.
Read more: https://learn.microsoft.com/en-us/entra/identity-platform/v2-protocols-oidc
#tip · TIP-093

2026-10-02 06:07:19 GMT

Question: Write a function that tells whether all the characters in a string are different. "abcde" gives true. "hello" gives false, because it has two l's.
What is the time complexity of your idea?
(CtCI 1.1)
Try to answer before you open the reply.
#arr005 · ARR-005-Q1

2026-10-02 06:07:19 GMT

- reply

One pass with a HashSet. Add each character. If Add returns false, that character was already in the set, so the answer is false.
```csharp
Console.WriteLine(AllUnique("abcde"));
Console.WriteLine(AllUnique("hello"));
static bool AllUnique(string s)
{
var seen = new HashSet<char>();
foreach (char c in s)
if (!seen.Add(c)) return false; // Add returns false for a repeat
return true;
}
```
It prints True, then False.
Time: O(n) on average, one pass, and each Add is O(1) on average. Extra memory: one entry per different character.
#arr005 · ARR-005-A1

2026-10-02 05:37:20 GMT

- reply

Learn: Kubernetes in one page
Pods, deployments, services and scaling: the Kubernetes words interviewers expect you to know.
Read the full article: #naddr1qq…05qf
#tip · TIP-062

2026-10-02 05:07:21 GMT

Learn: Linked list
What: nodes, each holding a value and a link to the next node.
Cost: insert or remove at a node you already hold is O(1); reaching item k is O(k), because you must walk.
Use it when: you add and remove at the ends or in the middle a lot, and rarely jump to a position. Example: an LRU cache, which pairs a Dictionary (find a node fast) with a linked list (move it to the front).
```csharp
var list = new LinkedList<int>();
list.AddLast(2); list.AddLast(3); list.AddFirst(1);
Console.WriteLine(string.Join(" ", list));
```
It prints 1 2 3. .NET's LinkedList<T> is doubly linked. In practice List<T> is often faster, because its items sit next to each other in memory.
Read more: https://www.geeksforgeeks.org/dsa/linked-list-data-structure/
#tip · TIP-026

2026-10-01 18:37:32 GMT

- reply

Learn: Merge sort, step by step
How merge sort splits, sorts and merges; why it is O(n log n); and when to choose it.
Read the full article: #naddr1qq…5cwh
#tip · TIP-037

2026-10-01 18:07:29 GMT

Learn: Abstract class
An abstract class is a base class you can't create directly. It can hold shared code and fields, plus abstract members each subclass must fill in.
A class can inherit from only one class.
Use it when: related classes share real code, not just a contract.
```csharp
Animal[] animals = { new Dog(), new Cat() };
foreach (var a in animals) Console.WriteLine(a.Describe());
abstract class Animal
{
public string Describe() => $"{GetType().Name} says {Sound()}"; // shared code
protected abstract string Sound(); // each subclass fills in
}
class Dog : Animal { protected override string Sound() => "woof"; }
class Cat : Animal { protected override string Sound() => "meow"; }
```
It prints Dog says woof, then Cat says meow.
Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/abstract
#tip · TIP-049

2026-10-01 17:07:21 GMT

2026-10-01 16:37:54 GMT