Drills

Aggregate errors by minute

Aggregates log entries into per-minute error counts with deterministic output.

Concept questionEasy~5 min

Choose between an array, List<T>, and LinkedList<T> in C#

Chooses a sequential collection from size, mutation, access pattern, memory locality, and the behavior callers actually need.

Choose between Join, ToLookup, and repeated scans

Avoids hidden quadratic work by indexing repeated matches while preserving duplicate, missing, ordering, and memory semantics.

Choose string comparers for keys, membership, and sorting

Separates ordinal identity comparison from culture-aware display ordering and keeps hash-based collection semantics consistent.

Architecture scenarioMedium~10 min

Choose the narrowest useful collection contract

Chooses between sequence, counted, indexed, set, and dictionary contracts based on required operations and complexity.

Coding problemEasy~15 min

Chunk items for batch processing

Implements chunking for batch processing without dropping final partial batches.

Collection operation complexity and real runtime costs

Uses complexity as a first filter while accounting for constants, locality, allocations, data size, and the complete operation sequence.

Deduplicate events by idempotency key

Implements duplicate suppression while preserving the first event for each idempotency key.

Concept questionEasy~5 min

Dictionary and HashSet hashing and equality in C#

Explains how hash-based collections use hash codes and equality, then chooses Dictionary or HashSet from the value the program needs to store.

Flatten a category tree to paths

Flattens a tree into display paths while preserving order and preventing simple cycles.

Group orders by customer summary

Builds customer summaries from order rows using grouping, aggregation, and deterministic ordering.

Code reviewMedium~10 min

How can intermediate collections create memory waste in .NET code?

Focuses on ToList chains, collection capacity, repeated enumeration, and memory-aware data shaping.

.NETASP.NET CoreC#

How yield iterators execute and clean up resources

Describes lazy iterator execution, state-machine behavior, early termination, resource disposal, and repeat-enumeration consequences.

Coding problemHard~35 min

Implement a simple LRU cache

Implements a small LRU cache using a dictionary plus linked list for O(1) get and put.

Concept questionHard~9 min

Know when a loop is clearer and faster than LINQ

Balances declarative transformations with explicit control flow when allocation, early exit, mutation, diagnostics, or complex state matters.

Debugging scenarioMedium~10 min

LINQ deferred execution and multiple enumeration

Predicts when an in-memory LINQ pipeline runs and prevents repeated work, changed results, and hidden side effects.

Materialize LINQ results at clear boundaries

Chooses when to keep a sequence lazy and when to create a stable collection with ToList, ToArray, or another deliberate materialization.

Merge overlapping time ranges

Implements interval merging for scheduling-style time ranges with sorted output.

Comparison questionMedium~7 min

Read-only views versus immutable collections

Separates restricted mutation access from a stable immutable value and chooses snapshots or structural sharing deliberately.

Return the top K frequent values

Implements top-K frequency selection with deterministic tie-breaking.

Shape data with Select, SelectMany, and GroupBy

Explains the output shape of core LINQ transformations and uses them without hiding empty groups, duplicate keys, or excessive buffering.

Streaming versus buffering LINQ operators

Distinguishes operators that can yield incrementally from operators that must consume substantial input before producing results.

Concept questionHard~9 min

Stream results with IAsyncEnumerable<T>

Uses async streams for incremental asynchronous production while preserving cancellation, disposal, backpressure expectations, and API boundaries.