Python Interview Questions
Python Interview Questions
Live-executed Python interview questions for data engineer roles, shaped like real pipeline code.
394 Python interview questions pulled from data engineer interview reports. Pipeline-shaped work: parsing malformed CSVs without crashing, deduplicating event streams by composite key with a proper tiebreaker, walking nested JSON with a recursive flattener, sessionizing event logs with itertools.groupby, writing retry decorators with exponential backoff plus jitter. Not LeetCode algorithm prep.
Python for data engineer roles is structurally different from Python for software engineer roles. About 4 percent of data engineer Python rounds resemble LeetCode algorithm puzzles. The other 96 percent are pipeline-shaped. The interviewer wants to see you parse a malformed CSV without crashing, deduplicate an event stream by composite key with a proper tiebreaker, walk a nested JSON with a recursive flattener that handles both lists-as-records and lists-as-attributes, sessionize an event log with itertools.groupby or a plain for-loop, write a retry decorator with exponential backoff plus random jitter (because without jitter every worker retries at the same later time and you have built a self-DDoS), and stream a 50GB file with a generator so memory stays constant regardless of input size.
The 394-question catalog mirrors the data engineer interview surface area. Data transformation problems are 29 percent of the bank (112 problems). Dict and set operations 16 percent (62). File parsing and IO 12 percent (45). String manipulation 10 percent (38). ETL flow control (router, batcher, retry decorator) 8 percent (32). Error handling with descriptive field-level errors 7 percent (28). Date and time including DST and timezone 6 percent (24). OOP and context managers 6 percent (22). Generators and lazy iteration 4 percent (15). Traditional DSA algorithms 2 percent (10), present for breadth but deliberately rare.
Library coverage. Vanilla Python is preferred in most data engineer rounds; the interviewer wants to see that you understand what pandas does under the hood. Pandas appears across most data engineer loops as a generic library question; a typical prompt is "implement SCD Type 2 merge logic in pandas". PySpark dominates at Spark-first companies (Databricks, Netflix, Uber, Airbnb, DoorDash, Spotify). Polars is rare in interviews but signals fluency when it comes up. The sandbox ships pandas, polars, numpy, pyarrow, json, csv, re, itertools, collections, heapq, datetime, requests, asyncio, and tenacity. ML libraries (scikit-learn, torch) are not in scope; this is data engineer practice, not ML engineer practice.
Every Python question runs in a real Python 3.11 sandbox with 5 to 15 test cases. Public tests are visible in the problem statement so the data engineer can read the input shape. Hidden tests reveal after the public ones pass and typically include empty input, single-element edge cases, Unicode user IDs (emoji and CJK characters break naive byte-counting), event timestamps at the DST boundary (which break naive timezone math), and a 100k-record performance test with a wall-clock budget that fails O(n-squared) solutions. The performance test is woven into the same problem statement, not separated; the same submission that fails on correctness fails on performance when the implementation is quadratic.
- Is this LeetCode-style Python algorithm prep?
- No. About 4 percent of data engineer Python rounds resemble LeetCode algorithm puzzles. The other 96 percent are pipeline-shaped: parsing malformed CSVs, deduplicating event streams by composite key, validating records with field-level errors, sessionizing event logs, writing retry decorators. The catalog reflects that distribution. The algorithms tier exists for breadth but is intentionally small.
- Does the Python code actually execute in the sandbox?
- Yes. Every submission runs in a real Python 3.11 sandbox with 5 to 15 test cases. Public tests are visible in the problem statement; hidden tests reveal after the public ones pass and include empty input, Unicode, DST boundary timestamps, and a performance budget that fails quadratic solutions on 100k records.
- Do I need to know pandas or PySpark for a data engineer Python round?
- Depends on the company. Pandas shows up across most data engineer interviews as a generic library question (a typical prompt: 'implement SCD Type 2 merge logic'). PySpark dominates at Spark-first companies: Databricks, Netflix, Uber, Airbnb. Polars is rare in interviews but signals fluency. The catalog covers both pandas and PySpark; the company-specific lists show which library each company actually tests.
- What Python idioms come up most in data engineer interview rounds?
- defaultdict and OrderedDict for grouped accumulation. csv.DictReader for tabular ingest. json with recursive flattening for nested payloads. itertools.groupby for sessionization. heapq.merge for streaming sorted merges. asyncio.Semaphore for rate-limited fetch. tenacity (or a hand-rolled decorator) for exponential backoff with random jitter. Most candidates write the longer for-loop version of these; that is fine. Mention the library equivalent.
- How many Python problems should a data engineer solve before an interview?
- 30 to 50 for a phone screen, 80 to 120 for an onsite, 150 or more for FAANG-level loops. Distribute across the high-frequency topics: data transformation, dict and set work, file parsing, error handling, date and time. Quality beats count. A problem you have solved, debugged, and re-derived a week later is worth five you skimmed once.
- How does the test runner show hidden case failures?
- After public tests pass, the runner reveals hidden tests one at a time with the input shape, the expected output shape, and the specific assertion that failed. For performance tests, wall-clock time and the threshold. For correctness, the diff between your output and expected with the first divergent element highlighted.
- Can I use third-party libraries beyond pandas and the stdlib?
- The sandbox ships pandas, polars, numpy, pyarrow, json, csv, re, itertools, collections, heapq, datetime, requests, asyncio, and tenacity. Spark problems run in a separate PySpark sandbox with the standard pyspark imports. ML libraries (scikit-learn, torch) are not in scope; this is data engineer practice, not ML engineer practice.
394 practice problems matching this filter. Difficulty: easy (184), medium (184), hard (26).
Python (394)
- Activity Time Ledger - easy - Matching activities. One runtime.
- Birds of a Feather - medium - Every record finds its kin; keep them in the order they arrived.
- Batch Records - medium - Too many at once. Break them into groups.
- Batch With Metadata - easy - The list gets chopped.
- Caesar Shift Check - easy - The key turns. Does it open?
- Letters in the Noise - easy - Case and punctuation are distractions. Find what each letter really weighs.
- Char Profile - medium - Every character in the string tells a story.
- The Fallback Layer - easy - When the live values come back empty, something has to stand in.
- Column Max - easy - One value rules the column.
- Column Range - easy - From minimum to maximum. What is the spread?
- All Told - easy - Every shift leaves a number behind. Total the fleet.
- Common Prefix - hard - They all start the same way. How far?
- Cumulative Sum - medium - The total grows with every row.
- Data Quality Report - hard - The data is not as clean as it looks.
- Deep Flatten - medium - Nested deep. Flatten everything.
- The Path Inward - medium - Every setting hides a few levels down. Follow the route, or come back empty.
- Detect Cycle in Sequence - medium - Follow the chain long enough and it might loop back.
- Detect Outliers - medium - Most values are normal. Some are suspicious.
- Diagonal Extract - medium - Not every value sits in a row or column.
- Dice Roll Scoring - medium - The pattern rewards the patient.
- Dictionary Key Intersection - medium - Two dictionaries. What do they share?
- Distribute Values Into Container Types - medium - Round-robin the values. Keep rotating.
- Dominant Element - easy - Majority element. Appears more than half the time.
- Even Filter - easy - Only the even ones survive.
- Execution Timer Wrapper - medium - Function wrapped with a timer. Duration captured on exit.
- Explode List - easy - One row holds many values. Unpack it.
- Extract Domain - easy - The domain is buried in the string.
- Extract Leaf Values - medium - The tree has leaves. Pluck them.
- Find Indices - medium - It is in there somewhere. Where exactly?
- Find Mode - medium - One value appears more than the rest.
- Who Came First - easy - The feed repeats itself. Keep each member only the first time it speaks.
- Flatten the Feed - easy - Nested lists, all the way down.
- Flatten the Nest - easy - Mixed nesting. One flat list out.
- Full Outer Zip - medium - Two sides. No value left behind.
- Greeting Formatter Class - easy - First impressions are formatted carefully.
- Group Average - hard - Same group, different values. What is typical?
- Group By - medium - Same key, different rows. Bring them together.
- Lag Column - medium - What came before this row?
- Left Join - medium - Keep the left side. Match what you can.
- Majority Event in Stream - medium - One event type is drowning out the rest. Find it without a frequency table.
- Max Length Token - medium - The longest token wins.
- Merge Counters - medium - Two tallies. Combine them.
- The Overlap - hard - Overlapping windows are one outage. Collapse them into the truth.
- Merge Overlapping Time Ranges - medium - Intervals piling up. Clean the timeline.
- Flat Memory - medium - Two sorted runs, one buffer, no scratch space. Fold them together where they already live.
- Normalize Name - easy - Names are messy. Standardize them.
- No Shortcuts - easy - The peak value. Built-ins off the table.
- Null Counter - easy - How many holes in the data?
- The Most Specific Rule Wins - medium - Every packet asks the same question of the firewall. Answer it the way the table intends.
- Ordered Character Check - easy - Check if all As appear before all Bs.
- Palindrome Hunt - medium - It reads the same both ways. Go further.
- Parse Log Line - medium - One line. A dozen fields hidden inside.
- Permissions Manager - medium - Manage user permissions with config updates.
- Pivot Records - hard - Long format is easy. Wide format is useful.
- Portfolio Profit Calculator - medium - Portfolio gain from purchase history and current prices.
- Precision and Recall - medium - Precision and recall. Both matter.
- Prefix Based Word Replacement - medium - Every word trimmed to its root.
- Progress Milestones - easy - Progress at every 10% increment. Keep the receipts.
- Quality Gate - easy - Not everything passes inspection.
- Quantile Calculator - easy - Mark the boundary value at a given point.
- Points of Order - medium - Every page makes its case for the top. Settle it, and settle the ties.
- Every Line on the Receipt - medium - Nested deep inside the receipt. Pull every item out.
- Record Filter - easy - Some records belong. Others do not.
- Rename Keys - medium - Old names out. New names in.
- Reverse Field - easy - Flip it. See what happens.
- Full Circle - medium - Load has to keep moving. Pass it down the line.
- Row Aggregates - medium - Each row holds its own summary.
- Run Length Encoding - easy - AAABBB becomes 3A3B. Compress it.
- Running Distinct Count - medium - New values keep appearing. Track the count.
- Sanitize Field - easy - Dirty input. Clean output.
- Schema Checker - easy - The schema says one thing. The data says another.
- Sequential Word Pairs - easy - Everything has a neighbor.
- Shortest Unique Metric Tag - medium - One token per metric. Make it unambiguous.
- Single Element Among Pairs - easy - One element has no partner.
- Sort Descending - easy - Biggest first. No exceptions.
- Stock Range Finder - medium - Prices move. One stretch had the widest gap.
- Stream-Process a Large CSV - hard - Too big to load. Read what you can.
- Subarray Signal - medium - One stretch carries the strongest signal.
- The Account Manager - easy - Deposits, withdrawals, and the risk of going negative.
- The Additive Chain - easy - Each value is the sum of the two before it - no calls to itself allowed.
- The Address Surgeon - easy - One string hides a street, a city, a state, and a zip.
- The Alphabet Score - easy - Every letter has a secret numeric value - what's your total?
- The Alphabet Sorter - easy - Filing cabinet logic: everything goes in its proper drawer.
- The Anomaly Detector - hard - Spot the outliers before they page someone.
- The Balanced Inspector - medium - Every branch should carry the same weight.
- The Balanced Sum - easy - Some numbers have a rare quality that mathematicians revere.
- The Bipartite Test - medium - Can this crowd be split into two perfectly separated groups?
- The Bit Counter - easy - How many lights are on in the binary representation?
- The Bit Ladder - easy - Count the ones all the way up.
- The Bit Reverser - medium - Sometimes the answer is literally backwards.
- The Bitwise Judge - easy - No division, no modulo - just a single bit tells you everything.
- The Blind Multiplier - medium - Compute the result of everything around you - without seeing yourself.
- The Bonus Round - medium - Consecutive matching dice rolls trigger a special scoring rule.
- The Bouncer - easy - Every door has a guest list.
- The Bracket Validator - easy - Brackets opened and closed. The nesting might be off.
- The Bronze Medalist - easy - Not first, not last - somewhere in the middle of the podium.
- The Budget Allocator - medium - Split the money. Some wore two hats.
- The Bug Spotter - easy - It compiles. The answer is still wrong.
- The Build Order - medium - Some tasks must wait for others to finish first.
- The Calendar Sort - easy - Time has its own opinion about order.
- The Carousel - easy - Keep moving, same ride.
- The Category Ranker - medium - Categories have standing. Rows get theirs.
- The Chain Builder - medium - Links connect in sequence - build the chain from scratch.
- The Chain Transform - medium - One small step at a time can cover a great distance.
- The Change Data Capture - hard - Inserts, updates, deletes : all present.
- The Change Tracker - medium - Before and after snapshots. The delta is in there.
- The Character Clans - medium - Words sharing the same letters belong to the same clan.
- The Character Encoder - easy - Squeeze a string down to its tightest form.
- The Character Map - easy - Character-level frequency. As a dictionary.
- The Chunked Reader - medium - Too big for memory. Read in pieces.
- The Cipher Wheel - easy - Every letter has an alias - you just need the right codebook.
- The Clock Angle - easy - Two hands. One gap. One number.
- The Clock Examiner - medium - Two hands on a clock - how wide is the gap?
- The Code Expander - easy - Compressed messages need a decoder to come alive.
- The Coin Vault - medium - Exact change only - and you want to use as few coins as possible.
- The Column Shuffle - medium - Rows in, columns out. Number them.
- The Column Transformer - easy - Each column gets its function.
- The Roll Call - easy - Every value is waiting for its name.
- The Complement Hunt - easy - Every number is looking for its other half.
- The Config Blender - easy - Config collision. The surviving values after a merge.
- The Consecutive Sequence Finder - medium - Numbers that flow without interruption.
- The Consecutive Streak - medium - Login streaks. No gaps allowed.
- The Counting Machine - medium - It knows where it stopped last time.
- The Crowd Favorite Eatery - easy - One restaurant clearly won the most hearts.
- The Crowd Pleaser - easy - One value shows up more than all others combined.
- The Crowd Splitter - easy - The middle holds even with a dominant outlier.
- The Custom Iterator - medium - Some sequences follow their own rules.
- The Cycle Detector - medium - Follow the chain long enough and you might end up where you started.
- The DAG Executor - hard - Wire up a mini pipeline and watch it run.
- The Date Sorter - medium - Jumbled calendar. Sort it first.
- The Decomposer - easy - Every composite thing can be broken down to its simplest parts.
- The Deep Config - medium - Nested config, dot-notation output.
- The Deep Dictionary - easy - One key goes further than the rest.
- The Deep Dive - easy - A specific position in the unsorted pile.
- The Deep Selector - easy - Tell it what you want. It knows where to look.
- The Deep Unpacker - easy - Boxes inside boxes. Eventually you reach the bottom.
- The Dependency Resolver - medium - Everything depends on everything.
- The Depth of Field - easy - Some containers hold containers that hold containers.
- The Diagonal Accountant - easy - Two diagonals cross in the center of every square.
- The Dict Comparator - medium - Two dictionaries. Subtle differences.
- The Mirror Index - easy - Every value remembers who pointed to it.
- The Dominant Signal - easy - Hottest items in the transaction log. Ties included.
- The Double-Ended Gateway - medium - Some queues let you skip the line from both ends.
- The Duplicate Spotter - easy - Some values appear more than once - report only those.
- The Dynamic Container - hard - Build your own resizable list with no help from the standard library.
- The Elevator Trace - medium - Nested floors. One path through.
- The Email Ranker - medium - Some inboxes see more action.
- The Encoded Signal - medium - The encoding is hiding multipliers. Decode it.
- The Even Checkpoint - easy - Is this number in the even club? Prove it the fast way.
- The Event Aggregator - medium - Bucket a firehose of events into tidy time windows.
- The Event Broadcaster - medium - Subscribers show up, listen, and sometimes leave.
- The Event Bucketer - easy - Logs slotted into buckets.
- The Event Overlap Detector - medium - Overlapping events. The calendar knows.
- The Event Window - medium - A five-minute window is all that matters.
- The Eviction Policy - medium - Fixed capacity. Oldest unused entry gets evicted.
- The Exception Handler - medium - Good code handles failure as gracefully as success.
- The Expander - easy - What goes in small comes out big.
- The Face That Breaks the Bank - medium - Roll enough dice and one number always runs away with it.
- The Family Reunion - medium - Two cousins share a common ancestor somewhere above.
- The Fast Climber - medium - Some routes up the mountain are faster than others.
- The Field Counter - easy - Some fields speak louder than others.
- The File Size Profiler - medium - File types and their disk footprint. One type dominates.
- The File Tree Builder - medium - Flat paths. Build the nested tree.
- The First Class Function - medium - Functions travel as values - prove you can pass one around.
- The First Encounter - easy - Every character has a story - but only if you remember where it started.
- The First Stranger - easy - In a crowd, the unique ones stand out first.
- The Flat Mapper - medium - Nested values. One flat stream out.
- The Forbidden Ceiling - easy - Round up. But not the obvious way.
- The Forbidden Sorter - medium - Put the letters in order without the obvious tool.
- The Forgetful Machine - medium - It remembers everything, until it does not.
- The Forward Fill - easy - Patch the gaps in a noisy sensor stream.
- The Frequency Eviction - hard - When storage is tight, something has to go.
- The Gap Filler - easy - Fill the Nones with the last real value.
- The Gap Reporter - medium - The missing IDs in the log - somebody has to notice.
- The Gate Keeper - easy - Not all openings have a closing.
- The Generous Ones - medium - The generous ones are obvious.
- The Genre Filter - medium - Three tables, two conditions, one actor's total.
- The Grid Pivot - easy - A different angle reveals a completely different picture.
- The Half-Life Search - medium - Every guess cuts the problem in half.
- The Halftime Score - easy - Middle value of a dataset. No built-in shortcuts.
- The Hash Stamper - easy - One input, one irreversible output - the foundation of every secret.
- The Hierarchy Builder - hard - Parent-child pairs, flat. Build the family tree.
- The High Mark - easy - Scan the list. Report the max.
- The High Rollers - medium - Not every gambler bets the same - some wager far more than others.
- The Horizon Scanner - medium - For each position, what is coming up ahead?
- The Hostile Takeover - medium - One dict eats another.
- The Host Ranker - medium - Some hosts have more to offer.
- The Hourly Bucket - medium - Timestamps belong somewhere.
- The Impersonator - medium - You only have stacks. Make a queue anyway.
- The Indivisibles - easy - Numbers that yield only to themselves.
- The Infection Spread - hard - It starts with one, and then it spreads.
- The Integer Sieve - easy - Not everything in this list belongs here.
- The Intervals - medium - Timestamps in buckets.
- The Inverted Triangle - medium - A pattern of stars narrows toward the bottom.
- The IP Validator - easy - Real and fake, mixed together.
- The Island Counter - medium - Surrounded by water, connected by land - how many separate landmasses?
- The Last Instance - easy - When duplicates appear, only the last one counts.
- The Last Seen Map - easy - For each character, where did it appear last?
- The Lazy Squares - easy - A sequence that never fully reveals itself.
- The Lazy Stream - hard - Yield values one at a time from a potentially infinite source.
- The Lazy Unpacker - medium - Instead of loading it all at once, yield it one piece at a time.
- The Letter Census - easy - Every crowd has its share of talkers and quiet ones.
- The Letter Frequency Map - easy - Count every character in the string and report the results.
- The Letter Kin - medium - Words that share the same letters belong together.
- The Letter Ledger - easy - Every character has a count to answer for.
- The Letter Mapper - medium - A consistent substitution, or not.
- The Letter Tally - easy - Each character in the string has a count to answer for.
- The Level Inspector - medium - Each floor of the tower tells a different story.
- The Level Summer - medium - Add up each level of the tree.
- The Line Cutter - easy - Did everyone with an A-pass get through before the B-crowd arrived?
- The Line Splitter - easy - Comma-separated truths, one at a time.
- The Link Shrinker - medium - Long addresses have aliases - you give them out, you keep the map.
- The List Merger - easy - No shortcuts.
- The Load Balancer - medium - Distribute incoming requests evenly across available servers.
- The Log Decoder - easy - Every line holds a secret.
- The Log Pulse - easy - Some lines repeat themselves.
- The Lone Character - easy - It appeared exactly one time. That made it special.
- The Lone Traveler - easy - One character stands apart from the crowd.
- The Manual Sorter - easy - No shortcuts, no built-ins, just work.
- The Map Reducer - medium - Map it. Reduce it. One answer.
- The Market Streak - medium - Some stocks run longer than you think.
- The Market Timer - medium - One buy, one sell - when do you make the most?
- The Matching Manifest - easy - Two warehouses, one shipment - only load what's in both.
- The Median Keeper - hard - The middle value keeps moving as new data arrives.
- The Meeting Room Allocator - hard - Meetings overlap on the calendar. Rooms are limited.
- The Merge - easy - Chaos in. Order out.
- The Merge Champion - medium - Many sorted rivers flowing into one.
- The Messy Pipeline - easy - The upstream API has no idea what a schema is.
- The Middle Ground - hard - The middle value keeps moving.
- The Min Tracker - medium - The stack remembers the best it ever saw.
- The Minutes Tracker - easy - Some activities eat more time than others.
- The Mirror Flip - easy - Sometimes the fastest fix is to swap everything.
- The Mirror Image - easy - Flip the tape backwards - start from the end.
- The Mirror Test - easy - Check if a string reads the same forwards and backwards.
- The Mirror Words - easy - Each word looks back at itself.
- The Missing Number - easy - Something is missing from the sequence.
- The Molecule Report - easy - Four letters. A lot of math hidden in the sequence.
- The Month-by-Month Snapshot - medium - Every salesperson has a story. The months just tell it sideways.
- The Mountain Peak - medium - The sequence has a summit.
- The Multiplication Trail - easy - Each step multiplies the whole journey.
- The Multiplier Rush - medium - Negatives cancel negatives - but only if you keep both in view.
- The Narrow Lens - medium - A narrow timeframe. Everything inside matters.
- The Nearest Value Mapper - medium - Close enough counts. Ties go low.
- The Never-Ending Sequence - easy - Sequence that keeps going. Follow it.
- The Numbered Chair - easy - A standing list. Position n holds one entry.
- The Number Miner - medium - JSON strings are hiding numeric secrets - dig them out.
- The Number Narrator - medium - Every number has a story in words.
- The Number Screen - easy - Some numbers make the cut. Most do not.
- The Odd Digits - easy - Hidden inside a mess of characters are a few odd numbers.
- The Odd Extractor - easy - Not all numbers from a string are welcome here.
- The Odd Filter - easy - Strip out everything that does not belong to the odd club.
- The One-of-Each - easy - Strip the repeats, keep the originals.
- The One-Timers - easy - Values that never repeated.
- The One-Way Street - easy - Monotonic time-series. Direction only.
- The Onion Layer - hard - Peel from the outside in - one ring at a time.
- The Online Elite - medium - The top performers are hiding in the data.
- The OOP Pillars Exam - medium - Four principles, one class hierarchy - show you know all of them.
- The Op Dispatcher - easy - Name the operation, apply it everywhere.
- The Order Enforcer - easy - Some rules say every A must come before every B.
- The Order Inspector - medium - A binary tree has rules - is this one actually following them?
- The Original Keeper - easy - Clean up duplicate events without losing the timeline.
- The Output Peak - hard - One stretch outpaced all the others.
- The Overlap Finder - easy - Two guest lists - who made it onto both?
- The Page Turner - medium - Nobody loads everything at once.
- The Pair Counter - easy - How many pairs can be formed from the crowd?
- The Paired Doors - easy - Every open bracket has a partner - but not every partner shows up.
- The Pandas Pivot - medium - Rows become columns. Columns become power.
- The Parentheses Factory - medium - Building balanced brackets is an art form.
- The Pascal Row - easy - Each number is the sum of two numbers above it.
- The Password Builder - easy - Random characters, fixed rules.
- The Password Forge - easy - Does this password pass the strength gate?
- The Pay Ladder - medium - Climb the ladder the hard way. No shortcuts allowed.
- The Payload Flattener - medium - Turn a deeply nested API response into a flat row.
- The Peak Finder - easy - Largest number in the list. Max() is not an option.
- The Perfect Match - medium - Two numbers walk into an interview...
- The Pipeline Filter - easy - In the door as one thing, out the door as another.
- The Placement Fixer - medium - Each value belongs in exactly one spot.
- The Postfix Processor - medium - Math without parentheses - the operators come after the numbers.
- The Precision Hunt - medium - Some answers need no decimal point.
- The Price Bander - easy - Different prices, different treatment.
- The Priority Queue - medium - When two things tie, something has to break the deadlock.
- The Progress Meter - medium - Report progress at every tenth of the way through.
- The Progress Parade - easy - Just tell them how far along you are.
- The Quarter Turn - medium - One rotation changes everything.
- The Queue Disguise - medium - A queue in sheep's clothing.
- The Ranked Dict - easy - Values deserve order too.
- The Record Reconciler - medium - Two versions of the same truth.
- The Repeat Offenders - easy - Repetition is a clue.
- The Repeat Review - medium - The echo came back.
- The Repeat Visitor - medium - Loyal customers come back sooner than expected.
- The Response Aggregator - medium - Multiple result pages. One clean summary.
- The Resume Sifter - medium - Pull what's useful. Skip what you know.
- The Rolling Peak - medium - The sweetest stretch in the sequence.
- The Rolling Window - medium - Smooth things out, one step at a time.
- The Roman Converter - easy - Roman numerals decoded.
- The Rotated Array - medium - Someone shuffled it. Now locate what you came for.
- The Runner-Up - easy - Not the winner. The one just behind it.
- The Running Total - easy - Each position holds the sum of everything before it.
- The Safe Caster - easy - Type conversion is easy, until it is not.
- The Schedule Cleaner - medium - Overlapping sessions. One clean line.
- The Schema Diff - medium - Two versions of the same config - what changed between them?
- The Schema Differ - medium - Schema from yesterday vs today. Something changed.
- The Schema Migrator - hard - Old schema in, new schema out.
- The Scoreboard Race - medium - Simulate rounds until someone hits the target.
- The Score Sorter - easy - Points on the board, sorted by who earned the most.
- The Scramble Check - easy - Same letters, different order - are these two strings secret twins?
- The Second Summit - easy - Not the top of the mountain - just below it.
- The Secret Twins - easy - Same letters, different disguises.
- The Self-Portrait Number - easy - Some numbers describe themselves perfectly.
- The Sequel Spotter - easy - Spot the sequels hiding in the catalog.
- The Shadow Cleaner - easy - Remove the repeats. No shortcuts.
- The Shifting Standard - medium - A benchmark in motion.
- The Short Address - medium - Turn a big number into a compact alphanumeric code.
- The Shortest Route - medium - Fewer hops is always better.
- The Silent Locator - easy - Every lookup should cost you less than the one before it.
- The Silver Screen Summit - medium - Box office totals decide who makes the top of the marquee.
- The Single Bit - easy - One particular pattern hides in plain sight.
- The Slow Leak - medium - Nested iterators. One flat stream.
- The Sneaky Twins - medium - They look different but they are the same inside.
- The Social Graph - easy - Everyone knows someone.
- The Solo Act - easy - One-and-done values only.
- The Spin Doctor - medium - Ninety degrees, but which way?
- The Spiral Harvest - medium - The snail reads the grid in its own special order.
- The Spread - easy - Data spread around a center. The range matters.
- The Squeeze - easy - aaabbb gets old fast. Shrink it.
- The Staircase Problem - medium - One step or two, the choices add up.
- The Status Board - medium - Make sense of a pile of raw Nginx access logs.
- The Step Counter - easy - You can hop one step or two - how many ways to reach the top?
- The Streak Breaker - easy - It has a problem with repetition.
- The Stream Averager - easy - The answer moves with the data.
- The Stream Joiner - hard - Events don't wait for each other. This does.
- The String Shrinker - easy - Compress the string. Shorter wins.
- The Style Guide - easy - Not every word deserves the same treatment.
- The Subarray Tally - medium - How many hidden windows hit the target?
- The Syntax Sentinel - easy - Brackets opened and closed. The nesting might be off.
- The Table Thief - medium - Somewhere in that query, tables are hiding.
- The Tag Analyst - medium - Two sets of labels, one analysis.
- The Tail End - easy - Push, pop, peek. The basics that break people.
- The Tail Finder - medium - Navigate to the end of a linked list using recursion.
- The Tail Trimmer - easy - Remove the k-th item from the back without counting forward first.
- The Tally Counter - easy - How many times does a single guest show up to the party?
- The Target Hunt - medium - Pairs that hit a target. Every one of them.
- The Throttle Ceiling - medium - Too many requests in too short a timeframe. Throttle it.
- The Throttle Wall - hard - Stop the abusers. Let the rest through.
- The Timezone Trap - medium - Trip data and timezones. They're not the same thing.
- The Timing Decorator - medium - Wrap any function to capture how long it takes.
- The Title Ladder - medium - Job titles and the salary tier they belong to.
- The Top Reviewer - easy - One restaurant receives the most feedback - which one?
- The Top Words - medium - In every document, some words dominate the conversation.
- The Trade Log Aggregator - medium - Every trade left a footprint.
- The Trade Signal - easy - Buy low, sell high. Identify the ideal moment.
- The Traffic Director - easy - Spread the load evenly - nobody should be doing all the work.
- The Trapped Pool - hard - What collects in the valleys after the rain?
- The Tree Measurer - easy - How deep does the rabbit hole go?
- The Trip Aggregator - medium - Travel records hold patterns waiting to be surfaced.
- The Trip Grouper - easy - Where did everyone go, and for how long?
- The Triple Alliance - hard - Three numbers, one target.
- The Triplet Hunt - medium - Every path that works gets a seat at the table.
- The Type Sorter - easy - A mixed list is hiding its numbers - extract them.
- The Value Sorter - easy - The order was always negotiable.
- The Velvet Rope - medium - Some users get in. Others wait outside until the window resets.
- The Version Parade - easy - 1.0 before 2.0. Don't let the dots confuse you.
- The Version Ranker - medium - Software versions follow their own ordering rules.
- The Vocabulary Test - medium - Can you spell out the whole sentence using only the words you know?
- The Vowel Hunt - easy - Just the vowels. All of them.
- The Waiting Game - medium - Patience has a price - and a count.
- The Water Collector - hard - Two walls, one sky, and a very important question.
- The Water Gauge - medium - Elevation bars trap water between peaks - count the volume.
- The Window Cleaner - medium - Keep it fresh, keep it unique.
- The Word Census - easy - Who said what - and how many times?
- The Word Counter - easy - How many times does each word show up in a file?
- The Word Families - medium - Different spellings, same letters - they belong together.
- The Word Flipper - easy - The sentence stays, the words surrender.
- The Word Inventory - easy - Every word, twice over.
- The Word Map - easy - Input text. Output: word frequency.
- The Word Mismatch - easy - Some text does not match.
- The Yahtzee Engine - hard - Five dice. Six faces. Score it.
- The Yahtzee Scorer - medium - Dice scoring. Multiple categories evaluated.
- The Zero Propagator - medium - One zero can change the whole picture.
- The Zigzag Encoder - medium - The message snakes its way across the rails.
- Threshold Filter - medium - Above the line or below it.
- The Spaces Between - easy - Raw lines arrive padded and uneven. Recover the fields that matter.
- Top N Keys - medium - Most of them do not matter. The few that do stand out.
- Transform Column - easy - Same data, new shape.
- Transpose Table - medium - Rows become columns. Columns become rows.
- Triangle Validator - medium - Not every triangle is a triangle.
- Type Caster - easy - Wrong type. Fix it.
- Unbroken - easy - A single dip resets the clock. Find the longest the machine held over the line.
- Unflatten Keys - medium - Dots in the key names. Rebuild the structure.
- Unique Values - easy - Duplicates are noise. Remove them.
- Validate Email - medium - Looks like an email. But is it?
- Value Count - easy - How many of each? Count them.
- Word Counter - easy - Words in, counts out.
- Zip to Record - easy - Two lists become one record.