Nostr notes by codementor

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

2026-10-28T15:08:03Z

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: Bitwise tricks Operators: & (and), | (or), ^ (xor), ~ ...

2026-10-28T14:37:53Z

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: Interface An interface is a contract: members a class must ...

2026-10-28T10:38:27Z

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

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

2026-10-28T10:08:00Z

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

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

2026-10-28T09:38:24Z

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

Question: A candidate checks only that each node's left child ...

2026-10-28T09:07:48Z

Question: A candidate checks only that each node's left child is smaller and its right child is bigger.

Why is that not enough? Give a tree that passes their check but is not a BST.

Try to answer before you open the reply.

#tg005 · TG-005-Q2

The rule is about whole subtrees, not just children. A grandchild ...

2026-10-28T09:07:48Z

In reply to nevent1q…sls5
_________________________

The rule is about whole subtrees, not just children. A grandchild can be on the wrong side of its grandparent.

```csharp
var bad = new Node(5, new Node(3, null, new Node(6)), new Node(8));
Console.WriteLine(LocalCheck(bad));

bool LocalCheck(Node? n) =>
n == null ||
(n.Left == null || n.Left.Value < n.Value) && (n.Right == null || n.Right.Value > n.Value)
&& LocalCheck(n.Left) && LocalCheck(n.Right);
```

It prints True, but the tree is not a BST: 6 sits in the left subtree of 5. Searching for 6 from the root would go right and miss it.

This is the most common bug in this question.

#tg005 · TG-005-A2

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

2026-10-28T08:37:56Z

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: Test your code by hand When your code is written, ...

2026-10-28T08:07:55Z

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

Learn: IDisposable and using Some objects hold things the garbage ...

2026-10-28T07:38:09Z

Learn: IDisposable and using

Some objects hold things the garbage collector doesn't manage well: files, network connections, database connections. They implement IDisposable, and you must call Dispose when done.
using does it for you, even if an exception is thrown:

```csharp
using (var r = new Resource()) Console.WriteLine("working");
Console.WriteLine("after");

class Resource : IDisposable { public void Dispose() => Console.WriteLine("cleaned up"); }
```

It prints working, cleaned up, after.
Shorter form: using var file = File.OpenRead(path); disposes at the end of the method or block.

Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/statements/using

#tip · TIP-101

Both are O(n) time: each node is visited once. The level version ...

2026-10-28T07:07:54Z

In reply to nevent1q…chpp
_________________________

Both are O(n) time: each node is visited once.

The level version holds one full level in memory. In a balanced tree the last level has about n/2 nodes, so that is O(n).

The recursive version uses the call stack: O(height). That is O(log n) for a balanced tree, but O(n) for a chain, where deep recursion can even overflow the stack.

The result itself is O(n) either way, so in an interview both answers are fine. Just name the trade-off.

#tg003 · TG-003-A3

Question: Compare the two versions: time, and extra memory ...

2026-10-28T07:07:54Z

Question: Compare the two versions: time, and extra memory besides the result.

For which tree shape is each one better?

Try to answer before you open the reply.

#tg003 · TG-003-Q3

Learn: When recursion fits Use recursion when a problem contains ...

2026-10-28T06:38:06Z

Learn: When recursion fits

Use recursion when a problem contains smaller copies of itself: trees, folders inside folders, divide and conquer, trying all options (backtracking).

Every recursive function needs a base case and a step toward it.

```csharp
Console.WriteLine(Factorial(5));
static long Factorial(int n) => n <= 1 ? 1 : n * Factorial(n - 1);
```

It prints 120. For very deep inputs, a loop is safer: each call uses stack memory.

Read more: https://www.geeksforgeeks.org/dsa/recursion-algorithms/

#tip · TIP-041

Learn: Ask before you code Before writing anything, ask about the ...

2026-10-28T06:08:02Z

Learn: Ask before you code

Before writing anything, ask about the input:

Can it be empty or null?
Are there duplicates or negative numbers?
Is it sorted?
How big can it get?

The answers often change the best solution, and asking shows the interviewer you think about edge cases.

#tip · TIP-002

Learn: Binary search in one post On a sorted array, look at the ...

2026-10-27T19:38:17Z

Learn: Binary search in one post

On a sorted array, look at the middle. If the target is bigger, keep the right half; if smaller, the left half. Each step halves the range: O(log n).

```csharp
int[] a = { 1, 3, 5, 7, 9, 11 };
int target = 7, lo = 0, hi = a.Length - 1;
while (lo <= hi)
{
int mid = lo + (hi - lo) / 2;
if (a[mid] == target) { Console.WriteLine(mid); break; }
if (a[mid] < target) lo = mid + 1; else hi = mid - 1;
}
```

It prints 3. Write mid as lo + (hi - lo) / 2: plain (lo + hi) / 2 can overflow an int on huge arrays.

#tip · TIP-006

Learn: Binary search tree (BST) In a BST, every value in a ...

2026-10-27T19:08:03Z

Learn: Binary search tree (BST)

In a BST, every value in a node's left subtree is smaller than the node, and every value in its right subtree is bigger.

To search, compare with the node and go left or right: one level per step. So the cost is O(height).

A balanced tree has height about log₂ n, so search is O(log n). A tree that is a chain has height n, so search is O(n).

That is why real libraries use self-balancing trees (like red-black or AVL trees), which fix the shape after each insert or delete.

#tg002 · TG-002-N

Learn: Concurrency vs parallelism Concurrency: several tasks are ...

2026-10-27T18:38:04Z

Learn: Concurrency vs parallelism

Concurrency: several tasks are in progress at the same time, maybe taking turns on one core. Example: a server waiting on many database calls.
Parallelism: work really runs at the same moment on several cores. Example: resizing 1,000 images.

