an approach to solve problem using some programming language

• Python Basics
• Interview Questions
• Python Quiz
• Popular Packages
• Python Projects
• Practice Python
• AI With Python
• Learn Python3
• Python Automation
• Python Web Dev
• DSA with Python
• Python OOPs
• Dictionaries

Programming Paradigms in Python

• Functional Programming in Python
• Python Event-Driven Programming
• Introduction of Programming Paradigms
• Python in Competitive Programming
• Python vs Other Programming Languages
• Metaprogramming with Metaclasses in Python
• Python - Fastest Growing Programming Language
• Command Line Interface Programming in Python
• Getting Started with Python Programming
• Programs for printing pyramid patterns in Python
• Python Input Methods for Competitive Programming
• Python | Making program run faster
• Comparison of Python with Other Programming Languages
• 8 Tips For Object-Oriented Programming in Python
• Declaring an Array in Python
• Python - Performing operations on the stock data
• Introduction to Programming Languages
• Python | as a Programming Language | Question 6
• Python | as a Programming Language | Question 25

Paradigm can also be termed as a method to solve some problems or do some tasks. A programming paradigm is an approach to solve the problem using some programming language or also we can say it is a method to solve a problem using tools and techniques that are available to us following some approach. There are lots of programming languages that are known but all of them need to follow some strategy when they are implemented and this methodology/strategy is paradigms. Apart from varieties of programming languages, there are lots of paradigms to fulfill each and every demand.

Python supports three types of Programming paradigms

Object Oriented programming paradigms

• Procedure Oriented programming paradigms

Functional programming paradigms

In the object-oriented programming paradigm, objects are the key element of paradigms. Objects can simply be defined as the instance of a class that contains both data members and the method functions. Moreover, the object-oriented style relates data members and methods functions that support encapsulation and with the help of the concept of an inheritance , the code can be easily reusable but the major disadvantage of object-oriented programming paradigm is that if the code is not written properly then the program becomes a monster.

Disadvantages

Note: For more information, refer to Object Oriented Programming in Python

Procedural programming paradigms

In Procedure Oriented programming paradigms, series of computational steps are divided modules which means that the code is grouped in functions and the code is serially executed step by step so basically, it combines the serial code to instruct a computer with each step to perform a certain task. This paradigm helps in the modularity of code and modularization is usually done by the functional implementation. This programming paradigm helps in an easy organization related items without difficulty and so each file acts as a container.

Functional programming paradigms is a paradigm in which everything is bind in pure mathematical functions style. It is known as declarative paradigms because it uses declarations overstatements. It uses the mathematical function and treats every statement as functional expression as an expression is executed to produce a value. Lambda functions or Recursion are basic approaches used for its implementation. The paradigms mainly focus on “what to solve” rather than “how to solve”. The ability to treat functions as values and pass them as an argument make the code more readable and understandable.

Note: For more information, refer to Functional Programming in Python

Please Login to comment...

Similar reads.

• Technical Scripter 2019
• Technical Scripter

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Indicative is now mParticle Analytics.

What Is A Programming Paradigm?

Written by Indicative Team

Programming Paradigm Defined

A programming paradigm is the classification, style or way of programming. It is an approach to solve problems by using programming languages. Depending on the language, the difficulty of using a  paradigm differs.

There a re several programming languages that use paradigms, but to do this, they need to follow a strategy or methodology. Paradigms are not meant to be mutually exclusive; a single program can feature multiple paradigms. Below is an overview of programming languages and their paradigm methodology.

• Imperative : Programming with an explicit sequence of commands.
• Declarative : Programming by specifying the result a user wants, instead of how to get it.
• Structured : Programming with clean control structures.
• Procedural : Imperative programming with procedure calls.
• Functional : Programming with function calls that avoid any global state.
• Function-Level : Programming with no variables at all.
• Object-Oriented : Programming by defining objects that send messages to each other.
• Event-Driven : Programming with emitters and listeners of asynchronous actions.
• Flow-Driven : Programming processes communicating with each other over predefined channels.
• Logic : Programming by specifying a set of facts and rules. 
• Constraint : Programming by specifying a set of constraints. 
• Aspect-Oriented : Programming c ross-cutting concerns applied transparently.
• Reflective : Programming by manipulating the program elements.
• Array : Programming with powerful array operators.

In Data Defined, we help make the complex world of data more accessible by explaining some of the most complex aspects of the field.

Click Here  for more Data Defined.

Related Articles

What Is Behavioral Data and Behavioral Analytics?

What Is A Data Warehouse?

What Is A Cohort?

Paradigms of Programming

Paradigm can also be termed as method to solve some problem or do some task. Programming paradigm is an approach to solve problem using some programming language or also we can say it is a method to solve a problem using tools and techniques that are available to us following some approach.

The course gives an overview of programming paradigms. It deals with the concepts common in various imperative programming languages. Furthermore, object-oriented programming is thaught. The fundamentals of declarative programming paradigm and its use in modern programming languages are illustrated as well. The final course topic covers the use of parallelism.

Important Links

• Youtube Playlist
• Online Quiz
• HackerRank Contest - 1
• HackerRank Contest - 2

Course Topics:

• Introduction to different paradigms of programming: Imperative - Object Oriented - Functional - Logic Imperative and Object-oriented Programming - Role of Types - Static and Dynamic Type Checking - Scope rules ; Grouping Data and operations, Information Hiding and Abstract Data Types, Objects, Inheritance, Polymorphism,Templates.
• Functional Programming - Expressions and Lists, Evaluation, types, type systems, values and operations, function declarations, lexical scope, lists and programming with lists, polymorphic functions, higher order and Curried functions, abstract data types.
• Logic Programming - Review of predicate logic, clausal-form logic, logic as a programming language, Unification algorithm, Abstract interpreter for logic programs, Semantics of logic programs, Programming in Prolog.
• Programming Languages: Concepts and Constructs; 2nd Edition, Ravi Sethi, Pearson Education Asia, 1996.

References:

• Programming Languages: Design and Implementation (4th Edition), by Terrence W. Pratt, Marvin V. Zelkowitz, Pearson, 2000.
• Programming Language Pragmatics, Third Edition, by Michael L. Scott, Morgan Kaufmann, 2009.

Tutorial Playlist

Programming tutorial, your guide to the best backend languages for 2024, an ultimate guide that helps you to start learn coding 2024, what is backend development: the ultimate guide for beginners, all you need to know for choosing the first programming language to learn, here’s all you need to know about coding, decoding, and reasoning with examples, understanding what is xml: the best guide to xml and its concepts., an ultimate guide to learn the importance of low-code and no-code development, top frontend languages that you should know about, top 75+ frontend developer interview questions and answers, the ultimate guide to learn typescript generics, the most comprehensive guide for beginners to know ‘what is typescript’.

The Ultimate Guide on Introduction to Competitive Programming

Top 60+ TCS NQT Interview Questions and Answers for 2024

Most commonly asked logical reasoning questions in an aptitude test, everything you need to know about advanced typescript concepts, an absolute guide to build c hello world program, a one-stop solution guide to learn how to create a game in unity, what is nat significance of nat for translating ip addresses in the network model, data science vs software engineering: key differences, a real-time chat application typescript project using node.js as a server, what is raspberry pi here’s the best guide to get started, what is arduino here’s the best beginners guide to get started, arduino vs. raspberry pi: which is the better board, the perfect guide for all you need to learn about mean stack, software developer resume: a comprehensive guide, here’s everything all you need to know about the programming roadmap, an ultimate guide that helps you to develop and improve problem solving in programming, the top 10 awesome arduino projects of all time, roles of product managers, pyspark rdd: everything you need to know about pyspark rdd, wipro interview questions and answers that you should know before going for an interview, how to use typescript with nodejs: the ultimate guide, what is rust programming language why is it so popular, software terminologies, an ultimate guide that helps you to develop and improve problem solving in programming.

Lesson 27 of 34 By Hemant Deshpande

Table of Contents

Coding and Programming skills hold a significant and critical role in implementing and developing various technologies and software. They add more value to the future and development. These programming and coding skills are essential for every person to improve problem solving skills. So, we brought you this article to help you learn and know the importance of these skills in the future. 

Want a Top Software Development Job? Start Here!

Topics covered in this problem solving in programming article are:

• What is Problem Solving in Programming? 
• Problem Solving skills in Programming
• How does it impact your career ?
• Steps involved in Problem Solving
• Steps to improve Problem Solving in programming

What is Problem Solving in Programming?

Computers are used to solve various problems in day-to-day life. Problem Solving is an essential skill that helps to solve problems in programming. There are specific steps to be carried out to solve problems in computer programming, and the success depends on how correctly and precisely we define a problem. This involves designing, identifying and implementing problems using certain steps to develop a computer.

When we know what exactly problem solving in programming is, let us learn how it impacts your career growth.

How Does It Impact Your Career?

Many companies look for candidates with excellent problem solving skills. These skills help people manage the work and make candidates put more effort into the work, which results in finding solutions for complex problems in unexpected situations. These skills also help to identify quick solutions when they arise and are identified. 

People with great problem solving skills also possess more thinking and analytical skills, which makes them much more successful and confident in their career and able to work in any kind of environment. 

The above section gives you an idea of how problem solving in programming impacts your career and growth. Now, let's understand what problem solving skills mean.

Problem Solving Skills in Programming

Solving a question that is related to computers is more complicated than finding the solutions for other questions. It requires excellent knowledge and much thinking power. Problem solving in programming skills is much needed for a person and holds a major advantage. For every question, there are specific steps to be followed to get a perfect solution. By using those steps, it is possible to find a solution quickly.

The above section is covered with an explanation of problem solving in programming skills. Now let's learn some steps involved in problem solving.

Steps Involved in Problem Solving

Before being ready to solve a problem, there are some steps and procedures to be followed to find the solution. Let's have a look at them in this problem solving in programming article.

Basically, they are divided into four categories:

• Analysing the problem
• Developing the algorithm
• Testing and debugging

Analysing the Problem

Every problem has a perfect solution; before we are ready to solve a problem, we must look over the question and understand it. When we know the question, it is easy to find the solution for it. If we are not ready with what we have to solve, then we end up with the question and cannot find the answer as expected. By analysing it, we can figure out the outputs and inputs to be carried out. Thus, when we analyse and are ready with the list, it is easy and helps us find the solution easily. 

Developing the Algorithm

It is required to decide a solution before writing a program. The procedure of representing the solution  in a natural language called an algorithm. We must design, develop and decide the final approach after a number of trials and errors, before actually writing the final code on an algorithm before we write the code. It captures and refines all the aspects of the desired solution.

Once we finalise the algorithm, we must convert the decided algorithm into a code or program using a dedicated programming language that is understandable by the computer to find a desired solution. In this stage, a wide variety of programming languages are used to convert the algorithm into code. 

Testing and Debugging

The designed and developed program undergoes several rigorous tests based on various real-time parameters and the program undergoes various levels of simulations. It must meet the user's requirements, which have to respond with the required time. It should generate all expected outputs to all the possible inputs. The program should also undergo bug fixing and all possible exception handling. If it fails to show the possible results, it should be checked for logical errors.

Industries follow some testing methods like system testing, component testing and acceptance testing while developing complex applications. The errors identified while testing are debugged or rectified and tested again until all errors are removed from the program.

The steps mentioned above are involved in problem solving in programming. Now let's see some more detailed information about the steps to improve problem solving in programming.

Steps to Improve Problem Solving in Programming

Right mindset.

The way to approach problems is the key to improving the skills. To find a solution, a positive mindset helps to solve problems quickly. If you think something is impossible, then it is hard to achieve. When you feel free and focus with a positive attitude, even complex problems will have a perfect solution.

Making Right Decisions

When we need to solve a problem, we must be clear with the solution. The perfect solution helps to get success in a shorter period. Making the right decisions in the right situation helps to find the perfect solution quickly and efficiently. These skills also help to get more command over the subject.

