Tired of Coding Mistakes? Use this Simple Technique

TL;DR: One major source of coding errors during interviews stems from candidates trying to construct and code an entire algorithm at once, under pressure. To avoid this, use the chunking and incremental coding method, which involves breaking the problem down into smaller, manageable parts. Implementing the solution incrementally, chunk by chunk, reduces the likelihood of errors. An added bonus of this approach is the simplicity it brings to explaining your code as your skeleton code becomes an outline answering the inevitable "explain your code" question. Practice this method under realistic conditions with platforms like Coditioning, to ensure you're prepared for your next coding interview

The Chunking and Incremental Coding Technique

Ever been stalled by mistakes or bugs during a coding interview? Perhaps you wrote your code, and had 5 minutes to go, only to run tests and discover a bug exists but you don't have enough time to find it, let alone fix it? Many candidates, under the combined stress of time-pressure and interviewer scrutiny, often attempt to formulate and write out a whole algorithm, in one go. If the algorithm challenge is simple enough, then this could work, but probably not the best idea for the types of challenges you'll encounter in real interviews.

Our short-term memory is rather limited, and can hold only so many elements for a short period, approximately 15 to 30 seconds. (There's exceptions to this e.g. Hyperthymestic individuals, who make up less than 1% of the population).

For the majority of us, there's a strategy that can greatly reduce coding errors - chunking and incremental coding. It's a simple yet effective approach to handle complex problems under pressure. Remember interviews conditions, with their time-constraints and interviewers breathing down your neck, are pressure-cookers. Mistakes flourish under these conditions.

The Power of Chunking and Incremental Coding

The approach is simple, divide the problem into manageable 'chunks' before jumping into the code. This way, each chunk represents a logical segment of the solution, which can be tackled independently, reducing the likelihood of errors.

Let's walk through this method with a programming challenge: given a list of objects, each representing a stock and its Year-To-Date (YTD) gain, identify the top 'k' stocks with the highest YTD gain. Where k is a positive integer.

Intuitively, what we will be doing is essentially eliminating any object for which 'k' objects have a larger YTD gain. To be in the top 'k', a stock cannot have 'k' stocks outperforming it. Picture yourself on a leaderboard, to be in the top 'k' positions, there can't be 'k' competitors with better scores than you.

A Step-by-Step Guide to Chunking and Incremental Coding

1) Preliminary Thinking

Spend 5 to 10 minutes deciding which solution you will be implementing, make sure your algorithm is correct (run through it with test cases, cover all corner cases!). Once you've figured out a solution, commit to it, and now just focus on implementing correctly.

2) Skeleton Code

Here's how skeleton pseudocode for our challenge might look:

3) Incremental Implementation:

Fill in the logic within each section of your skeleton code, one chunk at a time.

eventually you'll have something like this

4) Testing

Before submitting your code, write out test cases and mentally walk through the algorithm with sample input to check the output, or run the tests. I'd recommend mentally walking through before running your tests if you have time. It always looks better if your code passes all the tests the first time round.

Wait! There's more

An added bonus of this chunking approach is the simplicity it brings to explaining your code. Your skeleton code becomes a detailed outline for your explanation, ensuring a smooth and coherent presentation of your solution, free from memory lapses.

This strategy, with consistent practice, will become second nature and you'll find yourself writing error-free code even under high-pressure scenarios.

Practice using this approach under interview-conditions to get a feel of this method. You can do mock interviews with an AI-interviewer on Coditioning. The Coditioning platform allows you to simulate realistic interview conditions, so you can identify all your weakness now and not when it could cost you your dream job.It also allows you to try out a broad range of problems (not just algorithm-style, there's code reviews, spot the bug etc), explain your solutions under time-pressure etc.

But don't stop there, why not join our community on Discord? We share strategies, discuss, and learn from each other to optimize our coding and interview performance. Dive in and give yourself an edge. Happy coding!