In .NET: waiting on I/O → async/await. CPU-heavy work → Parallel.For, or Task.Run in UI apps (on a server, Task.Run only moves work between pool threads). Both bring the same risk: shared data touched by two threads at once.

Read more: https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/task-based-asynchronous-programming

#tip · TIP-072

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

2026-10-27T18:07:51Z

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

Learn: Custom authorization policies When roles are not enough, ...

2026-10-27T17:37:55Z

Learn: Custom authorization policies

When roles are not enough, write a policy:
1. A requirement: a small class with the rule's data, like MinimumAge = 18.
2. A handler: AuthorizationHandler<TRequirement> that reads the user's claims and calls context.Succeed(requirement).
3. Register both, then use [Authorize(Policy = "Over18")].
For rules about one specific object ("may edit THIS order"), inject IAuthorizationService and call AuthorizeAsync(user, order, "CanEdit").

Read more: https://learn.microsoft.com/en-us/aspnet/core/security/authorization/policies

#tip · TIP-091

Learn: Breadth-first search (BFS) BFS visits the start node, then ...

2026-10-27T17:08:04Z

Learn: Breadth-first search (BFS)

BFS visits the start node, then all its neighbors, then their neighbors, and so on: rings of growing distance.

It needs a Queue<T> for the nodes to visit and a HashSet<T> for the nodes already seen.

```csharp
var graph = new Dictionary<int, int[]> { [1] = [2, 3], [2] = [4], [3] = [4, 5], [4] = [], [5] = [] };
var seen = new HashSet<int> { 1 };
var queue = new Queue<int>([1]);
var order = new List<int>();
while (queue.TryDequeue(out int n))
{
order.Add(n);
foreach (int next in graph[n]) if (seen.Add(next)) queue.Enqueue(next); // mark when queued
}
Console.WriteLine(string.Join(" ", order));
```

It prints 1 2 3 4 5. Node 4 is reached twice, but queued once.

Cost: O(V + E). Because it goes ring by ring, BFS finds the route with the fewest edges.

#tg001 · TG-001-N

Learn: Think out loud In a coding interview, the interviewer ...

2026-10-27T16:38:17Z

Learn: Think out loud

In a coding interview, the interviewer grades how you think, not only the final code. Say what you are trying, why, and what you would check next.

Silence for five minutes looks the same as being stuck, even when you are close.

#tip · TIP-001

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

2026-10-27T16:07:58Z

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

2026-10-27T15:38:02Z

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: In a binary tree (not a search tree), find the first ...

2026-10-27T15:07:54Z

Question: In a binary tree (not a search tree), find the first common ancestor of two nodes: the lowest node that has both of them below it (a node counts as below itself).

There are no parent links, and you may not store nodes in an extra data structure.

(CtCI 4.8)

Try to answer before you open the reply.

#tg008 · TG-008-Q1

Recurse. A call returns p or q if it finds one of them, and null ...

2026-10-27T15:07:54Z

In reply to nevent1q…lqpc
_________________________

Recurse. A call returns p or q if it finds one of them, and null if it finds neither. If a node gets a non-null answer from both sides, p and q split there: that node is the answer. Otherwise pass up whichever side found something.

```csharp
Node a = new(2), b = new(7);
var root = new Node(8, new Node(4, a, new Node(6, new Node(5), b)), new Node(9));
Console.WriteLine(Lca(root, a, b)?.Value);

Node? Lca(Node? n, Node p, Node q)
{
if (n == null || n == p || n == q) return n; // compares references
Node? l = Lca(n.Left, p, q), r = Lca(n.Right, p, q);
return l != null && r != null ? n : l ?? r;
}
```

It prints 4.

n == p compares references: the same node object, not just the same value. O(n) time, O(height) stack.

#tg008 · TG-008-A1

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

2026-10-27T14:38:04Z

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

2026-10-27T14:07:56Z

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: Linked list classic: reverse it Interviewers want your own ...

2026-10-27T13:32:19Z

Learn: Linked list classic: reverse it

Interviewers want your own Node class, not LinkedList<T>. Walk the list and point each node back to the one before it. Save the next node first, or you lose the rest of the list.

```csharp
Node? cur = new Node(1, new Node(2, new Node(3, null))), prev = null;
while (cur != null)
{
Node? next = cur.Next; // save it before relinking
cur.Next = prev;
prev = cur;
cur = next;
}
Console.WriteLine($"{prev!.Value} {prev.Next!.Value} {prev.Next.Next!.Value}");
```

It prints 3 2 1. O(n) time, O(1) memory.
The other classic: fast and slow pointers (fast moves 2, slow moves 1) find the middle, or detect a cycle when they meet.

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

#tip · TIP-063

Question: You get a list of projects and a list of pairs (a, b): ...

2026-10-27T13:08:08Z

Question: You get a list of projects and a list of pairs (a, b): a must be built before b. Find an order to build all projects, or report that there is none.

Example: core before data, core before auth, data before web, auth before web, web before tests. A project docs has no rules.

(CtCI 4.7)

Try to answer before you open the reply.

#tg007 · TG-007-Q1

Count, for each project, how many projects it waits on. Projects ...

2026-10-27T13:08:08Z

In reply to nevent1q…x7sx
_________________________

Count, for each project, how many projects it waits on. Projects with 0 are ready: put them in a queue. Take one, add it to the order, and lower the count of every project that waits on it. A count that drops to 0 makes that project ready.

```csharp
var waitingOn = projects.ToDictionary(p => p, p => deps.Count(x => x.After == p));
var ready = new Queue<string>(projects.Where(p => waitingOn[p] == 0));
var order = new List<string>();
while (ready.TryDequeue(out var p))
{
order.Add(p);
foreach (var x in deps.Where(x => x.Before == p))
if (--waitingOn[x.After] == 0) ready.Enqueue(x.After);
}
Console.WriteLine(order.Count == projects.Length ? string.Join(" ", order) : "cycle");
```

