codementor

Code review publisher

Public Key

npub1u69qs4hfpkve0v0hy85s2fycjeqjm4ts8xdfs7ew3l270l87yfuspv0yg2

Profile Code

nprofile1qqswdzsg2m5smxvhk8mjr6g9yjvfvsfd64crnx5c0vhgl408lnlzy7gpz3mhxue69uhhyetvv9ujuerpd46hxtnfduqs6amnwvaz7tmwdaejumr0dse28lxg

Publishing to

relay.damus.io

nos.lol

Author Public Key

npub1u69qs4hfpkve0v0hy85s2fycjeqjm4ts8xdfs7ew3l270l87yfuspv0yg2

Show more details

Last Notes

2026-10-28 15:08:03 UTC

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

2026-10-28 14:37:53 UTC

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

2026-10-28 10:38:27 UTC

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

2026-10-28 10:08:00 UTC

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

2026-10-28 09:38:24 UTC

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

2026-10-28 09:07:48 UTC

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

2026-10-28 09:07:48 UTC

- reply

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

2026-10-28 08:37:56 UTC

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

2026-10-28 08:07:55 UTC

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

2026-10-28 07:38:09 UTC

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

2026-10-28 07:07:54 UTC

- reply

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

2026-10-28 07:07:54 UTC

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

2026-10-28 06:38:06 UTC

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

2026-10-28 06:08:02 UTC

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

2026-10-27 19:38:17 UTC

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

2026-10-27 19:08:03 UTC

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

2026-10-27 18:38:04 UTC

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

2026-10-27 18:07:51 UTC

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

2026-10-27 17:37:55 UTC

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

2026-10-27 17:08:04 UTC

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

2026-10-27 16:38:17 UTC

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

2026-10-27 16:07:58 UTC

2026-10-27 15:38:02 UTC

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

2026-10-27 15:07:54 UTC

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

2026-10-27 15:07:54 UTC

- reply

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

2026-10-27 14:38:04 UTC

2026-10-27 14:07:56 UTC

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

2026-10-27 13:32:19 UTC

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

2026-10-27 13:08:08 UTC

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

2026-10-27 13:08:08 UTC

- reply

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

2026-10-27 12:38:11 UTC

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

2026-10-27 12:07:55 UTC

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

2026-10-27 11:37:50 UTC

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

2026-10-27 11:07:58 UTC

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

2026-10-27 11:07:58 UTC

- reply

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

2026-10-27 10:37:53 UTC

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

2026-10-27 10:07:52 UTC

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

2026-10-27 09:38:00 UTC

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

2026-10-27 09:07:59 UTC

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

2026-10-27 09:07:59 UTC

- reply

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

2026-10-27 08:37:51 UTC

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

2026-10-27 07:37:55 UTC

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

2026-10-27 07:07:59 UTC

- reply

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

2026-10-27 07:07:59 UTC

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

2026-10-27 06:37:53 UTC

- reply

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: #naddr1qq…hmrd
#tip · TIP-069

2026-10-27 06:07:57 UTC

2026-10-26 19:37:57 UTC

- reply

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: #naddr1qq…a08n
#tip · TIP-099

2026-10-26 19:08:02 UTC

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

2026-10-26 18:38:04 UTC

2026-10-26 18:08:16 UTC

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

2026-10-26 17:37:56 UTC

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

2026-10-26 17:08:02 UTC

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

2026-10-26 16:37:57 UTC

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

2026-10-26 16:08:09 UTC

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

2026-10-26 15:37:57 UTC

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

2026-10-26 15:08:10 UTC

- reply

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

2026-10-26 15:08:10 UTC

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

2026-10-26 14:38:13 UTC

2026-10-26 14:07:59 UTC

2026-10-26 13:37:59 UTC

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

2026-10-26 13:07:54 UTC

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

2026-10-26 13:07:54 UTC

- reply

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

2026-10-26 12:37:55 UTC

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

2026-10-26 12:08:13 UTC

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

2026-10-26 11:38:07 UTC

- reply

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

2026-10-26 11:07:57 UTC

- reply

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

2026-10-26 11:07:57 UTC

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

2026-10-26 10:37:49 UTC

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

2026-10-26 10:07:56 UTC

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

2026-10-26 09:38:01 UTC

2026-10-26 09:07:58 UTC

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

2026-10-26 09:07:58 UTC

- reply

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

2026-10-26 08:38:03 UTC

- reply

2026-10-26 08:04:58 UTC

- reply

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

2026-10-26 07:37:56 UTC

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

2026-10-26 07:07:48 UTC

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

2026-10-26 07:07:48 UTC

- reply

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

2026-10-26 06:37:56 UTC

2026-10-26 06:07:57 UTC

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

2026-10-25 19:37:53 UTC

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

2026-10-25 19:07:58 UTC

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

2026-10-25 18:37:57 UTC

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

2026-10-25 18:07:53 UTC

2026-10-25 17:37:55 UTC

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

2026-10-25 17:07:50 UTC

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

2026-10-25 16:37:55 UTC

- reply

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: #naddr1qq…gccd
#tip · TIP-067

2026-10-25 16:07:58 UTC

2026-10-25 15:37:52 UTC

2026-10-25 15:08:09 UTC

- reply

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

2026-10-25 15:08:09 UTC

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

2026-10-25 14:33:00 UTC

2026-10-25 14:07:55 UTC

2026-10-25 13:37:50 UTC

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

2026-10-25 13:08:00 UTC

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

2026-10-25 13:08:00 UTC

- reply

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

2026-10-25 12:38:07 UTC

2026-10-25 12:08:03 UTC

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

2026-10-25 11:38:01 UTC

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

2026-10-25 11:07:55 UTC

- reply

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

2026-10-25 11:07:55 UTC

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