Order of Steps in Problem Solving

Overview

Solving a problem in computer science requires a clear and logical sequence of steps. Determining the correct order of steps ensures that algorithms and programs work as intended. Understanding how to structure these steps is essential for writing efficient and error-free code.

This note covers how to identify, arrange, and represent the steps needed to solve a problem using pseudocode, flowcharts, and code.

Problem-Solving Steps

• Definition: The sequence of actions or operations required to achieve a specific goal or solve a problem.
• Purpose: Ensures the solution follows a logical order, avoiding errors and inefficiencies.

Common Problem-Solving Steps:

• Understand the Problem: Define the inputs, processes, and outputs.
• Break Down the Problem: Divide the problem into smaller, manageable tasks.
• Plan the Solution: Identify the sequence of operations.
• Implement the Solution: Write pseudocode, code, or draw a flowchart.
• Test the Solution: Check if it works as expected, and refine it if necessary.

Representing Problem-Solving Steps

Pseudocode

• Definition: A high-level, language-agnostic description of the algorithm.
• Purpose: Helps plan the sequence of steps before actual coding.

START
INPUT temperature
IF temperature > 30 THEN
    PRINT "It's hot"
ELSE
    PRINT "It's not hot"
ENDIF
END

Flowcharts

• Definition: A visual representation of the steps in an algorithm.
• Purpose: Provides a clear view of the process flow, making it easier to understand and debug.
• Symbols:
  • Oval: Start/End.
  • Rectangle: Process/Task.
  • Diamond: Decision point.
  • Arrow: Flow of control.

Code

• After pseudocode or flowcharts, the steps are translated into code using a programming language.

temperature = int(input("Enter temperature: "))
if temperature > 30:
    print("It's hot")
else:
    print("It's not hot")

How to Determine the Order of Steps

1. Identify Inputs: Determine what data the program requires to start (e.g., user inputs, data files).
2. Define Processes: Identify the operations needed to process the inputs (e.g., calculations, decisions).
3. Determine Outputs: Define what the program should produce or display.
4. Sequence the Steps: Arrange the steps in a logical order:

• Start with inputs.
• Process the data.
• Make decisions if needed.
• Produce outputs.
• End the program.

5. Use Control Structures:

• Sequential Steps: Execute one step after another.
• Conditional Steps: Use IF or CASE to make decisions.
• Loops: Use FOR, WHILE, or REPEAT to repeat processes.

Example: Vending Machine Problem

Problem Statement: Design a program for a vending machine that dispenses a drink when the correct amount is inserted.

Steps in Order:

6. Start.
7. Display available drinks and their prices.
8. Accept user input for drink selection.
9. Prompt the user to insert money.
10. Check if the inserted amount is sufficient:

• If yes, dispense the drink and return any change.
• If no, prompt for additional money.

11. End. Pseudocode:

START
DISPLAY "Select a drink:"
INPUT drink
DISPLAY "Insert money:"
INPUT money
WHILE money < price[drink] DO
    DISPLAY "Insufficient funds, insert more money:"
    INPUT additional_money
    money = money + additional_money
ENDWHILE
DISPENSE drink
IF money > price[drink] THEN
    RETURN change
ENDIF
END

Flowchart:

12. Start.
13. Display drinks → Input selection → Input money.
14. Decision: Is money sufficient?

• Yes → Dispense drink → Return change → End.
• No → Loop back to "Input additional money."

Note Summary