It prints core docs data auth web tests.

This is a topological sort (Kahn's algorithm). Any order that keeps the rules is correct.

#tg007 · TG-007-A1

Learn: Scoped services in a singleton or BackgroundService A ...

2026-10-27T12:38:11Z

Learn: Scoped services in a singleton or BackgroundService

A BackgroundService is a singleton, but a DbContext is scoped. Injecting the DbContext directly would keep one DbContext forever.
Fix: inject IServiceScopeFactory. For each piece of work: create a scope, get the DbContext from it, and dispose the scope when done.
In Development, ASP.NET Core checks this for you (scope validation) and throws at startup if a singleton depends on a scoped service.

Read more: https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection

#tip · TIP-096

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

2026-10-27T12:07:55Z

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

Learn: Building strings in a loop A C# string can't change, ...

2026-10-27T11:37:50Z

Learn: Building strings in a loop

A C# string can't change, so result += text creates a brand new string every time and copies everything so far. In a loop that adds up to O(n²).

The docs warn that many repeated changes to a string cost a lot of performance. Use a StringBuilder, then call ToString() once at the end.

#tip · TIP-019

Question: A simpler version: at each node, call a separate ...

2026-10-27T11:07:58Z

Question: A simpler version: at each node, call a separate Height(left) and Height(right), compare them, then check both children the same way.

It is correct. What does it cost?

Try to answer before you open the reply.

#tg004 · TG-004-Q2

Height(subtree) visits every node of that subtree. Doing it at ...

2026-10-27T11:07:58Z

In reply to nevent1q…7te2
_________________________

Height(subtree) visits every node of that subtree. Doing it at every node means each node is counted once for each of its ancestors.

In a balanced tree, a node has about log n ancestors, so the check is O(n log n).

The one-pass version computes each height once and reuses it in the parent: O(n). Interviewers often ask for this improvement.

#tg004 · TG-004-A2

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

2026-10-27T10:37:53Z

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: ASP.NET Core Identity Identity is the built-in user ...

2026-10-27T10:07:52Z

Learn: ASP.NET Core Identity

Identity is the built-in user system: accounts, passwords, roles, email confirmation, lockout after failed logins, and two-factor login. Users can also log in with an external provider.
It stores passwords as PBKDF2 hashes (salted and repeated many times), never as plain text. Data goes through a pluggable store, usually EF Core with SQL Server. Lockout only counts failed logins when you pass lockoutOnFailure: true.
Main classes: UserManager (create users, check passwords, roles) and SignInManager (log in and out).

Read more: https://learn.microsoft.com/en-us/aspnet/core/security/authentication/identity

#tip · TIP-086

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

2026-10-27T09:38:00Z

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

Question: Why not just insert the values one by one, in the ...

2026-10-27T09:07:59Z

Question: Why not just insert the values one by one, in the array's order, into a normal binary search tree?

What tree do you get from 1, 2, 3, 4, 5, 6, 7?

Try to answer before you open the reply.

#tg002 · TG-002-Q3

Each new value is bigger than everything before it, so it always ...

2026-10-27T09:07:59Z

In reply to nevent1q…m0pk
_________________________

Each new value is bigger than everything before it, so it always goes right. You get a chain, like a linked list.

```csharp
Node? root = null;
for (int v = 1; v <= 7; v++) root = Insert(root, v);
Console.WriteLine(Height(root));

Node Insert(Node? n, int v)
{
if (n == null) return new Node(v);
if (v < n.Value) n.Left = Insert(n.Left, v); else n.Right = Insert(n.Right, v);
return n;
}
```

It prints 7: one level per value.

Searching that tree is O(n) instead of O(log n). Sorted input is the worst case for a plain BST, and it is common in real data.

#tg002 · TG-002-A3

Learn: Hashing rules in C# Equal objects must have equal hash ...

2026-10-27T08:37:51Z

Learn: Hashing rules in C#

Equal objects must have equal hash codes, so if you override Equals, override GetHashCode too. Records do both for you.
Don't read a missing key with dict[key]: it throws KeyNotFoundException. Use TryGetValue.
Lookups are O(1) on average, but O(n) in the worst case, when many keys collide.

```csharp
var ages = new Dictionary<string, int> { ["ann"] = 30 };
Console.WriteLine(ages.TryGetValue("bob", out int age) ? age : -1);
var set = new HashSet<Point> { new Point(1, 2) };
Console.WriteLine(set.Contains(new Point(1, 2)));
```

It prints -1 (no bob), then True (records compare by value).

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

#tip · TIP-065

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

2026-10-27T07:37:55Z

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

It never stops. Node 5 can't be reached, so the search never ...

2026-10-27T07:07:59Z

In reply to nevent1q…w6kn
_________________________

It never stops. Node 5 can't be reached, so the search never returns true. Meanwhile the cycle 1 → 2 → 4 → 1 keeps putting the same nodes back in the queue, forever.

The seen set is what makes the search finish: each node goes into the queue at most once.

Add the node to seen when you enqueue it, not when you dequeue it. Otherwise the same node can sit in the queue many times.

#tg001 · TG-001-A3

Question: In HasRoute, remove the seen set and enqueue every ...

2026-10-27T07:07:59Z

Question: In HasRoute, remove the seen set and enqueue every neighbor.

What happens for HasRoute(1, 5) on the same graph (1→2, 2→3, 2→4, 4→1)?

Try to answer before you open the reply.

#tg001 · TG-001-Q3

Learn: Grid problems: flood fill How to walk a grid in four ...

2026-10-27T06:37:53Z

In reply to naddr1qq…fp28
_________________________

Learn: Grid problems: flood fill

How to walk a grid in four directions, stay inside the bounds, and count connected areas.

Read the full article:

quoting naddr1qq…hmrd

Grid problems: flood fill

Many interview questions give you a grid of cells: a map, an image, a maze. The key move is flood fill: from one cell, visit every connected cell of the same kind.

Counting areas

Count the separate areas of 1s (cells connected up, down, left or right):
string[] map = { "11000", "11001", "00001" };
int rows = map.Length, cols = map[0].Length, areas = 0; var seen = new bool[rows, cols];
for (int r = 0; r < rows; r++) for (int c = 0; c < cols; c++)
    if (map[r][c] == '1' && !seen[r, c]) { areas++; Fill(r, c); }
Console.WriteLine(areas);
void Fill(int r, int c)
{
    if (r < 0 || c < 0 || r >= rows || c >= cols || seen[r, c] || map[r][c] == '0') return;
    seen[r, c] = true; Fill(r + 1, c); Fill(r - 1, c); Fill(r, c + 1); Fill(r, c - 1);
}
It prints 2: one area of four cells top-left, and one of two cells on the right.

The pattern

Loop over every cell.

When you find an unvisited 1, count a new area and flood-fill it.

The fill marks cells as seen and spreads in four directions.

Check the bounds first (row and column inside the grid) before reading a cell; this is where most bugs are.

Cost

Each cell is visited a constant number of times: O(rows × cols) time. The seen grid is O(rows × cols) memory. The recursion can go as deep as the area is big; for very large grids, use a queue (breadth-first) instead of recursion.

C# note

int[,] is one rectangular block; int[][] (jagged) is an array of arrays, where rows can differ in length. Many online judges give you jagged arrays.

Read more: https://www.geeksforgeeks.org/dsa/matrix/

#tip · TIP-069

#tip · TIP-069

Learn: IDisposable and using Some objects hold things the garbage ...

2026-10-27T06:07:57Z

Learn: Making microservices resilient Timeouts, retries with ...

2026-10-26T19:37:57Z

In reply to naddr1qq…yuje
_________________________

Learn: Making microservices resilient

Timeouts, retries with backoff, circuit breakers, idempotency and the outbox: how services survive each other's failures.

Read the full article:

quoting naddr1qq…a08n

Making microservices resilient

In a microservice system, some call always fails somewhere: a service restarts, the network hiccups, a database is slow. Design for these partial failures instead of hoping they don't happen.

The toolbox

Timeout: never wait forever for another service. A slow dependency must not hold your threads and requests.

Retry with backoff: retry short, temporary failures, waiting longer each time (for example 200 ms, 400 ms, 800 ms) and adding a little randomness (jitter), so many clients don't retry at the same moment.

Circuit breaker: after many failures, stop calling the broken service for a while and fail fast. Then try again carefully.

Bulkhead: limit how many calls can go to one dependency, so one slow service can't use up everything.

Fallback: return a cached or default answer when a call fails.

In .NET, Microsoft.Extensions.Http.Resilience (built on Polly) adds these to HttpClient in a few lines.

A retry, by hand
int calls = 0;
Console.WriteLine(await RetryAsync(() => ++calls < 3 ? throw new HttpRequestException("busy") : Task.FromResult("ok")));
async Task<string> RetryAsync(Func<Task<string>> action)
{
    for (int attempt = 1; ; attempt++)
    {
        try { return await action(); }
        catch (HttpRequestException) when (attempt < 5) { await Task.Delay(10 * (1 << attempt)); } // wait longer each time
    }
}
It prints ok: the first two calls fail, the third succeeds, with a growing wait between tries.

Data across services

Idempotency: retries mean the same request can arrive twice. Make handlers safe to repeat, for example with a request ID.

Outbox: save the business change and the message to send in the same database transaction; a background job publishes the messages. No lost events, but a message may be published twice, so consumers must be idempotent.

Saga: a business process across services is a series of local steps, each with a compensating step to undo it if a later step fails.

At the edge

An API gateway gives clients one entry point and handles routing, authentication and rate limiting for the services behind it.

Read more: https://learn.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/

#tip · TIP-099

#tip · TIP-099

Learn: Queue<T>: first in, first out A queue gives items ...

2026-10-26T19:08:02Z

Learn: Queue<T>: first in, first out

A queue gives items back in the order they came in. Enqueue adds at the back, Dequeue removes from the front, and Peek looks at the front without removing it.

```csharp
var q = new Queue<string>();
q.Enqueue("first"); q.Enqueue("second");
Console.WriteLine(q.Peek());
Console.WriteLine(q.Dequeue() + " " + q.Dequeue());
```

It prints first, then first second.

Queues are the tool for "handle in order of arrival": jobs, messages, and breadth-first search.

#sq006 · SQ-006-N

Learn: Concurrency vs parallelism Concurrency: several tasks are ...

2026-10-26T18:38:04Z

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

2026-10-26T18:08:16Z

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

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

2026-10-26T17:37:56Z

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

Learn: Which end of a Stack<T> is the top? new ...

2026-10-26T17:08:02Z

Learn: Which end of a Stack<T> is the top?

new Stack<int>(items) pushes the items in order, so the last item ends up on top.

foreach, ToArray and string.Join all go from the top down, not in the order you added the items.

```csharp
var s = new Stack<int>(new[] { 1, 2, 3 });
Console.WriteLine(s.Peek());
Console.WriteLine(string.Join(" ", s));
```

It prints 3, then 3 2 1.

This catches people when they print a stack to check their answer, so say "read from the top".

#sq005 · SQ-005-N

Learn: From recursion to memoization Plain recursive Fibonacci ...

2026-10-26T16:37:57Z

Learn: From recursion to memoization

Plain recursive Fibonacci recomputes the same values again and again: O(2ⁿ). Remember each answer the first time, and every value is computed once: O(n).

```csharp
var memo = new Dictionary<int, long>();
Console.WriteLine(Fib(60));
long Fib(int n)
{
if (n < 2) return n;
if (memo.TryGetValue(n, out long known)) return known;
return memo[n] = Fib(n - 1) + Fib(n - 2);
}
```

It prints 1548008755920 at once. Plain recursion would take hours for n = 60.
This is the first step of dynamic programming: overlapping subproblems + a cache.

Read more: https://www.geeksforgeeks.org/dsa/recursion-algorithms/

#tip · TIP-097

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

2026-10-26T16:08:09Z

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: Singleton One instance for the whole app, with a global ...

2026-10-26T15:37:57Z

Learn: Singleton

One instance for the whole app, with a global access point.

```csharp
Console.WriteLine(ReferenceEquals(Config.Instance, Config.Instance));

sealed class Config
{
private static readonly Lazy<Config> instance = new(() => new Config());
public static Config Instance => instance.Value;
private Config() { }
}
```

It prints True: both reads return the same object. Lazy<T> creates it once, on first use, even with many threads; the object itself must still be thread-safe.
In ASP.NET Core, prefer AddSingleton in DI: same effect, easier to test. Watch out: singletons are shared global state.

Read more: https://www.geeksforgeeks.org/system-design/singleton-design-pattern/

#tip · TIP-051

Case 1: the node has a right subtree. The next node is the ...

2026-10-26T15:08:10Z

In reply to nevent1q…4ept
_________________________

Case 1: the node has a right subtree. The next node is the leftmost node of that subtree.

Case 2: no right subtree. Climb up while you are a right child. The first parent you reach from its left side is the next node.

```csharp
var root = Tree(20, Tree(10, Tree(5), Tree(15)), Tree(30));
var asked = new[] { root.Left!, root.Left!.Right!, root.Right! };
Console.WriteLine(string.Join(" ", asked.Select(n => Successor(n)?.Value.ToString() ?? "none")));

PNode? Successor(PNode n)
{
if (n.Right != null) { n = n.Right; while (n.Left != null) n = n.Left; return n; }
while (n.Parent != null && n == n.Parent.Right) n = n.Parent; // climb while n is a right child
return n.Parent;
}
```

It prints 15 20 none. From 15 you climb to 10, then reach 20 from its left side.

O(height) time, O(1) memory.

#tg006 · TG-006-A1

Question: In a binary search tree, each node also has a link to ...

2026-10-26T15:08:10Z

Question: In a binary search tree, each node also has a link to its parent. Given a node, find the next node in sorted (in-order) order.

There are two cases. What are they?

(CtCI 4.6)

Try to answer before you open the reply.

#tg006 · TG-006-Q1

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

2026-10-26T14:38:13Z

Learn: Scoped services in a singleton or BackgroundService A ...

2026-10-26T14:07:59Z

Learn: Factory A factory creates objects for you, so the caller ...

2026-10-26T13:37:59Z

Learn: Factory

A factory creates objects for you, so the caller asks for "a pdf exporter" without naming the class.

```csharp
Console.WriteLine(Create("pdf").Export());
static IExporter Create(string kind) => kind switch
{
"pdf" => new PdfExporter(),
"csv" => new CsvExporter(),
_ => throw new ArgumentException(kind),
};
interface IExporter { string Export(); }
class PdfExporter : IExporter { public string Export() => "PDF file"; }
class CsvExporter : IExporter { public string Export() => "CSV file"; }
```

It prints PDF file.
Use it when: which class to create depends on input or configuration, or creating it is complicated.

Read more: https://www.geeksforgeeks.org/system-design/factory-method-for-designing-pattern/

#tip · TIP-052

Question: Check whether a binary tree is a binary search tree. ...

2026-10-26T13:07:54Z

Question: Check whether a binary tree is a binary search tree. Assume all values are different.

What must be true for every node, and how do you check it?

(CtCI 4.5)

Try to answer before you open the reply.

#tg005 · TG-005-Q1

Every node must be bigger than everything in its left subtree and ...

2026-10-26T13:07:54Z

In reply to nevent1q…nt5l
_________________________

Every node must be bigger than everything in its left subtree and smaller than everything in its right subtree. Pass down the allowed range (min, max). Going left, the node's value becomes the new max. Going right, it becomes the new min.

```csharp
var good = new Node(5, new Node(3, null, new Node(4)), new Node(8));
var bad = new Node(5, new Node(3, null, new Node(6)), new Node(8));
Console.WriteLine($"{IsBst(good, null, null)} {IsBst(bad, null, null)}");

bool IsBst(Node? n, int? min, int? max) =>
n == null ||
(min == null || n.Value > min) && (max == null || n.Value < max)
&& IsBst(n.Left, min, n.Value) && IsBst(n.Right, n.Value, max);
```

It prints True False. In the bad tree, 6 is right of 3 but on the left side of 5.

O(n) time. null means "no limit yet"; using int.MinValue and int.MaxValue as limits would wrongly reject a tree that holds those values.

#tg005 · TG-005-A1

Learn: Queues decouple services Put a message queue between a ...

2026-10-26T12:37:55Z

Learn: Queues decouple services

Put a message queue between a service that produces work and one that does it. The producer doesn't wait, and a slow consumer just builds a backlog instead of failing.

Most queues deliver "at least once", so a message can arrive twice. Make consumers idempotent (same result when repeated): processing the same message twice must be safe.

#tip · TIP-018

Learn: Authentication vs authorization Authentication: who are ...

2026-10-26T12:08:13Z

Learn: Authentication vs authorization

Authentication: who are you? (login, a cookie, a token)
Authorization: what may you do? (roles, policies)
On a protected endpoint: no valid login → 401; logged in but not allowed → 403. (Cookie login redirects web pages to a login page; since .NET 10, API endpoints get 401/403.)

```csharp
var identity = new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, "ann"), new Claim(ClaimTypes.Role, "Admin") }, "demo");
var user = new ClaimsPrincipal(identity);
Console.WriteLine($"{user.Identity!.IsAuthenticated} {user.IsInRole("Admin")} {user.IsInRole("Billing")}");
```

It prints True True False. IsAuthenticated is true only because an authentication type ("demo") was given. ASP.NET Core builds this ClaimsPrincipal for every request (HttpContext.User).

Read more: https://learn.microsoft.com/en-us/aspnet/core/security/authentication/

#tip · TIP-083

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

2026-10-26T11:38:07Z

In reply to naddr1qq…ah98
_________________________

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…xjh2

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

Yes. Pass the depth down. When a call reaches a depth for the ...

2026-10-26T11:07:57Z

In reply to nevent1q…qycl
_________________________

Yes. Pass the depth down. When a call reaches a depth for the first time, add a new list. Then add the node's value to the list for its depth.

```csharp
var levels = new List<List<int>>();
Visit(new Node(1, new Node(2, new Node(4)), new Node(3, null, new Node(5))), 0);
Console.WriteLine(string.Join(" | ", levels.Select(l => string.Join(" ", l))));
void Visit(Node? n, int depth)
{
if (n == null) return;
if (depth == levels.Count) levels.Add([]); // first node seen at this depth
levels[depth].Add(n.Value);
Visit(n.Left, depth + 1); Visit(n.Right, depth + 1);
}
```

It prints 1 | 2 3 | 4 5, the same as before. Left is visited before right, so each list is in left-to-right order.

#tg003 · TG-003-A2

Question: Can you get the same lists with a depth-first walk ...

2026-10-26T11:07:57Z

Question: Can you get the same lists with a depth-first walk (recursion) instead of going level by level?

What extra information does each call need?

Try to answer before you open the reply.

#tg003 · TG-003-Q2

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

2026-10-26T10:37:49Z

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: Two pointers Two indexes walk the data instead of nested ...

2026-10-26T10:07:56Z

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

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

2026-10-26T09:38:01Z

Question: A teammate wants to store the arrival time ...

2026-10-26T09:07:58Z

Question: A teammate wants to store the arrival time (DateTime.UtcNow) instead of a counter.

What can go wrong?

Try to answer before you open the reply.

#sq006 · SQ-006-Q3

Two devices that arrive very close together can get the same ...

2026-10-26T09:07:58Z

In reply to nevent1q…ak8q
_________________________

Two devices that arrive very close together can get the same time, because the clock has a limited resolution. Then TakeAny can't tell which came first.

On a server the clock can also be adjusted, so a later arrival could even get an earlier time.

A counter has neither problem: every arrival gets a new, bigger number. You can still store the time as well, for display.

#sq006 · SQ-006-A3

Learn: Making microservices resilient Timeouts, retries with ...

2026-10-26T08:38:03Z

In reply to naddr1qq…757x
_________________________

Learn: Making microservices resilient

Timeouts, retries with backoff, circuit breakers, idempotency and the outbox: how services survive each other's failures.

Read the full article:

quoting naddr1qq…l0j8

Making microservices resilient

In a microservice system, some call always fails somewhere: a service restarts, the network hiccups, a database is slow. Design for these partial failures instead of hoping they don't happen.

The toolbox

Timeout: never wait forever for another service. A slow dependency must not hold your threads and requests.

Retry with backoff: retry short, temporary failures, waiting longer each time (for example 200 ms, 400 ms, 800 ms) and adding a little randomness (jitter), so many clients don't retry at the same moment.

Circuit breaker: after many failures, stop calling the broken service for a while and fail fast. Then try again carefully.

Bulkhead: limit how many calls can go to one dependency, so one slow service can't use up everything.

Fallback: return a cached or default answer when a call fails.

In .NET, Microsoft.Extensions.Http.Resilience (built on Polly) adds these to HttpClient in a few lines.

A retry, by hand
int calls = 0;
Console.WriteLine(await RetryAsync(() => ++calls < 3 ? throw new HttpRequestException("busy") : Task.FromResult("ok")));
async Task<string> RetryAsync(Func<Task<string>> action)
{
    for (int attempt = 1; ; attempt++)
    {
        try { return await action(); }
        catch (HttpRequestException) when (attempt < 5) { await Task.Delay(10 * (1 << attempt)); } // wait longer each time
    }
}
It prints ok: the first two calls fail, the third succeeds, with a growing wait between tries.

Data across services

Idempotency: retries mean the same request can arrive twice. Make handlers safe to repeat, for example with a request ID.

Outbox: save the business change and the message to send in the same database transaction; a background job publishes the messages. No lost events, but a message may be published twice, so consumers must be idempotent.

Saga: a business process across services is a series of local steps, each with a compensating step to undo it if a later step fails.

At the edge

An API gateway gives clients one entry point and handles routing, authentication and rate limiting for the services behind it.

Read more: https://learn.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/

#tip · TIP-099

#tip · TIP-099

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

2026-10-26T08:04:58Z

In reply to naddr1qq…q5e6
_________________________

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…w9gx

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: The classic async deadlock In UI apps and classic ASP.NET ...

2026-10-26T07:37:56Z

Learn: The classic async deadlock

In UI apps and classic ASP.NET there is a SynchronizationContext: code after an await must continue on the original thread.
If that thread calls task.Result, it blocks and waits for the task. The task finishes its await and needs that same thread to continue. Each waits for the other: deadlock.
Fixes: await instead of .Result. In library code, add .ConfigureAwait(false) so it doesn't need the original thread.
ASP.NET Core has no SynchronizationContext, so it doesn't deadlock this way.

Read more: https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/

#tip · TIP-089

Interviewer's follow-up: "Now you may use any data ...

2026-10-26T07:07:48Z

Interviewer's follow-up: "Now you may use any data structure you like."

How do you sort the stack faster, and what does it cost?

Try to answer before you open the reply.

#sq005 · SQ-005-Q3

Copy the values to an array, sort it, and push them back largest ...

2026-10-26T07:07:48Z

In reply to nevent1q…t5e6
_________________________

Copy the values to an array, sort it, and push them back largest first, so the smallest ends on top.

```csharp
var s = new Stack<int>(new[] { 5, 1, 4, 2 });
int[] a = s.ToArray();
Array.Sort(a);
s.Clear();
for (int i = a.Length - 1; i >= 0; i--) s.Push(a[i]); // largest first, so smallest ends on top
Console.WriteLine(string.Join(" ", s));
```

It prints 1 2 4 5.

The docs say Array.Sort "is an O(n log n) operation". Copying in and out is O(n), so the total is O(n log n) time and O(n) extra memory.

#sq005 · SQ-005-A3

Learn: From recursion to memoization Plain recursive Fibonacci ...

2026-10-26T06:37:56Z

Learn: Decorator Wrap an object in another object of the same ...

2026-10-26T06:07:57Z

Learn: Decorator

Wrap an object in another object of the same type that adds behavior before or after it.

```csharp
INotifier n = new Loud(new Plain());
Console.WriteLine(n.Send("hi"));

interface INotifier { string Send(string m); }
class Plain : INotifier { public string Send(string m) => m; }
class Loud(INotifier inner) : INotifier { public string Send(string m) => inner.Send(m).ToUpper() + "!"; }
```

It prints HI!.
You already use it: GZipStream wraps another Stream and adds compression. (ASP.NET Core middleware is a similar wrapping idea, usually called a pipeline.) Use it to add logging, caching or retries without changing the original class.

Read more: https://www.geeksforgeeks.org/system-design/decorator-pattern/

#tip · TIP-055

Learn: volatile Without it, the compiler or CPU may keep reusing ...

2026-10-25T19:37:53Z

Learn: volatile

Without it, the compiler or CPU may keep reusing an old read of a field, so a loop can miss a "stop" flag that another thread set. volatile makes every read and write go to the field itself (the compiler can't keep an old copy), and limits how those reads and writes are reordered.
What it doesn't do: make count++ safe (use Interlocked or lock), or guarantee the very latest value on every processor.
For stopping work, prefer a CancellationToken.

Read more: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/volatile

#tip · TIP-090

Learn: Amortized O(1) "Amortized" means the average cost ...

2026-10-25T19:07:58Z

Learn: Amortized O(1)

"Amortized" means the average cost per operation over a long run, even if a few operations are slow.

List<T>.Add is the classic case. The docs say: "If Count is less than Capacity, this method is an O(1) operation." When the list is full, it "becomes an O(n) operation", because it copies everything into a bigger array.

The capacity doubles each time (in a test run it went 4, 8, 16, 32), so copies get rarer as the list grows. For n adds the copies sum to less than 2n, so Add is amortized O(1).

The queue made of two stacks works the same way: each value is moved at most once.

Source: https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.list-1.add

#sq004 · SQ-004-N

Learn: async and await await pauses this method until a task ...

2026-10-25T18:37:57Z

Learn: async and await

await pauses this method until a task finishes, and frees the thread while it waits. The task itself was already started.
Start independent work first, then await it together, and the waits overlap:

```csharp
var watch = System.Diagnostics.Stopwatch.StartNew();
Task first = Task.Delay(200), second = Task.Delay(200);
await Task.WhenAll(first, second);
Console.WriteLine(watch.ElapsedMilliseconds < 350 ? "ran together" : "ran one after another");
```

It prints ran together: two 200 ms waits took about 200 ms, not 400.
In ASP.NET Core, async endpoints let one server handle many more requests.

Read more: https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/

#tip · TIP-046

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

2026-10-25T18:07:53Z

Learn: Mutex A Mutex is a lock that can also work across ...

2026-10-25T17:37:55Z

Learn: Mutex

A Mutex is a lock that can also work across processes when you give it a name. Example: allow only one copy of your app to run.
It has thread affinity (it belongs to one thread): only the thread that took it can release it.

```csharp
var m = new Mutex();
m.WaitOne();
var t = new Thread(() =>
{
try { m.ReleaseMutex(); } catch (ApplicationException) { Console.WriteLine("only the owner can release"); }
});
t.Start(); t.Join();
m.ReleaseMutex();
```

It prints only the owner can release. Don't hold a Mutex across await: the code after it may run on another thread, which can't release it. Without a name, use lock instead: it is much faster.

Read more: https://learn.microsoft.com/en-us/dotnet/standard/threading/overview-of-synchronization-primitives

#tip · TIP-076

Learn: Index from the end with ^ In C#, list[^1] is the last ...

2026-10-25T17:07:50Z

Learn: Index from the end with ^

In C#, list[^1] is the last item, and list[^2] the one before it. It is short for list[list.Count - 1].

```csharp
var list = new List<string> { "a", "b", "c" };
Console.WriteLine(list[^1]);
Console.WriteLine(list[^2]);
```

It prints c, then b.

It works on arrays, List<T> and strings. On an empty list, list[^1] throws, like list[list.Count - 1] would.

#sq003 · SQ-003-N

Learn: Sorting cheat sheet Costs, memory and stability of the ...

2026-10-25T16:37:55Z

In reply to naddr1qq…nuxk
_________________________

Learn: Sorting cheat sheet

Costs, memory and stability of the common sorts, and what C#'s built-in sorts really do.

Read the full article:

quoting naddr1qq…gccd

Sorting cheat sheet

Sort Average Worst Extra memory Stable? Good for

Bubble O(n²) O(n²) O(1) yes teaching, tiny arrays

Insertion O(n²) O(n²) O(1) yes small or nearly sorted data

Merge O(n log n) O(n log n) O(n) yes linked lists, stable sorting

Quick O(n log n) O(n²) O(log n) no fast in practice on arrays

Heap O(n log n) O(n log n) O(1) no guaranteed O(n log n) in place

Stable means equal items keep their original order. It matters when you sort by one field after another (sort by name, then by age).

What C# does

Array.Sort and List<T>.Sort are O(n log n) but not stable.

LINQ OrderBy / ThenBy is stable.

Both take a custom order: a comparison or a key.
var people = new List<(string Name, int Age)> { ("Ann", 30), ("Bob", 25), ("Cy", 30) };
var byAge = people.OrderBy(p => p.Age).Select(p => p.Name); // stable: Ann stays before Cy
Console.WriteLine(string.Join(" ", byAge));
int[] nums = { 3, 1, 2 };
Array.Sort(nums, (a, b) => b.CompareTo(a)); // custom order: largest first
Console.WriteLine(string.Join(" ", nums));
It prints Bob Ann Cy (Ann stays before Cy: stable), then 3 2 1 (largest first).

Interview tips

Say the cost and whether it is stable.

"Why is quick sort usually fast but O(n²) at worst?" Bad pivots split the array unevenly, for example always picking the first item of sorted data.

Sorting first often makes the rest easy (two pointers, duplicates next to each other), but adds O(n log n).

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

#tip · TIP-067

Sort	Average	Worst	Extra memory	Stable?	Good for
Bubble	O(n²)	O(n²)	O(1)	yes	teaching, tiny arrays
Insertion	O(n²)	O(n²)	O(1)	yes	small or nearly sorted data
Merge	O(n log n)	O(n log n)	O(n)	yes	linked lists, stable sorting
Quick	O(n log n)	O(n²)	O(log n)	no	fast in practice on arrays
Heap	O(n log n)	O(n log n)	O(1)	no	guaranteed O(n log n) in place

#tip · TIP-067

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

2026-10-25T16:07:58Z

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

2026-10-25T15:37:52Z

Let one recursive function return the height of a subtree, or ...

2026-10-25T15:08:09Z

In reply to nevent1q…7k0d
_________________________

Let one recursive function return the height of a subtree, or −1 when it has found an unbalanced node. A parent that gets −1 from a child just passes −1 up.

```csharp
var ok = new Node(1, new Node(2, new Node(4)), new Node(3));
var bad = new Node(1, new Node(2, new Node(3, new Node(4))));
Console.WriteLine($"{Check(ok) != -1} {Check(bad) != -1}");

int Check(Node? n) // the height, or -1 if some subtree is unbalanced
{
if (n == null) return 0;
int l = Check(n.Left), r = Check(n.Right);
return l < 0 || r < 0 || Math.Abs(l - r) > 1 ? -1 : 1 + Math.Max(l, r);
}
```

It prints True False.

Each node is visited once, so it is O(n) time, plus O(height) for the call stack.

#tg004 · TG-004-A1

Question: A binary tree is balanced if, at every node, the ...

2026-10-25T15:08:09Z

Question: A binary tree is balanced if, at every node, the heights of the left and right subtrees differ by at most 1.

Write a check that visits each node only once.

(CtCI 4.4)

Try to answer before you open the reply.

#tg004 · TG-004-Q1

Learn: Concurrency vs parallelism Concurrency: several tasks are ...

2026-10-25T14:33:00Z

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

2026-10-25T14:07:55Z

Learn: Divide and conquer The pattern: split the problem into ...

2026-10-25T13:37:50Z

Learn: Divide and conquer

The pattern: split the problem into smaller parts of the same kind, solve each part (usually with recursion), then combine the answers.

Examples: merge sort (split, sort halves, merge), quick sort, binary search (keep only one half).

Why it helps: splitting in half again and again gives about log n levels, which is where the "log n" in O(n log n) comes from.

Read more: https://www.geeksforgeeks.org/dsa/divide-and-conquer/

#tip · TIP-036

Question: What is the time cost of building the tree from the ...

2026-10-25T13:08:00Z

Question: What is the time cost of building the tree from the middle, and how deep does the recursion go?

Try to answer before you open the reply.

#tg002 · TG-002-Q2

Time: O(n). Each call creates one node and does O(1) work besides ...

2026-10-25T13:08:00Z

In reply to nevent1q…4833
_________________________

Time: O(n). Each call creates one node and does O(1) work besides its two recursive calls, and each value becomes exactly one node.

Recursion depth: O(log n), because each call works on half the range. That is also the height of the tree.

No copying is needed: pass lo and hi indexes instead of making smaller arrays. Copying sub-arrays would add O(n log n) work.

#tg002 · TG-002-A2

Learn: Factory A factory creates objects for you, so the caller ...

2026-10-25T12:38:07Z

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

2026-10-25T12:08:03Z

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: Brute force first, then improve If you don't see the ...

2026-10-25T11:38:01Z

Learn: Brute force first, then improve

If you don't see the best solution right away, say the simple one first, with its Big-O. For example: "Check every pair: O(n²)."

Then ask yourself what work is repeated. A HashSet, sorting, or two pointers often removes it. A working slow answer beats an unfinished fast one.

#tip · TIP-003

Both are O(V + E) and both answer "is there a route?". ...

2026-10-25T11:07:55Z

In reply to nevent1q…5msp
_________________________

Both are O(V + E) and both answer "is there a route?".

Pick breadth-first when you also want the shortest route (fewest edges), or when the target is probably close: it explores in rings around the start.

Pick depth-first when you need to go deep anyway, for example to find cycles or a build order. It is short to write with recursion, but a very deep graph can overflow the call stack, so use your own Stack<T> for big inputs.

#tg001 · TG-001-A2

Question: Depth-first search would also work here. When would you ...

2026-10-25T11:07:55Z

Question: Depth-first search would also work here. When would you pick breadth-first, and when depth-first?

Try to answer before you open the reply.

#tg001 · TG-001-Q2