Keeping Ideas on Track

Ideas always help much in improving the skills; they also help to gain more knowledge and more command over things. In problem solving situations, these ideas help much and help to develop more skills. Give opportunities for the mind and keep on noting the ideas.

Learning from Feedbacks

A crucial part of learning is from the feedback. Mistakes help you to gain more knowledge and have much growth. When you have a solution for a problem, go for the feedback from the experienced or the professionals. It helps you get success within a shorter period and enables you to find other solutions easily.

Asking Questions

Questions are an incredible part of life. While searching for solutions, there are a lot of questions that arise in our minds. Once you know the question correctly, then you are able to find answers quickly. In coding or programming, we must have a clear idea about the problem. Then, you can find the perfect solution for it. Raising questions can help to understand the problem.

These are a few reasons and tips to improve problem solving in programming skills. Now let's see some major benefits in this article.

• Problem solving in programming skills helps to gain more knowledge over coding and programming, which is a major benefit.
• These problem solving skills also help to develop more skills in a person and build a promising career.
• These skills also help to find the solutions for critical and complex problems in a perfect way.
• Learning and developing problem solving in programming helps in building a good foundation.
• Most of the companies are looking for people with good problem solving skills, and these play an important role when it comes to job opportunities 

Don't miss out on the opportunity to become a Certified Professional with Simplilearn's Post Graduate Program in Full Stack Web Development . Enroll Today!

Problem solving in programming skills is important in this modern world; these skills build a great career and hold a great advantage. This article on problem solving in programming provides you with an idea of how it plays a massive role in the present world. In this problem solving in programming article, the skills and the ways to improve more command on problem solving in programming are mentioned and explained in a proper way.

If you are looking to advance in your career. Simplilearn provides training and certification courses on various programming languages - Python , Java , Javascript , and many more. Check out our Post Graduate Program in Full Stack Web Development course that will help you excel in your career.

If you have any questions for us on the problem solving in programming article. Do let us know in the comments section below; we have our experts answer it right away.

Find our Full Stack Developer - MERN Stack Online Bootcamp in top cities:

About the author.

Hemant Deshpande, PMP has more than 17 years of experience working for various global MNC's. He has more than 10 years of experience in managing large transformation programs for Fortune 500 clients across verticals such as Banking, Finance, Insurance, Healthcare, Telecom and others. During his career he has worked across the geographies - North America, Europe, Middle East, and Asia Pacific. Hemant is an internationally Certified Executive Coach (CCA/ICF Approved) working with corporate leaders. He also provides Management Consulting and Training services. He is passionate about writing and regularly blogs and writes content for top websites. His motto in life - Making a positive difference.

Recommended Resources

Your One-Stop Solution to Understand Coin Change Problem

Combating the Global Talent Shortage Through Skill Development Programs

What Is Problem Solving? Steps, Techniques, and Best Practices Explained

One Stop Solution to All the Dynamic Programming Problems

The Ultimate Guide to Top Front End and Back End Programming Languages for 2021

• PMP, PMI, PMBOK, CAPM, PgMP, PfMP, ACP, PBA, RMP, SP, and OPM3 are registered marks of the Project Management Institute, Inc.

Member-only story

10 Steps to Solving a Programming Problem

Tips for new developers staring at a blank screen, unsure of where to start.

Valinda Chan

Some of the feedback I hear from new developers working on a programming problem revolves around uncertainty of where to start. You understand the problem, the logic, basics of the syntax, etc. If you see someone else’s code or have someone to guide you, you can follow along. But maybe you feel uncertain about doing it yourself and have trouble turning your thoughts into code at first even though you understand the syntax or logic. Here’s my process and some tips to tackling a sample problem that hopefully some of you may find helpful in your journey.

1. Read the problem at least three times (or however many makes you feel comfortable)

You can’t solve a problem you don’t understand. There is a difference between the problem and the problem you think you are solving. It’s easy to start reading the first few lines in a problem and assume the rest of it because it’s similar to something you’ve seen in the past. If you are making even a popular game like Hangman, be sure to read through any rules even if you’ve played it before. I once was asked to make a game like Hangman that I realized was “Evil Hangman” only after I read through the instructions (it was a trick!).

Sometimes I’ll even try explaining the problem to a friend and see if her understanding of my explanation matches the problem I am tasked with. You don’t want to find out halfway through that you misunderstood the problem. Taking extra time in the beginning is worth it. The better you understand the problem, the easier it will be to solve it.

Let’s pretend we are creating a simple function selectEvenNumbers that will take in an array of numbers and return an array evenNumbers of only even numbers. If there are no even numbers, return the empty array evenNumbers .

Here are some questions that run through my mind:

• How can a computer tell what is an even number? Divide that number by 2 and see if its remainder is 0.
• What am I passing into this function? An array
• What will that array contain? One or more numbers
• What are the data types of the elements in the array? Numbers
• What is the goal of this function? What am I returning at the end of this function? The goal is to take all the even numbers and return them in an array. If there are no even numbers, return an empty array.

2. Work through the problem manually with at least three sets of sample data

Take out a piece of paper and work through the problem manually. Think of at least three sets of sample data you can use. Consider corner and edge cases as well.

Corner case : a problem or situation that occurs outside of normal operating parameters, specifically when multiple environmental variables or conditions are simultaneously at extreme levels, even though each parameter is within the specified range for that parameter. Edge case : problem or situation that occurs only at an extreme (maximum or minimum) operating parameter

For example, below are some sets of sample data to use:

When you are first starting out, it is easy to gloss over the steps. Because your brain may already be familiar with even numbers, you may just look at a sample set of data and pull out numbers like 2 , 4 , 6 and so forth in the array without fully being aware of each and every step your brain is taking to solve it. If this is challenging, try using large sets of data as it will override your brain’s ability to naturally solve the problem just by looking at it. That helps you work through the real algorithm.

Let’s go through the first array [1]

• Look at the only element in the array [1]
• Decide if it is even. It is not
• Notice that there are no more elements in this array
• Determine there are no even numbers in this provided array
• Return an empty array

Let’s go through the array [1, 2]

• Look at the first element in array [1, 2]
• Look at the next element in the array
• Decide if it is even. It is even
• Make an array evenNumbers and add 2 to this array
• Return the array evenNumbers which is [2]

I go through this a few more times. Notice how the steps I wrote down for [1] varies slightly from [1, 2] . That is why I try to go through a couple of different sets. I have some sets with just one element, some with floats instead of just integers, some with multiple digits in an element, and some with negatives just to be safe.

3. Simplify and optimize your steps

Look for patterns and see if there’s anything you can generalize. See if you can reduce any steps or if you are repeating any steps.

• Create a function selectEvenNumbers
• Create a new empty array evenNumbers where I store even numbers, if any
• Go through each element in the array [1, 2]
• Find the first element
• Decide if it is even by seeing if it is divisible by 2. If it is even, I add that to evenNumbers
• Find the next element
• Repeat step #4
• Repeat step #5 and #4 until there are no more elements in this array
• Return the array evenNumbers , regardless of whether it has anything in it

This approach may remind you of Mathematical Induction in that you:

• Show it is true for n = 1 , n = 2 , ...
• Suppose it is true for n = k
• Prove it is true for n = k + 1

4. Write pseudocode

Even after you’ve worked out general steps, writing out pseudocode that you can translate into code will help with defining the structure of your code and make coding a lot easier. Write pseudocode line by line. You can do this either on paper or as comments in your code editor. If you’re starting out and find blank screens to be daunting or distracting, I recommend doing it on paper.

Pseudocode generally does not actually have specific rules in particular but sometimes, I might end up including some syntax from a language just because I am familiar enough with an aspect of the programming language. Don’t get caught up with the syntax. Focus on the logic and steps.

For our problem, there are many different ways to do this. For example, you can use filter but for the sake of keeping this example as easy to follow along as possible, we will use a basic for loop for now (but we will use filter later when we refactor our code).

Here is an example of pseudocode that has more words:

Here is an example of pseudocode that has fewer words:

Either way is fine as long as you are writing it out line-by-line and understand the logic on each line.

Refer back to the problem to make sure you are on track.

5. Translate pseudocode into code and debug

When you have your pseudocode ready, translate each line into real code in the language you are working on. We will use JavaScript for this example.

If you wrote it out on paper, type this up as comments in your code editor. Then replace each line in your pseudocode.

Then I call the function and give it some sample sets of data we used earlier. I use them to see if my code returns the results I want. You can also write tests to check if the actual output is equal to the expected output.

I generally use console.log() after each variable or line or so. This helps me check if the values and code are behaving as expected before I move on . By doing this, I catch any issues before I get too far. Below is an example of what values I would check when I am first starting out. I do this throughout my code as I type it out.

After working though each line of my pseudocode, below is what we end up with. // is what the line was in pseudocode. Text that is bolded is the actual code in JavaScript.

I get rid of the pseudocode to avoid confusion.

Sometimes new developers will get hung up with the syntax that it becomes difficult to move forward. Remember that syntax will come more naturally over time and there is no shame in referencing material for the correct syntax later on when coding.

6. Simplify and optimize your code

You’ve probably noticed by now that simplifying and optimizing are recurring themes.

“Simplicity is prerequisite for reliability.” — Edsger W. Dijkstra, Dutch computer scientist and early pioneer in many research areas of computing science

In this example, one way of optimizing it would be to filter out items from an array by returning a new array using filter . This way, we don’t have to define another variable evenNumbers because filter will return a new array with copies of elements that match the filter. This will not change the original array. We also don’t need to use a for loop with this approach. filter will go through each item, return either true , to have that element in the array, or false to skip it.

Simplifying and optimizing your code may require you to iterate a few times, identifying ways to further simplify and optimize code.

Here are some questions to keep in mind:

• What are your goals for simplifying and optimizing? The goals will depend on your team’s style or your personal preference. Are you trying to condense the code as much as possible? Is the goal to make it the code more readable? If that’s the case, you may prefer taking that extra line to define the variable or compute something rather than trying to define and compute all in one line.
• How else can you make the code more readable?
• Are there any more extra steps you can take out?
• Are there any variables or functions you ended up not even needing or using?
• Are you repeating some steps a lot? See if you can define in another function.
• Are there better ways to handle edge cases?

“Programs must be written for people to read, and only incidentally for machines to execute.” — Gerald Jay Sussman and Hal Abelson, Authors of “Structure and Interpretation of Computer Programs”

This step really should be throughout the process. Debugging throughout will help you catch any syntax errors or gaps in logic sooner rather than later. Take advantage of your Integrated Development Environment (IDE) and debugger. When I encounter bugs, I trace the code line-by-line to see if there was anything that did not go as expected. Here are some techniques I use:

• Check the console to see what the error message says. Sometimes it’ll point out a line number I need to check. This gives me a rough idea of where to start, although the issue sometimes may not be at this line at all.
• Comment out chunks or lines of code and output what I have so far to quickly see if the code is behaving how I expected. I can always uncomment the code as needed.
• Use other sample data if there are scenarios I did not think of and see if the code will still work.
• Save different versions of my file if I am trying out a completely different approach. I don’t want to lose any of my work if I end up wanting to revert back to it!

“The most effective debugging tool is still careful thought, coupled with judiciously placed print statements.” — Brian W. Kernighan, Computer Science Professor at Princeton University

8. Write useful comments

You may not always remember what every single line meant a month later. And someone else working on your code may not know either. That’s why it’s important to write useful comments to avoid problems and save time later on if you need to come back to it.

Stay away from comments such as:

// This is an array. Iterate through it.

// This is a variable

I try to write brief, high-level comments that help me understand what’s going on if it is not obvious. This comes in handy when I am working on more complex problems. It helps understand what a particular function is doing and why. Through the use of clear variable names, function names, and comments, you (and others) should be able to understand:

• What is this code for?
• What is it doing?

