COS 102: Problem Solving

• This presentation covers Problem Solving-NUT-COS 102.
• It looks into what problem-solving is, why it is important, the differences between routine and non-routine problems, and how to identify problems in real-life and computing contexts.

Definition of Problem-Solving

• Problem-solving involves identifying and analysing challenges or obstacles to find solutions.
• Problem-solving uses a systematic approach to addressing issues and achieving desired outcomes.

Key Components of Problem-Solving

• Understanding the Problem involves recognizing the gap between the current and the desired states.
• Planning a Solution means devising strategies to bridge the gap.
• Executing the Solution means implementing the chosen approach.
• Evaluating the Outcome is reviewing the effectiveness of the solution.

Importance of Problem-Solving

• It helps address everyday challenges, such as deciding the quickest route to work, school, the mall or the airport.
• Problem-solving is critical for decision-making, innovation, and efficiency in workplace settings.
• It is essential for developing algorithms, debugging programs, and creating systems that address user needs.

Differences Between Routine Problems

• These are predictable problems with predefined methods or formulas for solving them.
• Routine problems are repetitive and straightforward.
• They require the application of learned rules or procedures.
• Routine problems often have one correct solution.
• Calculating the sum of two numbers is a routine problem.
• Writing a loop to process a list in programming is a routine problem.

Non-Routine Problems

• These are unique, complex problems that require creative thinking and the application of problem-solving techniques.
• These problems are unpredictable and multifaceted.
• They may require exploration and experimentation.
• Non-routine problems often have multiple solutions or approaches.
• Designing an algorithm for facial recognition is a non-routine problem.
• Solving an optimization problem in logistics is a non-routine problem.

Comparison of Routine vs Non-Routine Problems

• Routine problems are predictable and well-defined; non-routine problems are unpredictable and complex.
• Routine problem solving is rule-based and formulaic; non-routine involves creative, exploratory solutions.
• Example of a routine problem is arithmetic operations; non-routine is designing AI algorithms.

Identifying Problems in Real-Life Contexts

• Household Challenges: Managing time for cooking, cleaning, and errands.
• Transportation Issues: Finding the shortest route to a destination.
• Financial Decisions: Budgeting expenses to save for a major purchase.
• Deciding whether to rent or buy a car based on long-term costs is an example of problem solving.
• Determining the best time to shop to avoid crowds is an example of problem solving.

Computing Contexts

• Data Analysis: Extracting meaningful insights from raw data.
• System Design: Creating software that meets user requirements.
• Debugging: Identifying and resolving errors in code.
• Writing a function to calculate the factorial of a number is problem solving.
• Developing a sorting algorithm to organize data efficiently efficiently is problem solving.

Steps for Identifying Problems in Computing

• Understanding the Goal means clearly define what you want to achieve.
• Analysing the Current State means you Identify gaps between the existing setup and the goal.
• Breaking Down the Problem means divide the problem into smaller, manageable parts.
• Formulating Requirements means specify what a successful solution looks like.

Practical Example: Routine Problem

• Writing a program to calculate the sum of two numbers provided by the user.
• This follows a predictable process, is well-defined, is repeatable, and has a single, straightforward solution.
• Accept two numbers as input from the user; add the two numbers; display the result.

Code Example in Python

