Nostr notes by codementor

Learn: Linear search What: check the items one by one until you ...

2026-10-13T18:37:58Z

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

Learn: Starvation Starvation: a thread is ready to work but never ...

2026-10-08T15:37:25Z

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

Sort + two pointers: O(n log n) time, because of the sort (the ...

2026-10-05T14:07:22Z

In reply to nevent1q…jsw5
_________________________

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

Question: The array is NOT sorted. You need two numbers that add ...

2026-10-05T14:07:22Z

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

Learn: Bubble sort What: walk the array and swap neighbors that ...

2026-10-05T11:37:23Z

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

Learn: Interface or abstract class? Interface: a contract with no ...

2026-10-05T11:07:18Z

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

Learn: SOLID in one post S: Single responsibility. One class, one ...

2026-10-05T10:37:20Z

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

A 0 you just wrote looks exactly like an original 0. When the ...

2026-10-05T10:07:28Z

In reply to nevent1q…m2ay
_________________________

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

Question: In a matrix, if a cell is 0, set its whole row and ...

2026-10-05T10:07:28Z

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

Learn: The three pattern families Creational: how objects get ...

2026-10-05T09:37:28Z

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

Learn: PriorityQueue for "smallest first" .NET has ...

2026-10-05T08:37:17Z

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

Question: In the one-edit-away check, why can you return false ...

2026-10-05T08:07:30Z

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

Learn: Designing a URL shortener A step-by-step way to answer the ...

2026-10-05T07:37:37Z

In reply to naddr1qq…nuja
_________________________

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:

quoting naddr1qq…sdme

Designing a URL shortener

This is one of the most common system design interview questions. Here is a simple way to walk through it.

1. Requirements first

Ask before you draw anything:

Functional: make a short link for a long URL; redirect a short link to the long URL.

Non-functional: redirects must be fast; links must not collide; the service must stay up.

Scale: how many new links a day, and how many redirects? Redirects are usually far more common than new links, so this is a read-heavy system.

2. The API

POST /links with the long URL returns the short code.

GET /{code} answers with a redirect (HTTP 301 or 302) to the long URL.

3. Making the short code

Give every link a unique number (an ID from the database or an ID service), then write that number in base 62 (0-9, a-z, A-Z). Seven base-62 characters give about 3.5 trillion codes.
const string chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
long id = 125;
var code = "";
do { code = chars[(int)(id % 62)] + code; id /= 62; } while (id > 0);
Console.WriteLine(code);
It prints 21, because 125 = 2 × 62 + 1. Using unique IDs means two links can never get the same code.

4. Storage

A simple table: code → long URL, plus creation time. Reads by code must be fast, so the code is the key. A key-value store fits well.

5. Making redirects fast

Put a cache in front of the database: most traffic goes to a small number of popular links. Links rarely change, so cached copies stay correct for a long time.

6. Growing

More app servers behind a load balancer; the servers keep no state.

Shard the storage by code when one database is not enough.

Replicate data so a failed server doesn't lose links.

What interviewers look for

Clear requirements, a simple design first, then the bottlenecks: the read load, the ID generation, and what happens when a part fails.

#tip · TIP-022

#tip · TIP-022

Learn: Costs worth knowing by heart Read array[i]: O(1) Search an ...

2026-10-05T07:07:19Z

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

Yes. Give each letter one bit of the int, and flip that bit every ...

2026-10-05T06:07:31Z

In reply to nevent1q…zd0a
_________________________

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

Interviewer's follow-up: "The string has only the letters ...

2026-10-05T06:07:31Z

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

Learn: Thread-safe collections List<T> and Dictionary<K, ...

2026-10-05T05:37:19Z

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

Learn: The middleware pipeline Every request passes through a ...

2026-10-04T18:37:22Z

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

Learn: 2D arrays in C# int[,] is a grid with rows and columns. ...

2026-10-04T18:07:32Z

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

Learn: Never change a key while it is in a HashSet A HashSet or ...

2026-10-04T17:37:21Z

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

Learn: The Lock type (.NET 9+) .NET 9 added ...

2026-10-04T17:07:34Z

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

Learn: Sharding splits data by a key When one database is too big ...

2026-10-04T16:37:29Z

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

So that a range starting at index 0 needs no special case. The ...

2026-10-04T16:07:18Z

In reply to nevent1q…23dz
_________________________

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

Learn: Repository and Unit of Work Repository: hides data access ...

2026-10-04T15:30:09Z

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

Bug hunt: This Two Sum should print the indexes of two numbers ...

2026-10-04T15:07:22Z

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

It prints 0 0. The line seen[a[i]] = i; runs before the check. At ...

2026-10-04T15:07:22Z

In reply to nevent1q…m7k2
_________________________

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

Learn: Race condition When two threads read and write the same ...

2026-10-04T14:37:19Z

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

Question: Rewrite the recursive Sum(n) with a loop. What is its ...

2026-10-04T14:07:30Z

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

```csharp int total = 0; for (int i = 1; i <= 5; i++) total += ...

2026-10-04T14:07:30Z

In reply to nevent1q…85q8
_________________________

```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

Learn: Strings What: a sequence of characters. In C# a string ...

2026-10-04T13:37:30Z

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

Learn: Async mistakes interviewers ask about async void: ...

2026-10-04T13:07:26Z

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

Learn: Task vs Thread A Thread is an operating system thread: ...

2026-10-04T12:37:28Z

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

Question: Rotate a square n×n matrix 90 degrees clockwise, in ...

2026-10-04T12:07:24Z

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

Step 1: transpose. Swap m[i, j] with m[j, i], so rows become ...

2026-10-04T12:07:24Z

In reply to nevent1q…ker8
_________________________

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

Learn: Test your code by hand When your code is written, ...

2026-10-04T11:07:27Z

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

Question: Compress a string by writing each letter with how many ...

2026-10-04T10:03:48Z

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

A StringBuilder. It adds characters into spare room instead of ...

2026-10-04T10:03:48Z

In reply to nevent1q…jtsc
_________________________

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

Learn: SemaphoreSlim, the async-friendly lock A semaphore lets up ...

2026-10-04T09:37:30Z

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

Learn: Data structures: which one when? A one-page cheat sheet: ...

2026-10-04T09:07:32Z

In reply to naddr1qq…mg04
_________________________

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:

quoting naddr1qq…ytq7

Data structures: which one when?

Pick a data structure by asking: what will I do most often? Read by position? Look up by key? Add and remove at the ends? Keep things sorted?

Need Use C# type Main cost

Read by position, loop over all Array / list int[], List<T> index O(1), middle insert O(n)

Look up by key, count, remove duplicates Hash table Dictionary<K,V>, HashSet<T> O(1) on average

Last in, first out (undo, brackets, DFS) Stack Stack<T> push amortized O(1), pop O(1)

First in, first out (BFS, jobs) Queue Queue<T> enqueue amortized O(1), dequeue O(1)

Always take the smallest (top k, Dijkstra) Heap PriorityQueue<T,P> O(log n)

Keep sorted while changing, ranges Balanced tree SortedSet<T>, SortedDictionary<K,V> O(log n)

Many inserts/removes at known nodes Linked list LinkedList<T> O(1) at a node, O(n) to find it

Grid data Matrix int[,] O(rows × cols) to visit all

Nested data Tree your own node class depends on shape

How to answer in an interview

Say what operation the problem needs most.

Pick the structure that makes that operation cheap.

Say the cost out loud, and the trade-off: a hash table is fast but unordered; a sorted set is ordered but O(log n).

A quick example

"Find if any two numbers sum to 10" needs fast "have I seen x?" checks, so a HashSet<int> turns it into one pass:
int[] nums = { 3, 9, 7, 1 };
var seen = new HashSet<int>();
bool found = false;
foreach (int x in nums)
{
    found |= seen.Contains(10 - x);
    seen.Add(x);
}
Console.WriteLine(found);
It prints True (3 + 7 = 10).

Read more: https://roadmap.sh/datastructures-and-algorithms

#tip · TIP-032

Need	Use	C# type	Main cost
Read by position, loop over all	Array / list	`int[]`, `List<T>`	index O(1), middle insert O(n)
Look up by key, count, remove duplicates	Hash table	`Dictionary<K,V>`, `HashSet<T>`	O(1) on average
Last in, first out (undo, brackets, DFS)	Stack	`Stack<T>`	push amortized O(1), pop O(1)
First in, first out (BFS, jobs)	Queue	`Queue<T>`	enqueue amortized O(1), dequeue O(1)
Always take the smallest (top k, Dijkstra)	Heap	`PriorityQueue<T,P>`	O(log n)
Keep sorted while changing, ranges	Balanced tree	`SortedSet<T>`, `SortedDictionary<K,V>`	O(log n)
Many inserts/removes at known nodes	Linked list	`LinkedList<T>`	O(1) at a node, O(n) to find it
Grid data	Matrix	`int[,]`	O(rows × cols) to visit all
Nested data	Tree	your own node class	depends on shape

#tip · TIP-032

Learn: EF Core essentials IQueryable vs IEnumerable: filter an ...

2026-10-04T08:37:30Z

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

Question: In the counting solution, why check the lengths first? ...

2026-10-04T08:07:56Z

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

Strings with different lengths can't have the same letters, ...

2026-10-04T08:07:56Z

In reply to nevent1q…27n0
_________________________

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

Learn: Scale up or scale out Scale up (vertical): a bigger ...

2026-10-04T07:37:35Z

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

Learn: Array What: items stored side by side in memory, each at ...

2026-10-04T07:07:19Z

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

Learn: Value types vs reference types A value type (struct, int, ...

2026-10-04T06:37:28Z

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

Interviewer's follow-up: "Now solve it without a HashSet ...

2026-10-04T06:07:33Z

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

Learn: Backtracking Backtracking tries every choice step by step: ...

2026-10-04T05:37:16Z

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

Learn: Bitwise tricks Operators: & (and), | (or), ^ (xor), ~ ...

2026-10-04T05:07:23Z

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

Learn: Concurrency in .NET: which tool when A one-page map of ...

2026-10-03T18:37:29Z

In reply to naddr1qq…tmau
_________________________

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:

quoting naddr1qq…myvr

Concurrency in .NET: which tool when

When several threads touch the same data, three bugs appear: race conditions (lost updates), deadlocks (threads waiting on each other forever) and starvation (some work never gets a turn). Pick the tool that fits the situation.

Situation Tool Why

Add to a shared counter Interlocked atomic, no lock needed

Protect a few lines of sync code lock (on a private object, or Lock in .NET 9+) simple, fast; no await inside

Protect code that uses await SemaphoreSlim(1, 1) works with WaitAsync

Limit how many run at once SemaphoreSlim(n, n) lets n callers in

One lock across processes named Mutex visible to other processes

Many readers, few writers ReaderWriterLockSlim readers don't block each other; not for async code

Shared dictionary or queue ConcurrentDictionary, ConcurrentQueue thread-safe operations

Hand work from producers to consumers Channel<T> async queue; a bounded one makes fast producers wait

Wait for I/O async/await no thread held while waiting

Rules that prevent most bugs

Share as little as possible. Immutable data needs no lock.

Keep locked blocks short, and never call unknown code (events, callbacks) while holding a lock.

Take locks in one fixed order to avoid deadlocks.

Don't block on async code (.Result, .Wait()); in ASP.NET Core it starves the thread pool.

You can't await inside a lock; use SemaphoreSlim.

Readers and writers
var rw = new ReaderWriterLockSlim();
var prices = new Dictionary<string, int> { ["tea"] = 3 };
rw.EnterReadLock(); try { Console.WriteLine(prices["tea"]); } finally { rw.ExitReadLock(); }
rw.EnterWriteLock(); try { prices["tea"] = 4; } finally { rw.ExitWriteLock(); }
Console.WriteLine(prices["tea"]);
It prints 3, then 4. Many threads can hold the read lock together; the write lock is exclusive. For short sections a plain lock is often just as fast.

Read more: https://learn.microsoft.com/en-us/dotnet/standard/threading/managed-threading-best-practices

#tip · TIP-082

Situation	Tool	Why
Add to a shared counter	`Interlocked`	atomic, no lock needed
Protect a few lines of sync code	`lock` (on a private object, or `Lock` in .NET 9+)	simple, fast; no `await` inside
Protect code that uses `await`	`SemaphoreSlim(1, 1)`	works with `WaitAsync`
Limit how many run at once	`SemaphoreSlim(n, n)`	lets n callers in
One lock across processes	named `Mutex`	visible to other processes
Many readers, few writers	`ReaderWriterLockSlim`	readers don't block each other; not for async code
Shared dictionary or queue	`ConcurrentDictionary`, `ConcurrentQueue`	thread-safe operations
Hand work from producers to consumers	`Channel<T>`	async queue; a bounded one makes fast producers wait
Wait for I/O	`async`/`await`	no thread held while waiting

#tip · TIP-082

Learn: Three kinds of edits Edit problems use three operations: ...

2026-10-03T18:07:29Z

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

Learn: Caching in one breath A cache keeps a copy of slow data ...

2026-10-03T17:34:56Z

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

Learn: Matrix What: a grid of rows and columns; m[row, col] reads ...

2026-10-03T17:07:28Z

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

Learn: Queue What: first in, first out, like a line at a shop. ...

2026-10-03T16:37:19Z

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

n adds cost O(n²) in total, so one Add is O(n) on average. A ...

2026-10-03T15:07:27Z

In reply to nevent1q…cnmq
_________________________

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

Interviewer's follow-up: "Your list does not double. When ...

2026-10-03T15:07:27Z

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

Question: Two Sum with a Dictionary uses O(n) extra memory. When ...

2026-10-03T14:07:26Z

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

When the array is already sorted. Then two pointers from both ...

2026-10-03T14:07:26Z

In reply to nevent1q…fha6
_________________________

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

Learn: What a load balancer does It spreads incoming requests ...

2026-10-03T13:37:33Z

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

Learn: Linear search What: check the items one by one until you ...

2026-10-03T13:07:21Z

Learn: SemaphoreSlim, the async-friendly lock A semaphore lets up ...

2026-10-03T12:37:23Z

Question: You will add 1000 items to a list. What is the ...

2026-10-03T12:07:30Z

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

new List<int>(1000) makes room for 1000 items at the start, ...

2026-10-03T12:07:30Z

In reply to nevent1q…w65u
_________________________

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

Learn: The lock statement lock lets only one thread at a time run ...

2026-10-03T11:37:18Z

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

Learn: Binary search tree (BST) What: a binary tree where ...

2026-10-03T09:37:30Z

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

Learn: Async mistakes interviewers ask about async void: ...

2026-10-03T09:07:23Z

Learn: Interface An interface is a contract: members a class must ...

2026-10-03T08:37:29Z

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

Question: Two strings are "one edit away" if a single ...

2026-10-03T08:07:19Z

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

Learn: Tree traversals The four ways to visit a tree, when each ...

2026-10-03T07:37:19Z

In reply to naddr1qq…6d9e
_________________________

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:

quoting naddr1qq…fpl9

Tree traversals

Most tree questions start with visiting every node in some order.

Depth-first (recursion)

Pre-order: node, then left, then right. Use it to copy a tree or print it top-down.

In-order: left, then node, then right. On a binary search tree this gives the values in sorted order, a favorite interview fact.

Post-order: left, then right, then node. Use it to delete a tree or compute sizes (children first).
var root = new Tree(2, new Tree(1, null, null), new Tree(3, null, null));
var order = new List<int>();
InOrder(root, order);
Console.WriteLine(string.Join(" ", order));

static void InOrder(Tree? t, List<int> order)
{
    if (t == null) return;
    InOrder(t.Left, order); order.Add(t.Value); InOrder(t.Right, order);
}
It prints 1 2 3: in-order on a BST is sorted.

Breadth-first (level by level)

Use a queue: take a node out, add its children at the back. Use it for "shortest path in steps", "print level by level", or "nodes closest to the root".
var root = new Tree(1, new Tree(2, new Tree(4, null, null), null), new Tree(3, null, null));
var queue = new Queue<Tree>(new[] { root });
var visited = new List<int>();
while (queue.Count > 0)
{
    var t = queue.Dequeue(); visited.Add(t.Value);
    if (t.Left != null) queue.Enqueue(t.Left);
    if (t.Right != null) queue.Enqueue(t.Right);
}
Console.WriteLine(string.Join(" ", visited));
It prints 1 2 3 4: the root, then its children, then the next level.

Cost

Every traversal visits each node once: O(n) time. Memory: recursion uses O(h), where h is the tree's height (O(log n) if balanced, O(n) if it is a chain); breadth-first keeps up to one full level in the queue.

Read more: https://www.geeksforgeeks.org/dsa/tree-data-structure/

#tip · TIP-064

#tip · TIP-064

Learn: Array What: items stored side by side in memory, each at ...

2026-10-03T07:04:05Z

Learn: Two pointers Two indexes walk the data instead of nested ...

2026-10-03T06:37:21Z

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

Count each letter. A palindrome can have at most one letter with ...

2026-10-03T06:07:26Z

In reply to nevent1q…78wc
_________________________

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

Question: Can the letters of a string be rearranged into a ...

2026-10-03T06:07:26Z

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

Learn: EF Core essentials IQueryable vs IEnumerable: filter an ...

2026-10-02T18:37:27Z

Learn: Counting with an array To count lowercase letters, use an ...

2026-10-02T18:07:22Z

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

Learn: HashSet: a fast "have I seen this?" check A ...

2026-10-02T16:07:34Z

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

Learn: Deadlock Thread 1 holds lock A and waits for B. Thread 2 ...

2026-10-02T15:37:21Z

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

Learn: The Lock type (.NET 9+) .NET 9 added ...

2026-10-02T15:07:26Z

Learn: Producer-consumer with Channel<T> One part of the ...

2026-10-02T14:37:28Z

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

Question: Does the two-pointer palindrome check also work for an ...

2026-10-02T14:07:57Z

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

Learn: Kubernetes in one page Pods, deployments, services and ...

2026-10-02T13:37:23Z

In reply to naddr1qq…7cz4
_________________________

Learn: Kubernetes in one page

Pods, deployments, services and scaling: the Kubernetes words interviewers expect you to know.

Read the full article:

quoting naddr1qq…fmtd

Kubernetes in one page

Kubernetes (K8s) runs containers on a group of machines (a cluster) and keeps them in the state you describe.

The main objects

Pod: the smallest unit. One or more containers that run together and share a network address.

Deployment: "keep 3 copies of this pod running, with this image." Change the image and it rolls out new pods step by step.

Service: one stable name and address in front of a changing group of pods, with load balancing between them.

Ingress: routes outside HTTP traffic (like api.example.com/orders) to services.

ConfigMap and Secret: configuration and passwords given to pods without rebuilding the image. A Secret is only base64-encoded by default, not encrypted, so limit who can read it.

What it does for you

Self-healing: restarts containers that crash, replaces unhealthy ones, and only sends traffic to pods that pass their readiness check.

Scaling: change the number of copies, or let a Horizontal Pod Autoscaler add pods when CPU goes up.

Rolling updates: new versions go out gradually and can be rolled back.

You describe, it makes it true

You write the desired state in YAML (for example, 3 replicas). Kubernetes keeps comparing what runs with what you asked for, and fixes any difference.

Interview tips

Know the difference between a Pod (instance), a Deployment (keeps copies running) and a Service (stable address).

Health checks matter: a liveness probe restarts a stuck container; a readiness probe keeps traffic away until it is ready.

Read more: https://roadmap.sh/kubernetes

#tip · TIP-062

#tip · TIP-062

Learn: Two pointers Two indexes walk the data instead of nested ...

2026-10-02T13:07:30Z

Learn: Task vs Thread A Thread is an operating system thread: ...

2026-10-02T12:37:25Z

Search it as it is. A linear search is O(n). Sorting alone is O(n ...

2026-10-02T12:07:28Z

In reply to nevent1q…44qw
_________________________

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

Question: You need to answer one single search in an unsorted ...

2026-10-02T12:07:28Z

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

Learn: Producer-consumer by hand The classic whiteboard version ...

2026-10-02T11:37:21Z

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

Learn: Protecting endpoints in ASP.NET Core Order matters: ...

2026-10-02T11:07:21Z

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

Question: The inner loop starts at j = i, so it gets shorter each ...

2026-10-02T10:07:23Z

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

Yes. The inner loop runs n, then n - 1, ... down to 1 times. That ...

2026-10-02T10:07:23Z

In reply to nevent1q…733k
_________________________

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

Learn: Sharding splits data by a key When one database is too big ...

2026-10-02T09:07:32Z

Count the letters. Add 1 for each letter of the first string, ...

2026-10-02T08:07:32Z

In reply to nevent1q…guv0
_________________________

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

Question: One string is a permutation of another if it has the ...

2026-10-02T08:07:32Z

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

Learn: Tree What: nodes in a hierarchy. One root at the top, each ...

2026-10-02T07:07:41Z

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

Learn: OAuth 2.0 vs OpenID Connect OAuth 2.0 is about access: it ...

2026-10-02T06:37:31Z

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

Question: Write a function that tells whether all the characters ...

2026-10-02T06:07:19Z

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

One pass with a HashSet. Add each character. If Add returns ...

2026-10-02T06:07:19Z

In reply to nevent1q…gayh
_________________________

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

Learn: Kubernetes in one page Pods, deployments, services and ...

2026-10-02T05:37:20Z

In reply to naddr1qq…qu8w
_________________________

Learn: Kubernetes in one page

Pods, deployments, services and scaling: the Kubernetes words interviewers expect you to know.

Read the full article:

quoting naddr1qq…05qf

Kubernetes in one page

Kubernetes (K8s) runs containers on a group of machines (a cluster) and keeps them in the state you describe.

The main objects

Pod: the smallest unit. One or more containers that run together and share a network address.

Deployment: "keep 3 copies of this pod running, with this image." Change the image and it rolls out new pods step by step.

Service: one stable name and address in front of a changing group of pods, with load balancing between them.

Ingress: routes outside HTTP traffic (like api.example.com/orders) to services.

ConfigMap and Secret: configuration and passwords given to pods without rebuilding the image. A Secret is only base64-encoded by default, not encrypted, so limit who can read it.

What it does for you

Self-healing: restarts containers that crash, replaces unhealthy ones, and only sends traffic to pods that pass their readiness check.

Scaling: change the number of copies, or let a Horizontal Pod Autoscaler add pods when CPU goes up.

Rolling updates: new versions go out gradually and can be rolled back.

You describe, it makes it true

You write the desired state in YAML (for example, 3 replicas). Kubernetes keeps comparing what runs with what you asked for, and fixes any difference.

Interview tips

Know the difference between a Pod (instance), a Deployment (keeps copies running) and a Service (stable address).

Health checks matter: a liveness probe restarts a stuck container; a readiness probe keeps traffic away until it is ready.

Read more: https://roadmap.sh/kubernetes

#tip · TIP-062

#tip · TIP-062

Learn: Linked list What: nodes, each holding a value and a link ...

2026-10-02T05:07:21Z

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

Learn: Merge sort, step by step How merge sort splits, sorts and ...

2026-10-01T18:37:32Z

In reply to naddr1qq…yzdv
_________________________

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:

quoting naddr1qq…5cwh

Merge sort, step by step

Merge sort is the classic divide and conquer sort.

Divide: split the array into two halves.

Conquer: sort each half, with merge sort again (recursion).

Combine: merge the two sorted halves into one sorted array.

An array of one item is already sorted, so the recursion stops there.

The code
Console.WriteLine(string.Join(" ", Sort(new[] { 5, 2, 9, 1, 6 })));
static int[] Sort(int[] a)
{
    if (a.Length <= 1) return a;
    int[] left = Sort(a[..(a.Length / 2)]), right = Sort(a[(a.Length / 2)..]); // split in half
    var result = new List<int>(); int i = 0, j = 0;
    while (i < left.Length && j < right.Length) result.Add(left[i] <= right[j] ? left[i++] : right[j++]);
    result.AddRange(left[i..]); result.AddRange(right[j..]); // copy what is left
    return result.ToArray();
}
It prints 1 2 5 6 9.

Merging

Look only at the front of each half and take the smaller item. Repeat until one half is empty, then copy what is left of the other. Using <= keeps equal items in their original order, so merge sort is stable.

Cost

Time: O(n log n) in every case. There are about log n levels of splitting, and each level merges n items in total.

Memory: O(n) extra for the merged arrays.

When to choose it

You need a stable sort.

You sort a linked list (merging needs no random access).

The data is too big for memory and is sorted in chunks on disk (external sorting).

In everyday C#, Array.Sort is O(n log n) and the right default, but it is not stable; OrderBy in LINQ is stable. Know merge sort for interviews and for the cases above.

Read more: https://www.geeksforgeeks.org/dsa/merge-sort/

#tip · TIP-037

#tip · TIP-037

Learn: Abstract class An abstract class is a base class you ...

2026-10-01T18:07:29Z

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

Learn: Value types vs reference types A value type (struct, int, ...

2026-10-01T17:07:21Z