9. Get feedback through code reviews

Get feedback from your teammates, professors, and other developers. Check out Stack Overflow . See how others tackled the problem and learn from them. There are sometimes several ways to approach a problem. Find out what they are and you’ll get better and quicker at coming up with them yourself.

“No matter how slow you are writing clean code, you will always be slower if you make a mess.” — Uncle Bob Martin, Software Engineer and Co-author of the Agile Manifesto

10. Practice, practice, practice

Even experienced developers are always practicing and learning. If you get helpful feedback, implement it. Redo a problem or do similar problems. Keep pushing yourself. With each problem you solve, the better a developer you become. Celebrate each success and be sure to remember how far you’ve come. Remember that programming, like with anything, comes easier and more naturally with time.

“Take pride in how far you’ve come. Have faith in how far you can go. But don’t forget to enjoy the journey.” — Michael Josephson, Founder of Joseph and Edna Josephson Institute of Ethics

Thanks Gavin Stark

Written by Valinda Chan

Product & UX Design

More from Valinda Chan and codeburst

DataDrivenInvestor

Must-Read Books for Software Developers

60+ books on programming, computer science, algorithms and data structures, linear algebra, discrete mathematics, computer systems….

How To Create Horizontal Scrolling Containers

As a front end developer, more and more frequently i am given designs that include a horizontal scrolling component. this has become….

Top 50 Java Interview Questions for Beginners and Junior Developers

A list of frequently asked java questions and answers from programming job interviews of java developers of different experience..

Muzli - Design Inspiration

7 things I wished designers did more of when working with developers

How designers can put in that extra effort to help ensure a great final product, recommended from medium.

Benoit Ruiz

Better Programming

Advice From a Software Engineer With 8 Years of Experience

Practical tips for those who want to advance in their careers.

Artturi Jalli

I Built an App in 6 Hours that Makes $1,500/Mo

Copy my strategy.

General Coding Knowledge

Stories to Help You Grow as a Software Developer

Coding & Development

ChatGPT prompts

Hazel Paradise

How I Create Passive Income With No Money

Many ways to start a passive income today.

Benedict Neo

bitgrit Data Science Publication

Roadmap to Learn AI in 2024

A free curriculum for hackers and programmers to learn ai.

Alexander Nguyen

Level Up Coding

Why I Keep Failing Candidates During Google Interviews…

They don’t meet the bar..

Sufyan Maan, M.Eng

ILLUMINATION

What Happens When You Start Reading Every Day

Think before you speak. read before you think. — fran lebowitz.

Text to speech

UNIT 1: How to Think Like an Engineer

Learning objectives.

• Explain what we mean by “Computational Thinking”.
• Describe the problem being solved in a computational algorithm.
• Explain the process for generating computational algorithms.
• Generate and test algorithms to solve computational problems.
• Evaluate computational algorithms for exactness, correctness, termination, generalizability and understandability.
• Explain the role of programming in the field of Informatics.

Introduction

The goal of this book is to teach you to solve computational problems and to think like an engineer. Computational problems are problems that can be solved by the use of computations (a computation is what you do when you calculate something). Engineers are people who solve problems – they invent, design, analyze, build and test “things” to fulfill objectives and requirements. The single most important skill for you to learn is problem solving. Problem solving means the ability to formulate problems, think creatively about solutions, and express a solution clearly and accurately. As it turns out, the process of learning to program is an excellent opportunity to practice problem-solving skills.

This book strives to prepare you to write well-designed computer programs that solve interesting problems involving data.

Computational Thinking

Figure 1: “The seven components to computational thinking”(www.ignitemyfutureinschool.org/about)

Computational Thinking is the thought processes involved in understanding a problem and expressing its solution in a way that a computer can effectively carry out. Computational thinking involves solving problems, designing systems, and understanding human behavior (e.g. what the user needs or wants) – thinking like an engineer. Computational thinking is a fundamental skill for everyone, not just for programmers because computational thinking is what comes before any computing technology. [1]

Computer science is the study of computation — what can be computed and how to compute it whereas computational thinking is:

Conceptualizing , not programming. Computer science is not only computer programming. Thinking like a computer scientist means more than being able to program a computer. It requires thinking at multiple levels of abstraction;

Fundamental , not rote skill. A fundamental skill is something every human being must know to function in modern society. Rote means a mechanical routine;

A way that humans, not computers, think . Computational thinking is a way humans solve problems; it is not trying to get humans to think like computers. Computers are dull and boring; humans are clever and imaginative. We humans make computers exciting. Equipped with computing devices, we use our cleverness to tackle problems we would not dare take on before the age of computing and build systems with functionality limited only by our imaginations;

Complements and combines mathematical and engineering thinking . Computer science inherently draws on mathematical thinking, given that, like all sciences, its formal foundations rest on mathematics. Computer science inherently draws on engineering thinking, given that we build systems that interact with the real world;

Ideas , not artifacts. It’s not just the software and hardware artifacts we produce that will be physically present everywhere and touch our lives all the time, it will be the computational concepts we use to approach and solve problems, manage our daily lives, and communicate and interact with other people;

For everyone, everywhere . Computational thinking will be a reality when it is so integral to human endeavors it disappears as an explicit philosophy. [2]

Figure 2 “Are you happy?” by Typcut http://www.typcut.com/headup/are-you-happy

An algorithm specifies a series of steps that perform a particular computation or task. Throughout this book we’ll examine a number of different algorithms to solve a variety of computational problems.

Algorithms resemble recipes. Recipes tell you how to accomplish a task by performing a number of steps. For example, to bake a cake the steps are: preheat the oven; mix flour, sugar, and eggs thoroughly; pour into a baking pan; set the timer and bake until done.

However, “algorithm” is a technical term with a more specific meaning than “recipe”, and calling something an algorithm means that the following properties are all true:

• An algorithm is an unambiguous description that makes clear what has to be implemented in order to solve the problem. In a recipe, a step such as “Bake until done” is ambiguous because it doesn’t explain what “done” means. A more explicit description such as “Bake until the cheese begins to bubble” is better. In a computational algorithm, a step such as “Choose a large number” is vague: what is large? 1 million, 1 billion, or 100? Does the number have to be different each time, or can the same number be used again?
• An algorithm expects a defined set of inputs. For example, it might require two numbers where both numbers are greater than zero. Or it might require a word, or a list customer names.
• An algorithm produces a defined set of outputs. It might output the larger of the two numbers, an all-uppercase version of a word, or a sorted version of the list of names.
• An algorithm is guaranteed to terminate and produce a result, always stopping after a finite time. If an algorithm could potentially run forever, it wouldn’t be very useful because you might never get an answer.
• Must be general for any input it is given. Algorithms solve general problems (determine if a password is valid); they are of little use if they only solve a specific problem (determine if ‘comp15’ is a valid password)
• It is at the right level of detail…..the person or device executing the instruction know how to accomplish the instruction without any extra information.

Once we know it’s possible to solve a problem with an algorithm, a natural question is whether the algorithm is the best possible one. Can the problem be solved more quickly or efficiently?

The first thing you need to do before designing an algorithm is to understand completely the problem given. Read the problem’s description carefully, then read it again. Try sketching out by hand some examples of how the problem can be solved. Finally consider any special cases and design your algorithm to address them.

An algorithm does not solve a problem rather it gives you a series of steps that, if executed correctly, will result in a solution to a problem.

An Example Algorithm

Let us look at a very simple algorithm called find_max.

Problem : Given a list of positive numbers, return the largest number on the list.

Inputs : A list of positive numbers. This list must contain at least one number. (Asking for the largest number in a list of no numbers is not a meaningful question.)

Outputs : A number, which will be the largest number in the list.

Algorithm :

• Accept a list of positive numbers; set to nums_list
• Set max_number to 0.
• If the number is larger, set max_number to the larger number.
• max_number is now set to the largest number in the list of positive numbers, nums_list.

Does this meet the criteria for being an algorithm?

• Is it unambiguous? Yes. Each step of the algorithm consists of uncomplicated operations, and translating each step into programming code is straight forward.
• Does it have defined inputs and outputs? Yes.
• Is it guaranteed to terminate? Yes. The list nums_list is of finite length, so after looking at every element of the list the algorithm will stop.
• Is it general for any input? Yes. A list of any set of positive numbers works.
• Does it produce the correct result? Yes. When tested, the results are what are expected

Figure 3: Example Algorithm

How do we know if an algorithm is unambiguous, correct, comes to an end, is general AND is at the right level of detail? We must test the algorithm. Testing means verifying that the algorithm does what we expect it to do. In our ‘bake a cake’ example we know our algorithm is ‘working’ if, in the end, we get something that looks, smells and tastes like a cake.

Verifying your Algorithm

Figure 3 “ Keyboard ” by Geralt is licensed under CC 2

Your first step should be to carefully read through EACH step of the algorithm to check for ambiguity and if there is any information missing. To ensure that the algorithm is correct, terminates and is general for any input we devise ‘test cases’ for the algorithm.

A test case is a set of inputs, conditions, and expected results developed for a particular computational problem to be solved. A test case is really just a question that you ask of the algorithm (e.g. if my list is the three numbers 2, 14, and 11 does the algorithm return the number 14?). The point of executing the test is to make sure the algorithm is correct, that it terminates and is general for any input.

Good (effective) test cases:

• are easy to understand and execute
• are created with the user in mind (what input mistakes will be made? what are the preconditions?)
• make no assumptions (you already know what it is supposed to do)
• consider the boundaries for a specified range of values.

Let us look at the example algorithm from the previous section. The input for the algorithm is ‘a list of positive numbers’. To make it easy to understand and execute keep the test lists short. The preconditions are that the list only contains numbers and these numbers must be positive so include a test with a ‘non-number’ (i.e. a special character or a letter) and a test with a negative number. The boundaries for the list are zero and the highest positive number so include a test with zero and a large positive number. That is it! Here is an example of three different test cases.

Manually, you should step through your algorithm using each of the three test cases, making sure that the algorithm does indeed terminate and that you get your expected result. As our algorithms and programs become more complex, skilled programmers often break each test case into individual steps of the algorithm/program and indicate what the expected result of each step should be. When you write a detailed test case, you don’t necessarily need to specify the expected result for each test step if the result is obvious.

In computer programming we accept a problem to solve and develop an algorithm that can serve as a general solution. Once we have such a solution, we can use our computer to automate the execution. Programming is a skill that allows a competent programmer to take an algorithm and represent it in a notation (a program) that can be followed by a computer. These programs are written in programming languages (such as Python). Writing a correct and valid algorithm to solve a computational problem is key to writing good code. Learn to Think First and coding will come naturally!

The Process of Computational Problem Solving

Computational problem solving does not simply involve the act of computer programming. It is a process, with programming being only one of the steps. Before a program is written, a design for the program must be developed (the algorithm). And before a design can be developed, the problem to be solved must be well understood. Once written, the program must be thoroughly tested. These steps are outlined in Figure 5.

Figure 5: Process of Computational Problem Solving [footnote]Dierbach, Charles. Introduction to Computer Science Using Python: A Computational Problem-solving Focus. Wiley Publishing, 2012, pp17-18.[/footnote]

Values and Variables

A value is one of the basic things computer programs works with, like a password or a number of errors.

Values belong to different types: 21 is an integer (like the number of errors), and ‘comp15’ is a string of characters (like the password). Python lets you give names to values giving us the ability to generalize our algorithms.

One of the most powerful features of a programming language is the ability to use variables. A variable is simply a name that refers to a value as shown below,

Whenever the variable errors appears in a calculation the current value of the variable is used.

We need some way of storing information (i.e. the number of errors or the password) and manipulate them as well. This is where variables come into the picture. Variables are exactly what the name implies – their value can vary, i.e., you can store anything using a variable. Variables are just parts of your computer’s memory where you store some information. Unlike literal constants, you need some method of accessing these variables and hence you give them names.

