Strategy for solving a programming problem

Problem solving is the most important topic for software developers, this is what we're hired to do, we're not code monkeys, we're there to solve problems.

A software is nothing more than a piece of program that solves a particular problem or set of problems.

It’s true that solving problems comes with practice, but I can point out a few rules that I follow when trying to solve an issue.

Understand the problem

This is absolutely the first step. Ask anyone and they will tell you the same thing.

If you don’t understand what’s the problem, you will not be able to solve it.

Ask yourself the following questions:

Plan the solution

After we understand what we need to do, we still need to have a plan. Although we could theoretically jump directly into coding, we need to make sure we know what we have to do.

Give your brain some time to analyze the problem and process all the information.

Sketch some ideas on paper. Try to split the problem into smaller sub-problems.

Think about the code, write some simple pseudocode or simply delimit the sub-problems.

Go through the sample input

Don’t code yet. Let’s first imagine how the code will work with some sample input/output examples.

Take some simple examples and think about the output. Will your logic work on that input?

Take more complex and bigger inputs – will it still work?

What about corner cases / edge cases? What should be the output in such cases?

And what about receiving invalid input?

Break down the problem

Try to divide the problem into smaller, manageable problems. Split the functionality in multiple functions or classes. Connect those sub-problems by calling them into a specific order (one function calling another, etc).

This can also be done with pseudocode – by now, you should know the function names, and maybe also the input arguments / return type. Make sure that the function names (and parameter names) are crystal clear to everyone who reads them. Don’t get stuck with the syntax, just focus on the logic and the steps.

Write some unit-test to validate the code

TDD is a great way of making sure you understand the problem statement and what’s expected as input/output. Other than that, you’ll also know when your code is correct. Therefore, I strongly suggest to start with the test first, and validate the basic input.

Reduce the problem

First, you should think about a simplified version of your problem. Add or remove constraints, in order to reach a problem that you’re able to solve. Reducing the problem will also allow you to see exactly where is the remaining difficulty.

Solve the problem / the sub-problems

Now you can start coding. Solve each sub-problem one by one.

And remember – first, you should only care about making it work. Just implement the initial solution, it doesn’t matter how the code looks like for now. If you have a unit-test – your goal is to make it pass.

Simplify and optimize the code

Now that the problem is solved – we’re not done yet.

Write more complicated tests, and also validate the edge cases.

Then, you can start polishing the code.Make it better. Make it faster. Refactor it until you’re happy with the result. You'll make the tests fail, but that's why they are there, to tell you when everything's working properly again.

Rebuild and check the test results as much as possible.

To do so, you have to ask yourself the following questions:

Document the code

After you’re done with the code, add the documentation for classes, methods, and major algorithms – if any. Other developers (you included) will thank yourself for this.

Tackling the problem: String reverse

Let’s tackle a short problem. We want to reverse a string, and we cannot use any already-implemented functions, so we need to implement our own string reverse. Let’s go through each steps.

Understand the problem

Do you understand the problem?

Yes, we need to reverse a string.

Can you explain the problem im simple terms, to a non-technical person?

We want to create an algorithm that will receive a word and we need to reverse the letters, let’s say for example we receive the word “abcd” and we need to be able to return “dcba”.

What is the required input?

We need to receive a string, nothing else

What would be the output for those inputs?

The output for a given string should be the reverse of the string.

What are your assumptions about the problem?

The input should contain a valid string.

Have you solved similar problems before?

No, so I cannot make use of a similar solution.

Plan the solution

Ask yourself a few questions here. What happens if the string has only two letters? But what if it’s just one? Well, if it’s only one letter, we should just return it. But if they are two? We simply swap it. What if we add one more letter? So now we have three letters. We only need to swap first and the third one. So we will need to start from the beginning and end of the string, and go until they intersect.

Pseudocode:

                                            
                                                Function reverse(string myString):
                                                set n = length of myString
                                                iterate through the characters, from 0 to n
                                                swap the characters based on some logic
                                                return the reversed string
                                            
                                        

Go through the sample input

Ask yourself a few questions here. Will it work if you pass something else than a string? Maybe a number? Maybe a negative number? Or some strange character from a chinese keyboard? Does the string should be in english? Can it work with some character with a french accent ? How will it behave then ? Can I pass it an empty string? Can I pass it a string with a very long length, let’s say 1 million characters?

Simple examples:

Corner / edge cases:

Break down the problem

Not needed for this problem.

Write some unit-test to validate the code

Now we simply need to use the sample input that we created and move it into a unit-test.

                                            
                                                EXPECT_EQUAL(reverse("ab"), "ba");  
                                                EXPECT_EQUAL(reverse("abc"), "cba");  
                                                EXPECT_EQUAL(reverse("abcd"), "dcba");  
                                                EXPECT_EQUAL(reverse(""), "");  
                                                EXPECT_EQUAL(reverse("a"), "a");  
                                            
                                        

Reduce the problem

Let’s say you don’t know how to solve this problem. But we know how to reverse an empty string, it's still empty, right? We also know how to reverse a string with two characters, we simply switch them up. Now, what about three characters and beyond?

Let’s build our solution based on that. How would your brain solve the problem? Now you only need to transpose that into code.

Solve the problem / the sub-problems

Implement the code and check the unit-tests to make sure that they pass.

Is there an edge-case that you did not think of? Use the unit-tests to tell you that.

Therefore, you may have to add a few more edge-cases in the unit-test and update the code to accommodate those cases.

Simplify and optimize the code

Now that all your unit tests pass, you have a working code.

Can you make it better? Faster? Easier to be understood by others?

Did you find the best names for those variables? For the function? For the classes?

Are there extra variables that can be removed? Lines that can be moved together, logical conditions that could be stacked up, or moved into a variable to make it more clear what they validate?

Can the code run faster? Does it work for small data sets? For big data sets?

Document the code

This is the easiest step. Now that you’re done, document the code.

What is the input? What is the output? What does the function do ? Is it clear for everyone, even for someone who never saw that code up until now? If not, write it down.