## Program to calculate the sum of two numbers
## Step 1: Take input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))
## Step 2: Add the numbers
result = num1 + num2
## Step 3: Display the result
print(f"The sum of {num1} and {num2} is
{result}.")

Practical Example: Non-Routine Problem

• Designing an algorithm that predicts a user's next shopping preference based on past purchases.
• This requires creative thinking, analysis, and possibly multiple approaches to reach a solution.

Solution Steps (Algorithm Design)

• Collect Data: Gather the user's past purchase history (e.g., product categories, purchase frequency).
• Analyse Patterns: Identify trends such as the most frequently bought items or seasonal preferences.
• Build a Prediction Model: Use a rule-based or machine learning approach to suggest the next likely preference.
• Test the Model: Compare predictions against actual user behaviour for accuracy.

Example Algorithm

• Input: User purchase history ([Electronics, Books, Electronics, Home Appliances, Books, Books]).
• Counting the frequency of each category: Electronics: 2; Books: 3; Home Appliances: 1.
• Predict the most likely next category: Books.

Code

## Program to predict user's next shopping preference
from collections import Counter
## Step 1: User's purchase history
purchase_history = ["Electronics", "Books", "Electronics", "Home
Appliances", "Books", "Books"]
## Step 2: Count the frequency of each category
category_count = Counter(purchase_history)
## Program to predict user's next shopping preference
## Get the category with the highest count
most_common_category = category_count.most_common(1)[0]
[0]
## Program to predict user's next shopping preference
print(f"Count the purchase history of items: {category_count}")
## Print the result
print(f"The user's next likely shopping preference is:
{most_common_category}")

Comparison of Routine Problems

• Nature: Routine problems are straightforward, predictable.
• Solution: Direct formula or steps.
• Example Output: Sum of two numbers.
• Skills Required: Basic programming (input, arithmetic, output).

Comparison of Non-Routine Problems

• Nature: Complex, requires analysis and creativity.
• Solution: Iterative and exploratory.
• Example Output: Prediction of user preferences.
• Skills Required: Pattern recognition, algorithms, or machine learning.

Classification of Problems

• Problem: Calculating the area of a circle classification is routine.
• Reason: A standard formula is used.

Problem Classification

• Problem: Developing a system for automating attendance tracking classification is non-routine.
• Reason: Requires system design and problem analysis.

Examples

• Printing the first 10 numbers in a sequence is routine because a simple loop suffices for this task.
• Detecting spam emails is a non-routine task because it needs pattern recognition and testing.
• Converting temperatures is routine because formula-based conversion can use.
• Creating a chatbot is non-routine as it requires NLP and advanced programming techniques.
• Finding the largest number in a list is routine as one uses basic logic or a single function.
• Optimizing delivery routes is non-routine as it needs complex optimization algorithms.
• Drawing a flowchart for calculations is routine as it follows predefined steps to solve the problem.
• Building a recommendation system is non-routine as it requires advanced algorithms and data analysis.

Examples of Dual-Category Problems

• Finding the Largest Number in a List of Integers can be routine or non-routine.
• Routine Approach: Use a simple loop or a built-in function like max() in Python to find the largest number.
• Non-Routine Approach: If the dataset is massive (e.g., stored across distributed systems), solving this problem might require creating a custom algorithm to optimize memory and processing, making it complex.

Drawing a Flowchart for a Process.

• Routine Approach: Drawing a flowchart for a simple calculation, like adding two numbers, follows predefined steps.
• Non-Routine Approach: Designing a flowchart for a decision-making system (e.g., diagnosing medical conditions) could involve multiple branching scenarios, and creative problem-solving.

Automating Attendance Tracking.

• Routine Approach: Use a standard software or application with predefined templates and tools requires minimal creativity.
• Non-Routine Approach: Designing a custom system with advanced features like facial recognition or integration with multiple databases would make it a non-routine problem.

Sorting a List of Numbers.

• Routine Approach: Use standard sorting algorithms (e.g., Bubble Sort, Quick Sort) or built-in functions in programming languages like sorted() in Python.
• Non-Routine Approach: If the data is distributed across multiple servers, sorting requires a distributed algorithm like MapReduce, which is far more complex.

Developing a Budget Plan.

• Routine Approach: Using predefined spreadsheet templates with fixed formulas for income and expense calculation.
• Non-Routine Approach: Building a dynamic budget prediction system based on trends and external factors (e.g., market volatility), requires advanced modelling.

Why Problems Can Be Dual-Category

• Whether a problem is routine or non-routine often depends on the context in which it is presented, the approach and tools available, and the experience and expertise of the problem solver.

Problem-Solving Techniques objectives are:

• Abstraction
• Analogy
• Brainstorming
• Trial and Error

Abstraction

• It means simplifying a complex problem by focusing only on the essential details while ignoring irrelevant information.
• Abstraction makes problems more manageable.
• Abstraction reduces complexity by isolating key elements.
• Identify the essential components of the problem; eliminate details that do not affect the solution; work on the simplified version of the problem.
• Real-world abstraction involves simplifying a map by showing only major highways and landmarks to help plan a route.
• Computing abstraction involves when designing software, focus on user requirements first and defer lower-level implementation details (e.g., design a login feature without initially focusing on backend architecture).

Analogy

• Analogy is when you solve a problem by drawing parallels to a similar problem that has already been solved.
• Analogy leverages existing knowledge or solutions.
• Analogy encourages creative thinking by finding similarities between seemingly unrelated problems.
• Using the mechanics of a seesaw to understand the concept of leverage is an analogy.
• Computing analogy is comparing the structure of a file hierarchy to a tree diagram to understand folder organization.

Brainstorming

• It is one that generates as many ideas as possible for solving a problem, without immediately evaluating their feasibility.
• Brainstorming encourages out-of-the-box thinking.
• It helps explore multiple approaches to solving a problem.
• First define the problem clearly, allow individuals or groups to freely propose ideas, and record all ideas without criticism.
• Evaluate and refine the ideas after brainstorming.
• Real-world brainstorming is used to find ways to reduce energy consumption at home.
• Computing brainstorms generate features for a new mobile app during a product planning session.

Trial and Error

• This means testing multiple solutions or approaches until the correct one is found.
• Trial and Error is useful when the correct solution is not apparent.
• It promotes learning through experimentation.
• One must attempt a solution, evaluate the results, and modify the approach if necessary and retry.
• Real-world Trial and Error: Adjusting the recipe for a cake by testing different amounts of sugar.
• Computing Trial and Error: Debugging a faulty program by testing code snippets one at a time to isolate the issue.

Real-World Applications of Techniques in Computing

• Abstraction application is in software design and system architecture.
• Example: When developing a calculator app, focus on the main arithmetic functions (addition, subtraction) before integrating advanced features (e.g., trigonometry or graphs).
• Analogy application is Algorithm development.
• Example: Using the analogy of a library catalog system to design a database indexing method.
• Brainstorming application is Feature planning for new software.
• Example: Brainstorming user-friendly features for a learning management system (LMS) such as notifications, chat options, and file sharing.
• Trial and error is useful in debugging and optimization.
• Example: Testing various sorting algorithms (e.g., Bubble Sort, Merge Sort) to determine the fastest for a particular dataset.

Solve a problem of this institution using brainstorming techniques and document the step-by-step process

• A Task for Students!

Brainstorming steps:

• Defining the Problem
• create a simple and efficient system to track assignments and deadlines.
• Brainstorm Solutions
• Ideas might include: A physical planner, A mobile app with reminders, An online collaborative tool (e.g., Google Sheets), and a Chatbot that sends reminders.
• Evaluate Ideas
• Choose the idea that balances cost, accessibility, and usability
• Develop a Plan
• Add assignments with deadlines, set reminders for upcoming deadlines, and mark assignments as completed.
• Prototype and Test
• Creating a basic interface and test its usability with a small group of students.