Programmers generally choose names for their variables that are meaningful and document what the variable is used for. It is a good idea to begin variable names with a lowercase letter . The underscore character (_) can appear in a name and is often used in names with multiple words.

A program is a sequence of instructions that specifies how to perform a computation. The computation might be something mathematical, such as solving a system of mathematical equations or finding the roots of a polynomial, but it can also be a symbolic computation, such as searching and replacing text in a document or something graphical, like processing user input on an ATM device.

What is a Program?

Figure 6: “ Python Code ” by nyuhuhuu is licensed under CC-BY 2.0

The details look different in different computer programming languages, but there are some low-level conceptual patterns (constructs) that we use to write all programs. These constructs are not just for Python programs, they are a part of every programming language.

input Get data from the “outside world”. This might be reading data from a file, or even some kind of sensor like a microphone or GPS. In our initial algorithms and programs, our input will come from the user typing data on the keyboard.

output Display the results of the program on a screen or store them in a file or perhaps write them to a device like a speaker to play music or speak text.

sequential execution Perform statements one after another in the order they are encountered in the script.

conditional execution Checks for certain conditions and then executes or skips a sequence of statements.

repeated execution Perform some set of statements repeatedly, usually with some variation.

reuse Write a set of instructions once and give them a name and then reuse those instructions as needed throughout your program.

Believe it or not, that’s pretty much all there is to it. Every computer application you’ve ever used, no matter how complicated, is made up of constructs that look pretty much like these. So you can think of programming as the process of breaking a large, complex task into smaller and smaller subtasks until the subtasks are simple enough to be performed with one of these basic constructs. The “art” of writing a program is composing and weaving these basic elements together many times over to produce something that is useful to its users.

Computational Problem Design Using the Basic Programming Constructs

The key to better algorithm design and thus to programming lies in limiting the control structure to only three constructs as shown below.

• The Sequence structure (sequential execution)
• The Decision, Selection or Control structure (conditional execution)
• Repetition or Iteration Structure (repeated execution)

Figure 7: the 3 Programming Constructs

  Let us look at some examples for the sequential control and the selection control.

Sequential Control Example

The following algorithm is an example of sequential control .

Problem : Given two numbers, return the sum and the product of the two numbers.

Inputs : Two numbers.

Outputs : The sum and the product.

• display “Input two numbers”
• sum = number1 + number2
• print “The sum is “, sum
• product = number1 * number2
• print “The product is “, product
• Is it guaranteed to terminate? Yes. Sequential control, by its nature, always ends.
• Is it general for any input? Yes. Any two numbers work in this design.
• Does it produce the correct result? Yes. When tested, the results are what are expected.

Here is an example of three different test cases that are used to verify the algorithm.

Selection Control

The following two algorithms are examples of selection control which uses the ‘IF’ statement in most programming languages.

Problem : Given two numbers, the user chooses to either multiply, add or subtract the two numbers. Return the value of the chosen calculation.

Inputs : Two numbers and calculation option.

Outputs : The value of the chosen calculation.

The relational (or comparison) operators used in selection control are:

= is equal to

> is greater than

< is less than

>= is greater than or equal

<= is less than or equal

<> is not equal to

• display “choose one of the following”
• display “m for multiply”
• display “a for add”
• display “s for subtract”
• accept choice
• display “input two numbers you want to use”
• accept number1, number2
• if choice = m then answer= number1 * number2
• if choice = a then answer= number1 + number2
• if choice = s then answer= number1 -number212. if choice is not m, a, or s then answer is NONE
• display answer
• Is it guaranteed to terminate? Yes. The input is of finite length, so after accepting the user’s choice and the two numbers the algorithm will stop.
• Is it general for any input? Yes. Any two numbers work in this design and only a choice of a’m’, ‘a’, or ‘s’ will result in numeric output.

This example uses an extension of the simple selection control structure we just saw and is referred to as the ‘IF-ELSE’ structure.

Problem : Accept from the user a positive integer value representing a salary amount, return tax due based on the salary amount.

Inputs : One positive integer number.

Outputs : The calculated tax amount.

• accept salary
• If salary < 50000 then
• Tax = 0 Else
• If salary > 50000 AND salary < 100000 then
• Tax = 50000 * 0.05 Else
• Tax = 100000 * 0.30
• display Tax
• Is it guaranteed to terminate? Yes. The input is of finite length, so after accepting the user’s number, even if it is negative, the algorithm will stop.
• Is it general for any input? Yes. Any number entered in this design will work.

Iterative Control Examples

The third programming control is the iterative or, also referred to as, the repetition structure. This control structure causes certain steps to be repeated in a sequence a specified number of times or until a condition is met. This is what is called a ‘loop’ in programming

In all programming languages there are generally two options: an indefinite loop (the Python ‘WHILE’ programming statement) and a definite loop (the Python ‘FOR’ programming statement). We can use these two constructs, WHILE and FOR, for iterations or loops in our algorithms.

Note for Reader: A definite loop is where we know exactly the number of times the loop’s body will be executed. Definite iteration is usually best coded as a Python for loop. An indefinite loop is where we do not know before entering the body of the loop the exact number of iterations the loop will perform. The loop just keeps going until some condition is met. A while statement is used in this case.

The following algorithm is an example of iterative control using WHILE .

Problem : Print each keyboard character the users types in until the user chooses the ‘q’ (for ‘quit’) character.

Inputs : A series of individual characters.

Outputs : Each character typed in by the user.

• initialize (set) letter = ‘a’
• WHILE letter <> ‘q’
• ACCEPT letter
• DISPLAY “The character you typed is”, letter
• Is it guaranteed to terminate? Yes. The input is of finite length, so after accepting the user’s keyboard character, even if it is not a letter, the algorithm will stop.
• Is it general for any input? Yes. Any keyboard character entered in this design will work.

The following algorithm is an example of iterative control using FOR . This statement is used when the number of iterations is known in advance.

Problem : Ask the user how many words they want to enter then print the words entered by the user.

Inputs : Number of words to be entered; this value must be a positive integer greater than zero. Individual words.

Outputs : Each word typed in by the user.

• accept num_words (must be at least one)
• repeat num_words times (FOR 1 to num_words)
• accept word
• DISPLAY “The word you entered is”, word
• Is it guaranteed to terminate? Yes. The input is of finite length, so after accepting the user’s number of words to enter and any characters typed on the keyboard, even if it is not a ‘word’ per say, the algorithm will stop.
• Is it general for any input? Yes. Any positive integer greater than zero and any size ‘word’ will work.

Here is an example of two different test cases that are used to verify the algorithm.

The Role of Programming in the Field of Informatics

Figure8: iPhone apps by Jaap Arriens/NurPhoto via Getty Images (abcnews.go.com)

You see computer programming in use every day. When you use Google or your smartphone, or watch a movie with special effects, there is programing at work. When you order a product over the Internet, there is code in the web site, in the cryptography used to keep your credit card number secure, and in the way that UPS routes their delivery vehicle to get your order to you as quickly as possible.

Programming is indeed important to an informatics professional as they are interested in finding solutions for a wide variety of computational problems involving data.

When you Google the words “pie recipe,” Google reports that it finds approximately 38 million pages, ranked in order of estimated relevance and usefulness. Facebook has approximately 1 billion active users who generate over 3 billion comments and “Likes” each day. GenBank, a national database of DNA sequences used by biologists and medical researchers studying genetic diseases, has over 100 million genetic sequences with over 100 billion DNA base pairs. According to the International Data Corporation, by 2020 the digital universe – the data we create and copy annually – will reach 44 zettabytes, or 44 trillion gigabytes.

Figure 9: The Digital Universe ( www.emc.com/leadership/digital-universe/2014iview/images )

  Doing meaningful things with data is challenging, even if we’re not dealing with millions or billions of things. In this book, we will be working with smaller sets of data. But much of what we’ll do will be applicable to very large amounts of data too.

Unit Summary

Computational Thinking is the thought processes involved in formulating a problem and expressing its solution in a way that a computer—human or machine—can effectively carry out.

Computational Thinking is what comes before any computing technology—thought of by a human, knowing full well the power of automation.

Writing a correct and valid algorithm to solve a computational problem is key to writing good code.

• What are the inputs?
• What are the outputs (or results)?
• Can we break the problem into parts?
• Think about the connections between the input & output.
• Consider designing ‘backwards’.
• Have you seen the problem before? In a slightly different form?
• Can you solve part of the problem?
• Did you use all the inputs?
• Can you test it on a variety of inputs?
• Can you think of how you might write the algorithm differently if you had to start again?
• Does it solve the problem? Does it meet all the requirements? Is the output correct?
• Does it terminate?
• Is it general for all cases?

Practice Problems

• Write about a process in your life (e.g. driving to the mall, walking to class, etc.) and estimate the number of steps necessary to complete the task. Would you consider this a complex or simple task? What happens if you scale that task (e.g. driving two states away to the mall)? Is your method the most efficient? Can you come up with a more efficient way?

• Write an algorithm to find the average of 25 test grades out of a possible 100 points.
• If you are given three sticks, you may or may not be able to arrange them in a triangle. For example, if one of the sticks is 12 inches long and the other two are one inch long, it is clear that you will not be able to get the short sticks to meet in the middle. For any three lengths, there is a simple test to see if it is possible to form a triangle: “If any of the three lengths is greater than the sum of the other two, then you cannot form a triangle. Otherwise, you can.”Write an algorithm that accepts three integers as arguments, and that displays either “Yes” or “No,” depending on whether you can or cannot form a triangle from sticks with the given lengths.
• ROT13 is a weak form of encryption that involves “rotating” each letter in a word by 13 places. To rotate a letter means to shift it through the alphabet, wrapping around to the beginning if necessary, so ‘A’ shifted by 3 is ‘D’ and ‘Z’ shifted by 1 is ‘A’. Write an algorithm that accepts a word and an integer from the user, and that prints a new encrypted word that contains the letters from the original word “rotated” by the given amount (the integer input). For example, “cheer” rotated by 7 is “jolly” and “melon” rotated by −10 is “cubed.”
• Write an algorithm which repeatedly accepts numbers until the user enters “done”. Once “done” is entered, display the total sum of all the numbers, the count of numbers entered, and the average of all the numbers.
• Write an algorithm that sums a series of ten positive integers entered by the user excluding all numbers greater than 100. Display the final sum.
• Wing, Jeannette M. "Computational thinking." Communications of the ACM 49.3 (2006): 33-35. ↵

Privacy Policy

• Latest Articles
• Top Articles
• Posting/Update Guidelines
• Article Help Forum

• View Unanswered Questions
• View All Questions
• View C# questions
• View C++ questions
• View Javascript questions
• View Visual Basic questions
• View Python questions
• CodeProject.AI Server
• All Message Boards...
• Running a Business
• Sales / Marketing
• Collaboration / Beta Testing
• Work Issues
• Design and Architecture
• Artificial Intelligence
• Internet of Things
• ATL / WTL / STL
• Managed C++/CLI
• Objective-C and Swift
• System Admin
• Hosting and Servers
• Linux Programming
• .NET (Core and Framework)
• Visual Basic
• Web Development
• Site Bugs / Suggestions
• Spam and Abuse Watch
• Competitions
• The Insider Newsletter
• The Daily Build Newsletter
• Newsletter archive
• CodeProject Stuff
• Most Valuable Professionals
• The Lounge  
• The CodeProject Blog
• Where I Am: Member Photos
• The Insider News
• The Weird & The Wonderful
• What is 'CodeProject'?
• General FAQ
• Ask a Question
• Bugs and Suggestions

The Beginner Programmer's guide to Problem Solving [With Example]

Have you got this feeling that you are able to grasp the concepts of programming and  you are able to understand what’s a variable, what’s a function, what are data types, etc. yet you find it difficult to solve problems in programming.  Every beginner gets this feeling.  I did too when starting out.

It is important to overcome this feeling at the earliest, otherwise it can form a mental block for you.

How it can be a mental block to you?  Common sense says that the more you practice a certain skill, you get better at that skill as time progresses.  Same goes with problem solving too.  The more problems you solve, the better you become at problem solving.  But when you get a feel that you are trying hard and still unable to solve a problem or find it extremely difficult, your confidence lowers.  At this stage, either you stop solving problems or try to solve lesser number of problems.

The point is your curriculum or your professional work is generally designed in such a manner that the order of difficulty increases as time progresses.  So, you are in a situation where you feel less confident in solving small problems but now tasked with solving bigger problems.  And the cycle continues till it becomes a permanent mental block in you.

Is it too late to start solving problems?

No.  If you have come to the realization that you need to improve your problem solving skills, you have made that good first step.  Quite often our egos don’t let us accept the obvious.  It is good to accept certain truth because that is the only way that we can improve ourselves.

What can I do to become better at solving problems?

Remove the mental block first – exercise your mind.

Your mind is your most powerful weapon.  So you have to think you can actually solve the problem.  So from today, think positively that you can solve any problem.  But you will obviously start with small problems and go on to solve bigger problems.

As with every aspect in life, it starts with conditioning the mind.  So, starting today, tell yourselves the following:

• I can solve any problem that is put at me
• I will commit at least 1-2 hours per day on solving problems alone for the next 30 days
• I will never give up on any problem that is put at me, I will ask for help if required.1

Understand the basic approach to problem solving

Do you know one of the reasons for your struggle with problem solving?  One reason might be due to lack of practice.  But the main reason is because you have not understood the basics of problem solving especially in programming.  Once you understand the approach to problem solving to the smallest of things, you can go ahead and solve bigger and more complex problems with confidence.1

Ever wondered how top tech companies like Google, Amazon solved the internet’s biggest & hardest problems?  The answer is simplicity.  They solved problems at the basic level and then went on to solve bigger and bigger problems.  You can do it too.  But you need to be good at the basics.

What do I need to understand before even trying to solve the problem?

Understand the problem clearly – the power of clarity.

You need to understand your problem clearly before even trying to solve it1.  Lack of clarity at this stage will put you down.  So make a conscious effort in understanding the problem more clearly.  Ask questions like What, Why, When, Where, What if and How.  Not all questions might be applicable to your problem, but it is important to ask questions to yourself at this stage before you go ahead trying to solve the problem.

Visualize – The Power of visualization

I am sure everyone of you is aware of what visualization is.  Trying to picturize your thoughts.  Have you ever imagined how some people can solve extra ordinary problems just by looking into those problems and they will instantly have a solution to it?  And we don’t even understand the problem fully?  It is because they do it with their mind.  They visualize the problem in their minds and they solve it in their minds itself.  Visualization is a powerful tool in your mind.

But in order to get to that state, first you need to visualize the problem externally.  That is where a pen and a paper/notebook (or) a white board comes into play1.  Try to visualize the problem at hand and try to picturize the problem.  That is also one of the steps to make sure that you understand the problem clearly.

There was a situation when I and my dear friend & colleague were discussing about a problem and we were literally going nowhere.  This was actually when we each had around 7 years of experience in the industry.  At that point, my friend said “Let’s put our points in board.  If we don’t put it on the board, we will never get started”.  And we started putting things on board.  Things started to get more clear and raised more questions and ultimately became more clear.

That is the power of visualization.  It really helps us to get started with our thinking. This visual thing works.  Just try it out.

Your next question might be “I kinda get it, but I don’t.  How do I visualize? What exactly do I visualize?”.  Please read on to find out the answers.

What is the basic approach to problem solving

Step 1:  identify small problems.

The major trick in problem solving is to identify and solve the smallest problem and then moving ahead with bigger ones.  So how do you do it?

The answer is division of responsibility.  Simply put, we need to identify parts that can stand on its own and identify a sequence in those responsibilities.  And once you start breaking down the problems into smaller ones, then you can go ahead with the next step.

Step 2:  Solve the smaller problems one at a time

Now that you have identified the smaller problems, try to solve them.  While solving them, make sure that you are focussing only on one problem at a time.  That makes life much simpler for us.  If you feel that this smaller problem is too big to solve on its own, try to break it down further.  You need to iterate steps 1 to step 3 for each smaller problem.  But for now, ignore the bigger problem and solve the rest of the problems.

• It is ok to assume that other problems are solved
• It is ok to hardcode when coding a particular problem, but later you will resolve it in step 3.
• Solve the easier problems first, that will give you confidence and momentum until you get the confidence to solve the hardest problem first.

Step 3: Connect the dots (Integration)

You have solved individual problems.  Now it is time to connect the dots by connecting the individual solution.  Identify those steps which will make the solution or the program complete.  Typically in programming, the dots are connected by passing data that is stored in variables.

Step 4: Try to optimize each step & across steps

Once you are completed with a working solution, try to optimize the solution with the best code that you can write.  This comes only with practice.  This trick can make a difference between a good programmer and a great programmer.  But to get to this step, you need to be first good at steps 1 to 3.

Let’s take an example & walkthrough the problem solving approach

Problem:  check if a user given string is a palindrome or not.

I will be using Python for this exercise (Although I have experience in1 C# and JAVA, I am also a Python beginner, so pardon any bad code).  Let’s iterate through our steps:

Let’s call this as Level 1:

Step 1:  Identify smaller problems:

Step 2: Solve the small problems

So each small problem will map to its corresponding solution as below:

Note: When solving the step (3.  Compare the variables), I am doing 2 things:

• I am making an assumption that reversed is the variable name of the reversed string.
• I am hardcoding the variable name reversed to ‘madam’ to avoid compile time error
• If you execute the program at this state, you can input ‘madam’ and check if it is printing ‘The given string is a palindrome’ (And) you can input something else like ‘dog’ and check if it is printing ‘The given string is not a palindrome’

When we are trying to connect the dots, the only thing that is missing now is the variable reversed is hardcoded.  For that to be set to the correct value, we need to break the small problem (Reverse the user input and store in a separate variable) into further smaller problems.  Till that point we need to mark it as incomplete.

2 things still remain unsolved in Level 1:

• Solution for step 2 in the diagram (Reverse the user input and store in a separate variable)
• Connecting the dots once the solution for step 2 is found

Iterating small problem 2 through our problem solving steps:

Let’s call this Level 2:

Step 1: Identify smaller problems

Step 3: Connect the dots

Here, we have already connected the dots.  So we need not do anything extra in this step.

Now we have solved the smaller problems, which means Level 2 is over.  Now we need to come back to Level 1.

If you remember, 2 things remain in Level 1.  One is solution for step 2 which we have found now.  Two is connecting the dots.

Now if we substitute the small problem 2 with the solution that we derived just now, we get something like this:

The thing that remains is connecting the dots.

So if we see what is the missing connection, the variable reversed is set twice.  One to the solution of step 2 and another is hardcoded in step 3.  So we can now remove the hardcoded value in step 3, in which case our code will become like this

If you see, we have actually solved our problem.

We are left with step 4 – Optimize each step and across steps

Step 4: Try to optimize each step and across steps

As you can see, there are many things that needs to be optimized for this code.  I would leave you to optimize the code further.  Come on, put on your thinking cap and try different solutions.

BONUS STEP 5:  Make the code robust

By robust I mean,

• Adding error & exception handling
• Using better variable names
• Adding user defined functions
• Adding comments where necessary

Again, I would leave you to figure out how to do this step.

• We saw just how we can solve problems using a step by step approach
• By solving smaller problems, I get into a momentum for solving bigger & tougher problems
• By focussing one problem at a time, I am eliminating distractions, thus allowing to better direct your efforts for that one problem rather than getting confused with many small problems at hand.
• If you understand this approach and practice, you will definitely go on to solve bigger problems and your confidence will raise.
• Beauty about breaking down the problem is that we can further convert each problem and sub problem into separate functions/modules thus making the code more modularized and maintainable.

Wait, You can’t leave yet:

Now dear beginner programmers, take any problem and try to apply this approach.  See the results for yourselves.  Now, describe the following in the comments section:

• What problem you are solving?
• How did you break it down? (Even a snap of your notebook page or board will do!)
• The final code
• How did you feel and what did you learn from this exercise?

Also remember, I am challenging you for the 30 day problem solving challenge.

If you liked this blog post, please feel free to share it with your circles in social media.

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Comments and Discussions

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

• All Articles List
• 15 April 2024
• 14687 views

Problem-Solving. How to Boost Your Ability to Solve Programming Tasks and Challenges

8 Steps to Improve Your Problem-Solving Skills as a Rookie Programmer

1. make sure you understand the problem, 2. break down the problem into smaller ones, 3. plan the solution first, 4. solve programming problems on various preparation platforms.

One of the most popular tech interview platforms with a huge community and over 1650 problems for you to practice. Supports 14 programming languages including Java.

Interview Cake

Another well-known website with all kinds of content for programmers, including programming tasks, articles, tips and lots of interview questions.

HackerEarth

Besides programming problems, this platform allows you to test yourself in mock interviews, as well as to participate in coding competitions and hackathons.

5. Use CodeGym to practice and learn how to approach programming problems

6. play coding games to practice problem-solving while having fun, 7. extend your knowledge of design patterns, algorithms, and data structures, 8. get feedback, 4 major applied programming techniques for problem solving, 1. debugging, 2. code refactoring, 3. using data structures & algorithms, 4. using version control systems.

Expert advice

Cracking the Coding Interview: Solve 5 Real World Problems

Preparing for tech interviews is no easy task. You need the skills to break down the problem and to deploy the right tools. Educative has always been on the mission to make coding interview prep more accessible for engineers. We’ve learned firsthand that the best way to succeed is not to memorize 1500+ Leetcode problems . Understanding patterns are the key to grokking the coding interview for top tech companies.

That’s why we want to approach interview prep a bit differently today by tackling some real world problems faced by tech companies. Learning how to build real world features (like “how to merge recommendations on Amazon”) is more fun, and it’s much easier to remember what you learned. If you can understand a problem’s underlying pattern, you can apply it to just about any question.

We will dive into how to crack coding interviews, solutions for a few common real world coding problems from FAANG companies and build 5 features. We will offer our solutions in Java and Python.

Crack the coding interview

Finding the motivation to prepare for the coding interview should be simple. Programmers everywhere are practicing coding problems and learning patterns , and you should too, if you want to compete for your dream job.

While preparing for a coding interview with a top tech company, it is essential to have a strong foundation in data structures, algorithms, dynamic programming, and problem-solving fundamentals .

Review the fundamental data structures , including arrays, linked lists, stacks, queues, trees, and graphs. Practice implementing these data structures and familiarize yourself with their operations and time complexities. Once you are comfortable with the basics, progress to more advanced data structures like hash tables, heaps, and tries.

Practice standard sorting and searching algorithms like quicksort, merge sort, binary search, and linear search. Review how to implement these algorithms and analyze the time and space complexity. Then, depending on the programming language, migrate to more complex algorithms like dynamic programming, graph algorithms, and divide and conquer algorithms . You must show your recruiter that you understand when to use each type of algorithm and how to optimize them for different technical questions.

Dynamic programming solves complex problems by breaking them down into smaller sub-problems and solving them recursively . Practice solving dynamic programming problems such as the knapsack problem and the maximum subarray problem . Identifying and solving these dynamic programming problems is vital to crack the coding interview.

In order to crack the coding interview, problem-solving skills are just as necessary as technical skills. Identify the problem type, break it into smaller parts, and develop a plan for solving it. Creative problem-solving is at the core of every developer , and the interviewer wants to see you demonstrate it. Try coding your solutions on a whiteboard or paper to simulate the interview experience.

In addition to mastering these concepts, it is essential to keep up with the latest technologies and relevant trends in the industry. Read tech blogs, follow news outlets, attend meetups and hackathons, and network with other software engineers on sites like GitHub and LinkedIn. Keep your skills sharpened by working on individual projects and contributing to open-source projects.

With these tips and strategies, you can ace your coding interview with a top tech company and land your dream job as a software engineer.

For more on how to crack the coding interview with a top tech company and start collecting job offers, take a look at this article about the behavioral interview questions on the Educative blog.

Understanding how to take on coding problems

Below are 10 tips and tricks for handling coding problems in your programming interview. Take these steps into each question during your interview preparation and the interview process to guarantee you’re giving yourself the best chance at success.

The first step to solving any coding problem is to understand it completely. Ensure you read the problem statement carefully , ask clarifying questions, and understand the inputs and outputs.

Feel free to ask questions if you need more information. Technical interviewers want to see that you can communicate and ask insightful questions . Especially for the trickiest algorithm problems, don’t handcuff yourself by neglecting to ask clarifying questions.

Don’t shy away from thinking out loud. As you work through the problem, explain your thought process out loud. Thinking out loud helps the interviewer understand your approach and thought process . It also acts as a fail-safe to catch any mistakes or oversights you may make.

Break the problem down into more manageable pieces . Doing this will help you tackle the problem more effectively and stay calm. It is also why understanding the overarching patterns are so helpful when solving coding problems.

Try to devise multiple solutions , even if you only implement some. This practice shows your ability to think creatively with different approaches.

Write code that is the easiest to read and understand . This includes using descriptive variable names, proper formatting, and commenting on your code when necessary.

Make sure to test your code thoroughly before submitting it. Mainly, this refers to testing edge cases and ensuring your code handles errors.

Be aware of your time constraints. Time management is absolutely vital in any coding interview. Make sure to pace yourself and spend only a little time on any one part of a coding problem. Solving a coding problem yourself is much different than solving it in front of an audience and with a time restraint. Take yourself through mock interviews in order to better prepare yourself for the actual interview.

Practice more than you think you should. Although it may appear straightforward, this learning strategy is excellent for learning anything, not just coding problems. The more you practice coding problems, the more comfortable and confident you’ll become in a coding interview. While practicing, you must focus on practicing the coding patterns behind each question instead of trying to memorize over a thousand unique coding problems.

Try to stay calm and focused during the coding interview. Take deep breaths and stay hydrated. If you’re feeling especially nervous, remember that it’s more than okay to make mistakes or not know an answer. The interviewer is more interested in your problem-solving skills and critical thought process than in getting a perfectly optimized solution.

Now, let’s start with a tutorial on five programming interview questions you’ll likely see in interviews from big tech companies !

This tutorial at a glance:

Netflix Feature: Group Similar Titles (hash maps)

Facebook feature: friend circles (dfs), google calendar feature: find meeting rooms (heaps), amazon feature: products in price range (bst), twitter feature: add likes (strings), where to go from here.

Answer any interview problem by learning the patterns behind common questions. Grokking Coding Interview Patterns in Python Grokking Coding Interview Patterns in JavaScript Grokking Coding Interview Patterns in Java Grokking Coding Interview Patterns in Go Grokking Coding Interview Patterns in C++

Netflix is one of the biggest video streaming platforms out there. The Netflix engineering team is always looking for new ways to display content. For this first problem, imagine you’re a developer on these teams.

Task: Our task here is to improve search results by enabling users to see relevant search results without being hindered by typos, which we are calling the “Group Similar Titles” feature.

First, we need to determine how to individually group any character combination for a given title. Let’s imagine that our library has the following titles: "duel", "dule", "speed", "spede", "deul", "cars" . You are tasked to design a functionality so that if a user misspells a word (for example speed as spede ), they will still be shown the correct title.

First, we need to split our titles into sets of words so that the words in a set are anagrams. We have three sets: {"duel", "dule", "deul"} , {"speed", "spede"} , and {"cars"} . The search results should include all members of the set that the string is found in.

Note: It’s best to pre-compute our sets rather than forming them when a user searches.

Learn in-demand tech skills in half the time

Mock Interview

Skill Paths

Assessments

Learn to Code

Tech Interview Prep

Generative AI

Data Science

Machine Learning

GitHub Students Scholarship

Early Access Courses

For Individuals

Try for Free

Gift a Subscription

Become an Author

Become an Affiliate

Earn Referral Credits

Cheatsheets

Frequently Asked Questions

Privacy Policy

Cookie Policy

Terms of Service

Business Terms of Service

Data Processing Agreement

Copyright © 2024 Educative, Inc. All rights reserved.

Problem Solving Through Programming in C

In this lesson, we are going to learn Problem Solving Through Programming in C. This is the first lesson while we start learning the C language.

So let’s start learning the C language.

Table of Contents

Introduction to Problem Solving Through Programming in C

Regardless of the area of the study, computer science is all about solving problems with computers. The problem that we want to solve can come from any real-world problem or perhaps even from the abstract world. We need to have a standard systematic approach to problem solving through programming in c.

computer programmers are problem solvers. In order to solve a problem on a computer, we must know how to represent the information describing the problem and determine the steps to transform the information from one representation into another.

In this chapter, we will learn problem-solving and steps in problem-solving, basic tools for designing solution as an algorithm, flowchart , pseudo code etc.

A computer is a very powerful and versatile machine capable of performing a multitude of different tasks, yet it has no intelligence or thinking power.

The Computer performs many tasks exactly in the same manner as it is told to do. This places responsibility on the user to instruct the computer in a correct and precise manner so that the machine is able to perform the required job in a proper way. A wrong or ambiguous instruction may sometimes prove dangerous.

The computer cannot solve the problem on its own, one has to provide step by step solutions of the problem to the computer. In fact, the task of problem-solving is not that of the computer.

It is the programmer who has to write down the solution to the problem in terms of simple operations which the computer can understand and execute.

Problem-solving is a sequential process of analyzing information related to a given situation and generating appropriate response options.

In order to solve a problem with the computer, one has to pass through certain stages or steps. They are as follows:

Steps to Solve a Problem With the Computer

Step 1: Understanding the Problem:

Here we try to understand the problem to be solved in totally. Before with the next stage or step, we should be absolutely sure about the objectives of the given problem.

Step 2: Analyzing the Problem:

After understanding thoroughly the problem to be solved, we look at different ways of solving the problem and evaluate each of these methods.

The idea here is to search for an appropriate solution to the problem under consideration. The end result of this stage is a broad overview of the sequence of operations that are to be carried out to solve the given problem.

Step 3: Developing the solution:

Here, the overview of the sequence of operations that was the result of the analysis stage is expanded to form a detailed step by step solution to the problem under consideration.

Step 4: Coding and Implementation:

The last stage of problem-solving is the conversion of the detailed sequence of operations into a language that the computer can understand. Here, each step is converted to its equivalent instruction or instructions in the computer language that has been chosen for the implantation.

The vehicle for the computer solution to a problem is a set of explicit and unambiguous instructions expressed in a programming language. This set of instruction is called a program with problem solving through programming in C .

A program may also be thought of as an algorithm expressed in a programming language. an algorithm, therefore, corresponds to a solution to a problem that is independent of any programming language .

To obtain the computer solution to a problem once we have the program we usually have to supply the program with input or data. The program then takes this input and manipulates it according to its instructions. Eventually produces an output which represents the computer solution to the problem.

The problem solving is a skill and there are no universal approaches one can take to solving problems. Basically one must explore possible avenues to a solution one by one until she/he comes across the right path to a solution.

In general, as one gains experience in solving problems, one develops one’s own techniques and strategies, though they are often intangible. Problem-solving skills are recognized as an integral component of computer programming.

Note: Practice C Programs for problem solving through programming in C.

Problem Solving Steps

Problem-solving is a creative process which defines systematization and mechanization. There are a number of steps that can be taken to raise the level of one’s performance in problem-solving.

A problem-solving technique follows certain steps in finding the solution to a problem. Let us look into the steps one by one:

1. Problem Definition Phase:

The success in solving any problem is possible only after the problem has been fully understood. That is, we cannot hope to solve a problem, which we do not understand. So, the problem understanding is the first step towards the solution of the problem.

In the problem definition phase, we must emphasize what must be done rather than how is it to be done. That is, we try to extract the precisely defined set of tasks from the problem statement.

Inexperienced problem solvers too often gallop ahead with the task of the problem – solving only to find that they are either solving the wrong problem or solving the wrong problem or solving just one particular problem.

2. Getting Started on a Problem:

There are many ways of solving a problem and there may be several solutions. So, it is difficult to recognize immediately which path could be more productive. Problem solving through programming in C.

Sometimes you do not have any idea where to begin solving a problem, even if the problem has been defined. Such block sometimes occurs because you are overly concerned with the details of the implementation even before you have completely understood or worked out a solution.

The best advice is not to get concerned with the details. Those can come later when the intricacies of the problem have been understood.

3. Use of Specific Examples:

To get started on a problem, we can make use of heuristics i.e the rule of thumb. This approach will allow us to start on the problem by picking a specific problem we wish to solve and try to work out the mechanism that will allow solving this particular problem.

It is usually much easier to work out the details of a solution to a specific problem because the relationship between the mechanism and the problem is more clearly defined.

This approach of focusing on a particular problem can give us the foothold we need for making a start on the solution to the general problem.

4. Similarities Among Problems:

One way to make a start is by considering a specific example. Another approach is to bring the experience to bear on the current problems. So, it is important to see if there are any similarities between the current problem and the past problems which we have solved.

The more experience one has the more tools and techniques one can bring to bear in tackling the given problem. But sometimes, it blocks us from discovering a desirable or better solution to the problem.

A skill that is important to try to develop in problem-solving is the ability to view a problem from a variety of angles.

One must be able to metaphorically turn a problem upside down, inside out, sideways, backwards, forwards and so on. Once one has developed this skill it should be possible to get started on any problem.

5. Working Backwards from the Solution:

In some cases, we can assume that we already have the solution to the problem and then try to work backwards to the starting point. Even a guess at the solution to the problem may be enough to give us a foothold to start on the problem.

We can systematize the investigations and avoid duplicate efforts by writing down the various steps taken and explorations made.

Another practice that helps to develop the problem-solving skills, once we have solved a problem, to consciously reflect back on the way we went about discovering the solution.

General Problem Solving Strategies:

There are a number of general and powerful computational strategies that are repeatedly used in various guises in computer science.

Often it is possible to phrase a problem in terms of one of these strategies and achieve considerable gains in computational efficiency.

1. Divide and Conquer:

The most widely known and used strategy, where the basic idea is to break down the original problem into two or more sub-problems, which is presumably easier or more efficient to solve.

The Splitting can be carried on further so that eventually we have many sub-problems, so small that further splitting is no necessary to solve them. We shall see many examples of this strategy and discuss the gain in efficiency due to its application.

2. Binary Doubling:

This is the reverse of the divide and conquers strategy i.e build-up the solution for a larger problem from solutions and smaller sub-problems.

3. Dynamic Programming:

Another general strategy for problem-solving which is useful when we can build-up the solution as a sequence of the intermediate steps. Problem Solving through programming in C.

The travelling salesman problem falls into this category. The idea here is that a good or optimal solution to a problem can be built-up from good or optimal solutions of the sub-problems.

4. General Search, Back Tracking and Branch-and-Bound:

All of these are variants of the basic dynamic programming strategy but are equally important.

Share This Story, Choose Your Platform!

Related posts.

What is Preprocessor in C

What is File Handling in C

Structures and Unions in C

Dynamic Programming for Beginners – How to Solve Coding Challenges with Memoization and Tabulation

Dynamic Programming is style of coding where you store the results of your algorithm in a data structure while it runs.

Understanding Dynamic Programming can help you solve complex programming problems faster.

These methods can help you ace programming interview questions about data structures and algorithms. And they can improve your day-to-day coding as well.

We released a 5-hour course on Dynamic Programming on the freeCodeCamp.org YouTube channel.

Alvin Zablan developed this course. Alvin is an experienced programming instructor at Coderbyte, a popular website for technical interview prep and coding challenges.

In this course you will learn to use Dynamic Programming strategies to solve programming challenges such as:

• Calculating the 40th number of the Fibonacci sequence.
• Counting the number of different ways to move through a 6x9 grid.
• Given a set of coins, how can you make 27 cents in the least number of coins.

This course uses images and animations to help you visualize problems and important concepts. After understanding problems conceptually, you will learn how to solve them in JavaScript using Dynamic Programming.

Even though this course uses JavaScript, you will learn concepts and knowledge that you can apply to other programming languages, including Python.

Dynamic Programming Methods This Course Covers

Part one of this course focuses on Memoization methods. This is where you use recursion and store the intermediate results of your algorithm. You can then access those results on later trips through your your loops.

Here are the Memoization strategies this course covers:

• fib memoization
• gridTraveler memoization
• memoization recipe
• canSum memoization
• howSum memoization
• bestSum memoization
• canConstruct memoization
• countConstruct memoization
• allConstruct memoization

And part two focuses on Tabulation strategies. These involve building up a table of data iteratively.

Here are the Tabulation strategies this course covers:

• fib tabulation
• gridTraveler tabulation
• tabulation recipe
• canSum tabulation
• howSum tabulation
• bestSum tabulation
• canConstruct tabulation
• countConstruct tabulation
• allConstruct tabulation

You can watch the full course on the freeCodeCamp.org YouTube channel (5-hour watch).

I'm a teacher and developer with freeCodeCamp.org. I run the freeCodeCamp.org YouTube channel.

If you read this far, thank the author to show them you care. Say Thanks

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

• SUGGESTED TOPICS
• The Magazine
• Newsletters
• Managing Yourself
• Managing Teams
• Work-life Balance
• The Big Idea
• Data & Visuals
• Reading Lists
• Case Selections
• HBR Learning
• Topic Feeds
• Account Settings
• Email Preferences

Share Podcast

A Better Framework for Solving Tough Problems

Start with trust and end with speed.

• Apple Podcasts

When it comes to solving complicated problems, the default for many organizational leaders is to take their time to work through the issues at hand. Unfortunately, that often leads to patchwork solutions or problems not truly getting resolved.

But Anne Morriss offers a different framework. In this episode, she outlines a five-step process for solving any problem and explains why starting with trust and ending with speed is so important for effective change leadership. As she says, “Let’s get into dialogue with the people who are also impacted by the problem before we start running down the path of solving it.”

Morriss is an entrepreneur and leadership coach. She’s also the coauthor of the book, Move Fast and Fix Things: The Trusted Leader’s Guide to Solving Hard Problems .

Key episode topics include: strategy, decision making and problem solving, strategy execution, managing people, collaboration and teams, trustworthiness, organizational culture, change leadership, problem solving, leadership.

HBR On Strategy curates the best case studies and conversations with the world’s top business and management experts, to help you unlock new ways of doing business. New episodes every week.

• Listen to the full HBR IdeaCast episode: How to Solve Tough Problems Better and Faster (2023)
• Find more episodes of HBR IdeaCast
• Discover 100 years of Harvard Business Review articles, case studies, podcasts, and more at HBR.org .

HANNAH BATES: Welcome to HBR On Strategy , case studies and conversations with the world’s top business and management experts, hand-selected to help you unlock new ways of doing business.

When it comes to solving complicated problems, many leaders only focus on the most apparent issues. Unfortunately that often leads to patchwork or partial solutions. But Anne Morriss offers a different framework that aims to truly tackle big problems by first leaning into trust and then focusing on speed.

Morriss is an entrepreneur and leadership coach. She’s also the co-author of the book, Move Fast and Fix Things: The Trusted Leader’s Guide to Solving Hard Problems . In this episode, she outlines a five-step process for solving any problem. Some, she says, can be solved in a week, while others take much longer. She also explains why starting with trust and ending with speed is so important for effective change leadership.

This episode originally aired on HBR IdeaCast in October 2023. Here it is.

CURT NICKISCH: Welcome to the HBR IdeaCast from Harvard Business Review. I’m Curt Nickisch.

Problems can be intimidating. Sure, some problems are fun to dig into. You roll up your sleeves, you just take care of them; but others, well, they’re complicated. Sometimes it’s hard to wrap your brain around a problem, much less fix it.

And that’s especially true for leaders in organizations where problems are often layered and complex. They sometimes demand technical, financial, or interpersonal knowledge to fix. And whether it’s avoidance on the leaders’ part or just the perception that a problem is systemic or even intractable, problems find a way to endure, to keep going, to keep being a problem that everyone tries to work around or just puts up with.

But today’s guest says that just compounds it and makes the problem harder to fix. Instead, she says, speed and momentum are key to overcoming a problem.

Anne Morriss is an entrepreneur, leadership coach and founder of the Leadership Consortium and with Harvard Business School Professor Francis Frei, she wrote the new book, Move Fast and Fix Things: The Trusted Leaders Guide to Solving Hard Problems . Anne, welcome back to the show.

ANNE MORRISS: Curt, thank you so much for having me.

CURT NICKISCH: So, to generate momentum at an organization, you say that you really need speed and trust. We’ll get into those essential ingredients some more, but why are those two essential?

ANNE MORRISS: Yeah. Well, the essential pattern that we observed was that the most effective change leaders out there were building trust and speed, and it didn’t seem to be a well-known observation. We all know the phrase, “Move fast and break things,” but the people who were really getting it right were moving fast and fixing things, and that was really our jumping off point. So when we dug into the pattern, what we observed was they were building trust first and then speed. This foundation of trust was what allowed them to fix more things and break fewer.

CURT NICKISCH: Trust sounds like a slow thing, right? If you talk about building trust, that is something that takes interactions, it takes communication, it takes experiences. Does that run counter to the speed idea?

ANNE MORRISS: Yeah. Well, this issue of trust is something we’ve been looking at for over a decade. One of the headlines in our research is it’s actually something we’re building and rebuilding and breaking all the time. And so instead of being this precious, almost farbege egg, it’s this thing that is constantly in motion and this thing that we can really impact when we’re deliberate about our choices and have some self-awareness around where it’s breaking down and how it’s breaking down.

CURT NICKISCH: You said break trust in there, which is intriguing, right? That you may have to break trust to build trust. Can you explain that a little?

ANNE MORRISS:  Yeah, well, I’ll clarify. It’s not that you have to break it in order to build it. It’s just that we all do it some of the time. Most of us are trusted most of the time. Most of your listeners I imagine are trusted most of the time, but all of us have a pattern where we break trust or where we don’t build as much as could be possible.

CURT NICKISCH: I want to talk about speed, this other essential ingredient that’s so intriguing, right? Because you think about solving hard problems as something that just takes a lot of time and thinking and coordination and planning and designing. Explain what you mean by it? And also, just  how we maybe approach problems wrong by taking them on too slowly?

ANNE MORRISS: Well, Curt, no one has ever said to us, “I wish I had taken longer and done less.” We hear the opposite all the time, by the way. So what we really set out to do was to create a playbook that anyone can use to take less time to do more of the things that are going to make your teams and organizations stronger.

And the way we set up the book is okay, it’s really a five step process. Speed is the last step. It’s the payoff for the hard work you’re going to do to figure out your problem, build or rebuild trust, expand the team in thoughtful and strategic ways, and then tell a real and compelling story about the change you’re leading.

Only then do you get to go fast, but that’s an essential part of the process, and we find that either people under emphasize it or speed has gotten a bad name in this world of moving fast and breaking things. And part of our mission for sure was to rehabilitate speed’s reputation because it is an essential part of the change leader’s equation. It can be the difference between good intentions and getting anything done at all.

CURT NICKISCH: You know, the fact that nobody ever tells you, “I wish we had done less and taken more time.” I think we all feel that, right? Sometimes we do something and then realize, “Oh, that wasn’t that hard and why did it take me so long to do it? And I wish I’d done this a long time ago.” Is it ever possible to solve a problem too quickly?

ANNE MORRISS: Absolutely. And we see that all the time too. What we push people to do in those scenarios is really take a look at the underlying issue because in most cases, the solution is not to take your foot off the accelerator per se and slow down. The solution is to get into the underlying problem. So if it’s burnout or a strategic disconnect between what you’re building and the marketplace you’re serving, what we find is the anxiety that people attach to speed or the frustration people attach to speed is often misplaced.

CURT NICKISCH: What is a good timeline to think about solving a problem then? Because if we by default take too long or else jump ahead and we don’t fix it right, what’s a good target time to have in your mind for how long solving a problem should take?

ANNE MORRISS: Yeah. Well, we’re playful in the book and talking about the idea that many problems can be solved in a week. We set the book up five chapters. They’re titled Monday, Tuesday, Wednesday, Thursday, Friday, and we’re definitely having fun with that. And yet, if you count the hours in a week, there are a lot of them. Many of our problems, if you were to spend a focused 40 hours of effort on a problem, you’re going to get pretty far.

But our main message is, listen, of course it’s going to depend on the nature of the problem, and you’re going to take weeks and maybe even some cases months to get to the other side. What we don’t want you to do is take years, which tends to be our default timeline for solving hard problems.

CURT NICKISCH: So you say to start with identifying the problem that’s holding you back, seems kind of obvious. But where do companies go right and wrong with this first step of just identifying the problem that’s holding you back?

ANNE MORRISS: And our goal is that all of these are going to feel obvious in retrospect. The problem is we skip over a lot of these steps and this is why we wanted to underline them. So this one is really rooted in our observation and I think the pattern of our species that we tend to be overconfident in the quality of our thoughts, particularly when it comes to diagnosing problems.

And so we want to invite you to start in a very humble and curious place, which tends not to be our default mode when we’re showing up for work. We convince ourselves that we’re being paid for our judgment. That’s exactly what gets reinforced everywhere. And so we tend to counterintuitively, given what we just talked about, we tend to move too quickly through the diagnostic phase.

CURT NICKISCH: “I know what to do, that’s why you hired me.”

ANNE MORRISS: Exactly. “I know what to do. That’s why you hired me. I’ve seen this before. I have a plan. Follow me.” We get rewarded for the expression of confidence and clarity. And so what we’re inviting people to do here is actually pause and really lean into what are the root causes of the problem you’re seeing? What are some alternative explanations? Let’s get into dialogue with the people who are also impacted by the problem before we start running down the path of solving it.

CURT NICKISCH: So what do you recommend for this step, for getting to the root of the problem? What are questions you should ask? What’s the right thought process? What do you do on Monday of the week?

ANNE MORRISS: In our experience of doing this work, people tend to undervalue the power of conversation, particularly with other people in the organization. So we will often advocate putting together a team of problem solvers, make it a temporary team, really pull in people who have a particular perspective on the problem and create the space, make it as psychologically safe as you can for people to really, as Chris Argyris so beautifully articulated, discuss the undiscussable.

And so the conditions for that are going to look different in every organization depending on the problem, but if you can get a space where smart people who have direct experience of a problem are in a room and talking honestly with each other, you can make an extraordinary amount of progress, certainly in a day.

CURT NICKISCH: Yeah, that gets back to the trust piece.

ANNE MORRISS: Definitely.

CURT NICKISCH: How do you like to start that meeting, or how do you like to talk about it? I’m just curious what somebody on that team might hear in that meeting, just to get the sense that it’s psychologically safe, you can discuss the undiscussable and you’re also focusing on the identification part. What’s key to communicate there?

ANNE MORRISS: Yeah. Well, we sometimes encourage people to do a little bit of data gathering before those conversations. So the power of a quick anonymous survey around whatever problem you’re solving, but also be really thoughtful about the questions you’re going to ask in the moment. So a little bit of preparation can go a long way and a little bit of thoughtfulness about the power dynamic. So who’s going to walk in there with license to speak and who’s going to hold back? So being thoughtful about the agenda, about the questions you’re asking about the room, about the facilitation, and then courage is a very infectious emotion.

So if you can early on create the conditions for people to show up bravely in that conversation, then the chance that you’re going to get good information and that you’re going to walk out of that room with new insight in the problem that you didn’t have when you walked in is extraordinarily high.

CURT NICKISCH: Now, in those discussions, you may have people who have different perspectives on what the problem really is. They also bear different costs of addressing the problem or solving it. You talked about the power dynamic, but there’s also an unfairness dynamic of who’s going to actually have to do the work to take care of it, and I wonder how you create a culture in that meeting where it’s the most productive?

ANNE MORRISS: For sure, the burden of work is not going to be equitably distributed around the room. But I would say, Curt, the dynamic that we see most often is that people are deeply relieved that hard problems are being addressed. So it really can create, and more often than not in our experience, it does create this beautiful flywheel of action, creativity, optimism. Often when problems haven’t been addressed, there is a fair amount of anxiety in the organization, frustration, stagnation. And so credible movement towards action and progress is often the best antidote. So even if the plan isn’t super clear yet, if it’s credible, given who’s in the room and their decision rights and mandate, if there’s real momentum coming out of that to make progress, then that tends to be deeply energizing to people.

CURT NICKISCH: I wonder if there’s an organization that you’ve worked with that you could talk about how this rolled out and how this took shape?

ANNE MORRISS: When we started working with Uber, that was wrestling with some very public issues of culture and trust with a range of stakeholders internally, the organization, also external, that work really started with a campaign of listening and really trying to understand where trust was breaking down from the perspective of these stakeholders?

So whether it was female employees or regulators or riders who had safety concerns getting into the car with a stranger. This work, it starts with an honest internal dialogue, but often the problem has threads that go external. And so bringing that same commitment to curiosity and humility and dialogue to anyone who’s impacted by the problem is the fastest way to surface what’s really going on.

CURT NICKISCH: There’s a step in this process that you lay out and that’s communicating powerfully as a leader. So we’ve heard about listening and trust building, but now you’re talking about powerful communication. How do you do this and why is it maybe this step in the process rather than the first thing you do or the last thing you do?

ANNE MORRISS: So in our process, again, it’s the days of the week. On Monday you figured out the problem. Tuesday you really got into the sandbox in figuring out what a good enough plan is for building trust. Wednesday, step three, you made it better. You created an even better plan, bringing in new perspectives. Thursday, this fourth step is the day we’re saying you got to go get buy-in. You got to bring other people along. And again, this is a step where we see people often underinvest in the power and payoff of really executing it well.

CURT NICKISCH: How does that go wrong?

ANNE MORRISS: Yeah, people don’t know the why. Human behavior and the change in human behavior really depends on a strong why. It’s not just a selfish, “What’s in it for me?” Although that’s helpful, but where are we going? I may be invested in a status quo and I need to understand, okay, if you’re going to ask me to change, if you’re going to invite me into this uncomfortable place of doing things differently, why am I here? Help me understand it and articulate the way forward and language that not only I can understand, but also that’s going to be motivating to me.

CURT NICKISCH: And who on my team was part of this process and all that kind of stuff?

ANNE MORRISS: Oh, yeah. I may have some really important questions that may be in the way of my buy-in and commitment to this plan. So certainly creating a space where those questions can be addressed is essential. But what we found is that there is an architecture of a great change story, and it starts with honoring the past, honoring the starting place. Sometimes we’re so excited about the change and animated about the change that what has happened before or what is even happening in the present tense is low on our list of priorities.

Or we want to label it bad, because that’s the way we’ve thought about the change, but really pausing and honoring what came before you and all the reasonable decisions that led up to it, I think can be really helpful to getting people emotionally where you want them to be willing to be guided by you. Going back to Uber, when Dara Khosrowshahi came in.

CURT NICKISCH: This is the new CEO.

ANNE MORRISS: The new CEO.

CURT NICKISCH: Replaced Travis Kalanick, the founder and first CEO, yeah.

ANNE MORRISS: Yeah, and had his first all-hands meeting. One of his key messages, and this is a quote, was that he was going to retain the edge that had made Uber, “A force of nature.” And in that meeting, the crowd went wild because this is also a company that had been beaten up publicly for months and months and months, and it was a really powerful choice. And his predecessor, Travis was in the room, and he also honored Travis’ incredible work and investment in bringing the company to the place where it was.

And I would use words like grace to also describe those choices, but there’s also an incredible strategic value to naming the starting place for everybody in the room because in most cases, most people in that room played a role in getting to that starting place, and you’re acknowledging that.

CURT NICKISCH: You can call it grace. Somebody else might call it diplomatic or strategic. But yeah, I guess like it or not, it’s helpful to call out and honor the complexity of the way things have been done and also the change that’s happening.

ANNE MORRISS: Yeah, and the value. Sometimes honoring the past is also owning what didn’t work or what wasn’t working for stakeholders or segments of the employee team, and we see that around culture change. Sometimes you’ve got to acknowledge that it was not an equitable environment, but whatever the worker, everyone in that room is bringing that pass with them. So again, making it discussable and using it as the jumping off place is where we advise people to start.

Then you’ve earned the right to talk about the change mandate, which we suggest using clear and compelling language about the why. “This is what happened, this is where we are, this is the good and the bad of it, and here’s the case for change.”

And then the last part, which is to describe a rigorous and optimistic way forward. It’s a simple past, present, future arc, which will be familiar to human beings. We love stories as human beings. It’s among the most powerful currency we have to make sense of the world.

CURT NICKISCH: Yeah. Chronological is a pretty powerful order.

ANNE MORRISS: Right. But again, the change leaders we see really get it right, are investing an incredible amount of time into the storytelling part of their job. Ursula Burns, the Head of Xerox is famous for the months and years she spent on the road just telling the story of Xerox’s change, its pivot into services to everyone who would listen, and that was a huge part of her success.

CURT NICKISCH: So Friday or your fifth step, you end with empowering teams and removing roadblocks. That seems obvious, but it’s critical. Can you dig into that a little bit?

ANNE MORRISS: Yeah. Friday is the fun day. Friday’s the release of energy into the system. Again, you’ve now earned the right to go fast. You have a plan, you’re pretty confident it’s going to work. You’ve told the story of change the organization, and now you get to sprint. So this is about really executing with urgency, and it’s about a lot of the tactics of speed is where we focus in the book. So the tactics of empowerment, making tough strategic trade-offs so that your priorities are clear and clearly communicated, creating mechanisms to fast-track progress. At Etsy, CEO Josh Silverman, he labeled these projects ambulances. It’s an unfortunate metaphor, but it’s super memorable. These are the products that get to speed out in front of the other ones because the stakes are high and the clock is sticking.

CURT NICKISCH: You pull over and let it go by.

ANNE MORRISS: Yeah, exactly. And so we have to agree as an organization on how to do something like that. And so we see lots of great examples both in young organizations and big complex biotech companies with lots of regulatory guardrails have still found ways to do this gracefully.

And I think we end with this idea of conflict debt, which is a term we really love. Leanne Davey, who’s a team scholar and researcher, and anyone in a tech company will recognize the idea of tech debt, which is this weight the organization drags around until they resolve it. Conflict debt is a beautiful metaphor because it is this weight that we drag around and slows us down until we decide to clean it up and fix it. The organizations that are really getting speed right have figured out either formally or informally, how to create an environment where conflict and disagreements can be gracefully resolved.

CURT NICKISCH: Well, let’s talk about this speed more, right? Because I think this is one of those places that maybe people go wrong or take too long, and then you lose the awareness of the problem, you lose that urgency. And then that also just makes it less effective, right? It’s not just about getting the problem solved as quickly as possible. It’s also just speed in some ways helps solve the problem.

ANNE MORRISS: Oh, yeah. It really is the difference between imagining the change you want to lead and really being able to bring it to life. Speed is the thing that unlocks your ability to lead change. It needs a foundation, and that’s what Monday through Thursday is all about, steps one through four, but the finish line is executing with urgency, and it’s that urgency that releases the system’s energy, that communicates your priorities, that creates the conditions for your team to make progress.

CURT NICKISCH: Moving fast is something that entrepreneurs and tech companies certainly understand, but there’s also this awareness that with big companies, the bigger the organization, the harder it is to turn the aircraft carrier around, right? Is speed relative when you get at those levels, or do you think this is something that any company should be able to apply equally?

ANNE MORRISS: We think this applies to any company. The culture really lives at the level of team. So we believe you can make a tremendous amount of progress even within your circle of control as a team leader. I want to bring some humility to this and careful of words like universal, but we do think there’s some universal truths here around the value of speed, and then some of the byproducts like keeping fantastic people. Your best people want to solve problems, they want to execute, they want to make progress and speed, and the ability to do that is going to be a variable in their own equation of whether they stay or they go somewhere else where they can have an impact.

CURT NICKISCH: Right. They want to accomplish something before they go or before they retire or finish something out. And if you’re able to just bring more things on the horizon and have it not feel like it’s going to be another two years to do something meaningful.

ANNE MORRISS: People – I mean, they want to make stuff happen and they want to be around the energy and the vitality of making things happen, which again, is also a super infectious phenomenon. One of the most important jobs of a leader, we believe, is to set the metabolic pace of their teams and organizations. And so what we really dig into on Friday is, well, what does that look like to speed something up? What are the tactics of that?

CURT NICKISCH: I wonder if that universal truth, that a body in motion stays in motion applies to organizations, right? If an organization in motion stays in motion, there is something to that.

ANNE MORRISS: Absolutely.

CURT NICKISCH: Do you have a favorite client story to share, just where you saw speed just become a bit of a flywheel or just a positive reinforcement loop for more positive change at the organization?

ANNE MORRISS: Yeah. We work with a fair number of organizations that are on fire. We do a fair amount of firefighting, but we also less dramatically do a lot of fire prevention. So we’re brought into organizations that are working well and want to get better, looking out on the horizon. That work is super gratifying, and there is always a component of, well, how do we speed this up?

What I love about that work is there’s often already a high foundation of trust, and so it’s, well, how do we maintain that foundation but move this flywheel, as you said, even faster? And it’s really energizing because often there’s a lot of pent-up energy that… There’s a lot of loyalty to the organization, but often it’s also frustration and pent-up energy. And so when that gets released, when good people get the opportunity to sprint for the first time in a little while, it’s incredibly energizing, not just for us, but for the whole organization.

CURT NICKISCH: Anne, this is great. I think finding a way to solve problems better but also faster is going to be really helpful. So thanks for coming on the show to talk about it.

ANNE MORRISS:  Oh, Curt, it was such a pleasure. This is my favorite conversation. I’m delighted to have it anytime.

HANNAH BATES: That was entrepreneur, leadership coach, and author Anne Morriss – in conversation with Curt Nickisch on HBR IdeaCast.

We’ll be back next Wednesday with another hand-picked conversation about business strategy from Harvard Business Review. If you found this episode helpful, share it with your friends and colleagues, and follow our show on Apple Podcasts, Spotify, or wherever you get your podcasts. While you’re there, be sure to leave us a review.

When you’re ready for more podcasts, articles, case studies, books, and videos with the world’s top business and management experts, you’ll find it all at HBR.org.

This episode was produced by Mary Dooe, Anne Saini, and me, Hannah Bates. Ian Fox is our editor. Special thanks to Rob Eckhardt, Maureen Hoch, Erica Truxler, Ramsey Khabbaz, Nicole Smith, Anne Bartholomew, and you – our listener. See you next week.

• Subscribe On:

Latest in this series

This article is about strategy.

• Decision making and problem solving
• Strategy execution
• Leadership and managing people
• Collaboration and teams
• Trustworthiness
• Organizational culture

Partner Center