PROBLEM SOLVING
Comprehensive Study Notes
Concise Notes for Test Preparation
Topics Covered:
Problem Understanding, Logical Reasoning, Algorithms, Data Representation,
Pattern Recognition, Mathematical Reasoning, Critical Thinking, Debugging,
Complexity Analysis, Programming, Creative Thinking, Real-World Applications
2024 Edition
Table of Contents
1. Introduction to Problem Solving
2. Problem Understanding & Analysis
3. Logical Reasoning Fundamentals
4. Algorithms & Flow Control
5. Data Representation & Abstraction
6. Pattern Recognition & Generalization
7. Mathematical & Quantitative Reasoning
8. Algorithmic Thinking
9. Critical Thinking & Decision Making
10. Debugging & Error Analysis
11. Complexity & Efficiency Awareness
12. Problem Solving Using Programming
13. Data-Driven Problem Solving
14. Creative & Innovative Thinking
15. Real-World Problem Solving
16. Communication & Documentation of Solutions
1. Introduction to Problem Solving
1.1 Definition
Problem: A situation where there is a gap between current state and desired goal state
Problem Solving: The process of identifying a problem, developing solutions, and implementing the best solution
to achieve the desired goal
1.2 Key Components of Problem Solving
Problem Space: All possible states and operators in the problem domain
Initial State: Starting condition or situation
Goal State: Desired outcome or solution
Operators: Actions or moves that transform one state to another
Constraints: Rules or limitations that restrict possible solutions
1.3 Problem Solving Process (General Steps)
1. Define: Clearly identify and understand the problem
2. Analyze: Break down into smaller parts, identify root cause
3. Generate: Brainstorm potential solutions
4. Evaluate: Assess feasibility, pros/cons of each solution
5. Select: Choose the best solution based on criteria
6. Implement: Execute the chosen solution
7. Review: Evaluate outcome and refine if necessary
1.4 Types of Problems
Type Characteristics Example
Clear goals, defined constraints, known
Well-Structured Math equations, puzzles
solutions exist
Unclear goals, ambiguous constraints,
Ill-Structured Social issues, design
multiple solutions
Familiar, solved using established
Routine Following a recipe
procedures
Non-Routine Novel, requires creative approaches New product development
1.5 Problem Solving Approaches
Algorithmic: Step-by-step procedure guaranteeing a solution
Heuristic: Rule of thumb or shortcut, no guarantee but faster
Insight-based: Sudden realization or "Aha!" moment
Trial and Error: Testing multiple solutions until one works
1.6 Barriers to Problem Solving
Mental Set: Tendency to use approaches that worked before (rigid thinking)
Functional Fixedness: Seeing objects only in their usual function
Confirmation Bias: Seeking information that confirms existing beliefs
Anchoring: Over-relying on first piece of information
Information Overload: Too much data hampers decision making
2. Problem Understanding & Analysis
2.1 Problem Definition
Goal: Transform vague problem statement into clear, specific definition
Ask: What is the real problem? Why is it a problem? Who is affected?
2.2 Problem Analysis Techniques
5W1H Method: Who, What, Where, When, Why, How
Root Cause Analysis: Finding the fundamental cause of a problem
Ishikawa Diagram (Fishbone): Categorizes potential causes (Man, Machine, Material, Method, Environment)
5 Whys: Repeatedly ask "Why?" to reach root cause
2.3 Problem Decomposition
Breaking complex problem into smaller, manageable sub-problems
Benefits: Reduces complexity, enables parallel work, easier to solve
Methods: Functional decomposition, Structural decomposition, Chronological decomposition
2.4 Problem Representation
Verbal: Natural language description
Visual: Diagrams, charts, mind maps
Mathematical: Equations, formulas
Symbolic: Symbols, notation systems
2.5 Problem Statement Components
Current State: Where we are now
Desired State: Where we want to be
Gap: Difference between current and desired
Constraints: Limitations and boundaries
Stakeholders: People affected by the problem
2.6 Analytical Frameworks
SWOT Analysis: Strengths, Weaknesses, Opportunities, Threats
PESTLE: Political, Economic, Social, Technological, Legal, Environmental
Gap Analysis: Compare current vs. desired performance
3. Logical Reasoning Fundamentals
3.1 Definition
Logical reasoning is the process of drawing valid conclusions from given premises using established rules of
inference
3.2 Types of Logical Reasoning
Type Description Pattern
General to specific; conclusion necessarily All A are B; X is A; Therefore X is
Deductive
follows from premises B
Specific to general; conclusion probable X, Y, Z are A and B; Therefore all
Inductive
based on evidence A are B
Inference to best explanation; most likely Observation B; If A then B;
Abductive
cause Therefore possibly A
3.3 Deductive Reasoning
Syllogism: Three-part argument with major premise, minor premise, conclusion
Validity vs Soundness:
Valid: Conclusion follows logically from premises (structure is correct)
Sound: Valid argument with true premises (both structure and content correct)
3.4 Inductive Reasoning
Generalization: Drawing general conclusions from specific instances
Analogy: Inferring similarity between things based on shared characteristics
Causal Inference: Determining cause-effect relationships
Strength: Inductive arguments can be strong or weak, not valid/invalid
3.5 Logical Operators
Operator Symbol Meaning
AND AND True if both operands true
OR OR True if at least one true
NOT ~ Negation of operand
IMPLIES --> If...then relationship
IFF (If and only if) <--> Biconditional; both directions
3.6 Common Logical Fallacies
Ad Hominem: Attacking the person instead of the argument
Straw Man: Misrepresenting opponent's argument to make it easier to attack
False Dilemma: Presenting only two options when more exist
Slippery Slope: Suggesting one action leads to chain of negative events
Circular Reasoning: Conclusion is assumed in the premise
Post Hoc: Assuming correlation implies causation
Appeal to Authority: Using authority figure as sole evidence
4. Algorithms & Flow Control
4.1 Algorithm Definition
A step-by-step procedure or formula for solving a problem in finite number of steps
4.2 Properties of Algorithms
Finiteness: Must terminate after finite number of steps
Definiteness: Each step must be precisely defined
Input: Zero or more inputs
Output: One or more outputs
Effectiveness: Each step must be basic enough to be executed
4.3 Flow Control Structures
Structure Description Usage
Sequence Execute statements one after another Default flow
Selection Execute based on condition (if-else, switch) Decision making
Iteration Repeat block of code (for, while, do-while) Repetition
Subroutine Call and return from procedures/functions Modularity
4.4 Algorithm Representation
Pseudocode: Informal high-level description using natural language and programming constructs
Flowchart: Graphical representation using standard symbols
Decision Table: Table showing actions for all combinations of conditions
Nassi-Shneiderman Diagram: Structured flowchart (no goto)
4.5 Flowchart Symbols
Oval: Start/End (terminator)
Rectangle: Process/Operation
Diamond: Decision (yes/no question)
Parallelogram: Input/Output
Arrow: Flow direction
Rectangle with double bars: Predefined process/subroutine
4.6 Control Flow Patterns
Conditional: if, if-else, if-else-if, nested if, switch-case
Loop: while (entry-controlled), do-while (exit-controlled), for (counter)
Break/Continue: Exit loop early or skip iteration
Nested Control: Control structures inside other control structures
5. Data Representation & Abstraction
5.1 Data Representation
Methods of encoding and storing information in a format that can be processed by computers
5.2 Basic Data Types
Type Examples Operations
Integer -5, 0, 42 +, -, *, /, mod
Float/Real 3.14, -0.5, 2.0e10 +, -, *, /
Boolean True, False AND, OR, NOT
Character 'A', '5', '@' Comparison, concatenation
String "Hello" Concatenation, substring, length
5.3 Data Structures
Array: Fixed-size collection of same type elements, indexed access
List/Linked List: Dynamic collection, sequential access, nodes linked
Stack: LIFO (Last In First Out), push/pop operations
Queue: FIFO (First In First Out), enqueue/dequeue operations
Tree: Hierarchical structure with root, nodes, leaves
Graph: Vertices connected by edges, can represent relationships
Hash Table: Key-value pairs with fast lookup
5.4 Abstraction
Definition: Hiding implementation details while showing only essential features
Levels:
Data Abstraction: Hide data representation details (e.g., abstract data types)
Procedural Abstraction: Hide implementation details of operations
Control Abstraction: Hide control flow details (e.g., loops as iterators)
5.5 Abstract Data Types (ADT)
Mathematical model defining data type by its behavior (operations), not implementation
Examples: Stack ADT, Queue ADT, List ADT, Dictionary ADT
ADT = Data + Operations + Constraints (implementation hidden from user)
5.6 Information Hiding
Design principle: Modules should hide internal details from other modules
Benefits: Reduces complexity, enables modularity, easier maintenance
6. Pattern Recognition & Generalization
6.1 Pattern Recognition
Identifying regularities, trends, or recurring structures in data or problems
6.2 Types of Patterns
Numerical: Arithmetic, geometric, Fibonacci sequences
Geometric: Shapes, symmetry, tessellations
Behavioral: Repeated actions, habits, trends
Structural: Architecture, code patterns, design patterns
Linguistic: Grammar, syntax, language patterns
6.3 Pattern Recognition Process
1. Observation: Collect and examine data
2. Identification: Find recurring elements or relationships
3. Description: Express pattern in formal or natural language
4. Prediction: Use pattern to predict future occurrences
5. Verification: Test predictions against new data
6.4 Generalization
Definition: Extending specific observations to broader rules or principles
Purpose: Create reusable solutions, transfer learning to new problems
Risk: Overgeneralization can lead to incorrect conclusions
6.5 Common Number Patterns
Pattern Type Example Formula
Arithmetic 2, 5, 8, 11, 14... a_n = a_1 + (n-1)d
Geometric 2, 6, 18, 54... a_n = a_1 * r^(n-1)
Fibonacci 1, 1, 2, 3, 5, 8, 13... F_n = F_(n-1) + F_(n-2)
Square 1, 4, 9, 16, 25... a_n = n^2
Triangular 1, 3, 6, 10, 15... a_n = n(n+1)/2
6.6 Abstraction in Pattern Recognition
Extract essential features of pattern, ignore irrelevant details
Example: "Sort items" is abstract pattern; implementation varies (bubble sort, quick sort)
7. Mathematical & Quantitative Reasoning
7.1 Mathematical Reasoning
Using mathematical concepts, logic, and procedures to analyze and solve problems
7.2 Key Mathematical Concepts
Set Theory: Sets, subsets, union, intersection, complement, Venn diagrams
Functions: Domain, range, mapping, one-to-one, onto, inverse functions
Relations: Equivalence, order, transitive, reflexive, symmetric properties
Combinatorics: Permutations, combinations, counting principles
Probability: Events, conditional probability, Bayes theorem
7.3 Counting Principles
Addition Rule: If A and B are disjoint, |A OR B| = |A| + |B|
Multiplication Rule: If task 1 has m ways, task 2 has n ways: m x n total ways
Permutation: nP r = n! / (n-r)! (arrangement matters)
Combination: nCr = n! / (r! * (n-r)!) (order doesn't matter)
7.4 Quantitative Problem Solving
Steps:
1. Understand the problem: Identify given information and what to find
2. Devise a plan: Select appropriate method or formula
3. Execute: Perform calculations accurately
4. Verify: Check reasonableness of answer
7.5 Ratio, Proportion, and Percentages
Ratio: Comparison of two quantities (a:b or a/b)
Proportion: Equality of two ratios (a:b = c:d)
Percentage: Part per hundred; P% = P/100
7.6 Estimation and Approximation
Estimation: Finding approximate value when exact value not needed
Rounding: Approximating to specified decimal places or significant figures
Order of Magnitude: Powers of 10 comparison
8. Algorithmic Thinking
8.1 Definition
A problem-solving approach that involves breaking down problems into clear, step-by-step procedures that can be
executed systematically
8.2 Key Components
Decomposition: Break complex problem into smaller sub-problems
Pattern Matching: Identify similarities with previously solved problems
Abstraction: Focus on essential details, ignore irrelevant complexity
Algorithm Design: Create step-by-step solution procedure
8.3 Problem-Solving Strategies
Divide and Conquer: Divide problem into sub-problems, solve each, combine results
Dynamic Programming: Break into overlapping sub-problems, store results to avoid recomputation
Greedy Approach: Make locally optimal choice at each step
Backtracking: Build solution incrementally, abandon paths that fail constraints
Brute Force: Try all possible solutions until finding correct one
8.4 Algorithm Design Techniques
Top-Down: Start with general solution, refine details progressively
Bottom-Up: Start with basic components, build up to complete solution
Stepwise Refinement: Gradually add detail to algorithm in steps
8.5 Common Algorithms
Category Algorithms
Sorting Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, Quick Sort, Heap Sort
Searching Linear Search, Binary Search, Hash Search
Graph BFS, DFS, Dijkstra, Bellman-Ford, Prim, Kruskal
Dynamic Programming Fibonacci, Knapsack, Longest Common Subsequence, Edit Distance
9. Critical Thinking & Decision Making
9.1 Critical Thinking Definition
Objective analysis and evaluation of information to form a judgment; questioning assumptions and examining
evidence
9.2 Critical Thinking Skills
Analysis: Break down information into components
Evaluation: Assess credibility and relevance of information
Inference: Draw reasonable conclusions from evidence
Interpretation: Understand meaning and significance
Self-Regulation: Monitor and correct one's own thinking
9.3 Decision Making Process
1. Identify Decision: What needs to be decided?
2. Gather Information: Collect relevant data
3. Identify Alternatives: List possible options
4. Evaluate: Weigh pros and cons of each option
5. Choose: Select best alternative
6. Implement: Execute decision
7. Review: Evaluate outcome and learn
9.4 Decision Making Models
Rational Model: Systematic, logical, maximize utility
Bounded Rationality: Satisficing (good enough) due to limited resources
Intuitive Model: Based on experience and gut feeling
Creative Model: Generate novel alternatives
9.5 Decision Making Tools
Decision Matrix: Evaluate options against weighted criteria
Decision Tree: Visual representation of choices and outcomes
Cost-Benefit Analysis: Compare costs and benefits of options
Pros-Cons List: Simple listing of advantages and disadvantages
9.6 Cognitive Biases in Decision Making
Confirmation Bias: Favoring information confirming existing beliefs
Availability Bias: Overweighting easily recalled information
Sunk Cost Fallacy: Continuing due to past investment
Framing Effect: Decisions influenced by presentation
Overconfidence: Excessive confidence in one's own judgments
10. Debugging & Error Analysis
10.1 Definition
Debugging: Process of finding and resolving defects or errors in a system
Error Analysis: Systematic examination of errors to understand causes
10.2 Types of Errors
Error Type Description Detection
Syntax Error Violation of language grammar rules Compile time
Error during program execution (divide by
Runtime Error During execution
zero)
Logical Error Program runs but produces wrong result Testing/review
Semantic Error Code syntax correct but meaning wrong Testing/review
10.3 Debugging Process
1. Reproduce: Consistently reproduce the error
2. Isolate: Narrow down location of defect
3. Understand: Analyze the cause of error
4. Fix: Correct the defect
5. Verify: Confirm fix works without introducing new bugs
10.4 Debugging Techniques
Print Debugging: Insert print statements to trace execution
Debugger Tools: Step-through execution, breakpoints, watch variables
Binary Search: Narrow down by testing half the code at a time
Backtracking: Work backwards from point of failure
Rubber Duck Debugging: Explain code line by line to identify issues
10.5 Error Prevention
Write clear, readable code; Use meaningful names; Add comments
Test frequently; Use version control; Code reviews
10.6 Root Cause Analysis
5 Whys: Ask "why" repeatedly to reach root cause
Fishbone Diagram: Categorize potential causes
Fault Tree Analysis: Top-down approach to identify failure modes
11. Complexity & Efficiency Awareness
11.1 Algorithm Efficiency
Measure of resources (time and space) used by an algorithm as input size grows
11.2 Asymptotic Notation
Big-O (O): Upper bound - worst case complexity
Omega (Omega): Lower bound - best case complexity
Theta (Theta): Tight bound - average case complexity
11.3 Common Time Complexities
Complexity Name Example
O(1) Constant Array access, hash lookup
O(log n) Logarithmic Binary search, balanced tree operations
O(n) Linear Linear search, single loop
O(n log n) Linearithmic Merge sort, quick sort (average)
O(n^2) Quadratic Bubble sort, nested loops
O(2^n) Exponential Recursive Fibonacci, subset generation
O(n!) Factorial Permutation generation, TSP brute force
11.4 Space Complexity
Amount of memory required by algorithm as function of input size
Examples: O(1) - in-place algorithms; O(n) - single array; O(n^2) - 2D matrix
11.5 Time-Space Tradeoff
Often can reduce time complexity by using more memory, or vice versa
Example: Hash table uses extra space for O(1) lookup vs O(log n) for binary search
11.6 Analyzing Complexity
Rules:
Drop constants: O(2n) = O(n)
Drop lower-order terms: O(n^2 + n) = O(n^2)
Consider worst case for Big-O
12. Problem Solving Using Programming
12.1 Programming as Problem Solving
Using programming languages to implement algorithmic solutions to problems
12.2 Problem Solving Steps in Programming
1. Understand: Read problem, identify inputs, outputs, constraints
2. Plan: Design algorithm using pseudocode or flowchart
3. Code: Translate algorithm into programming language
4. Test: Run with test cases, verify correctness
5. Debug: Find and fix errors if tests fail
6. Optimize: Improve efficiency if needed
12.3 Input/Output Handling
Input: Reading data from user, files, or other sources
Output: Displaying or storing results
Validation: Checking input validity before processing
12.4 Common Problem Patterns
Accumulator: Running sum, count, or product
Search: Finding element in collection
Filter: Selecting elements matching criteria
Transform: Converting data from one form to another
Aggregate: Computing statistics (min, max, avg)
12.5 Problem Decomposition in Programming
Break problem into functions/procedures
Each function has single responsibility
Functions can be tested independently
12.6 Testing Strategies
Unit Testing: Test individual functions
Integration Testing: Test combined components
Boundary Testing: Test edge cases (empty, single, max)
Error Path Testing: Test invalid inputs
13. Data-Driven Problem Solving
13.1 Definition
Using data analysis and evidence to inform problem understanding and solution selection
13.2 Data-Driven Process
1. Define: Clearly state the problem and questions
2. Collect: Gather relevant data from appropriate sources
3. Clean: Process data (remove errors, handle missing values)
4. Analyze: Apply statistical methods, identify patterns
5. Interpret: Draw conclusions from analysis
6. Act: Implement decisions based on insights
13.3 Data Collection Methods
Surveys: Structured questionnaires
Observations: Direct monitoring of behavior
Experiments: Controlled testing
Existing Data: Databases, logs, historical records
13.4 Data Analysis Techniques
Descriptive: Summarize data (mean, median, mode, standard deviation)
Diagnostic: Understand why something happened
Predictive: Forecast future outcomes
Prescriptive: Recommend actions
13.5 Data Visualization
Charts: Bar, line, pie, scatter plots
Tables: Structured data presentation
Graphs: Networks, relationships
Dashboards: Real-time data monitoring
13.6 Challenges in Data-Driven Approach
Data quality issues (incomplete, inaccurate, outdated)
Bias in data collection or analysis
Correlation vs causation confusion
Over-reliance on data without domain expertise
14. Creative & Innovative Thinking
14.1 Creativity in Problem Solving
Generating novel and useful ideas, solutions, or approaches to problems
14.2 Creative Thinking Techniques
Brainstorming: Generate many ideas without judgment
Mind Mapping: Visual exploration of ideas and connections
SCAMPER: Substitute, Combine, Adapt, Modify, Put to other uses, Eliminate, Reverse
Six Thinking Hats: Different perspectives (facts, emotions, caution, benefits, creativity, control)
Reverse Thinking: Consider opposite of the problem
Analogy: Apply solutions from other domains
14.3 Innovation Process
Ideation: Generate ideas
Selection: Choose promising ideas
Development: Refine and prototype
Implementation: Execute the solution
Evaluation: Assess impact and refine
14.4 Creative Problem Solving Models
Osborn-Parnes Model:
Objective Finding → Fact Finding → Problem Finding → Idea Finding → Solution Finding → Acceptance Finding
Design Thinking:
Empathize → Define → Ideate → Prototype → Test
14.5 Overcoming Creative Blocks
Mental Blocks: Fear of failure, perfectionism, rigid thinking
Solutions: Take breaks, seek diverse perspectives, embrace failure as learning
14.6 Lateral vs Vertical Thinking
Vertical (Logical): Sequential, analytical, follows established patterns
Lateral (Creative): Non-linear, generates alternatives, challenges assumptions
15. Real-World Problem Solving
15.1 Characteristics of Real-World Problems
Often ill-defined with unclear boundaries
Multiple stakeholders with conflicting interests
Constraints may change over time
No single correct answer; multiple valid solutions
15.2 Problem Contexts
Domain Examples Key Considerations
Business Process optimization, market analysis ROI, stakeholder interests
Engineering Design challenges, system failures Safety, reliability, cost
Social Public health, education Ethics, equity, accessibility
Environmental Sustainability, resource management Long-term impact, scalability
15.3 Systems Thinking
Viewing problems as interconnected systems rather than isolated parts
Components: Elements, interconnections, purpose/function
Feedback Loops: Reinforcing (amplify) and Balancing (stabilize)
15.4 Interdisciplinary Approaches
Combining knowledge and methods from multiple disciplines
Benefits: Broader perspective, innovative solutions
Challenges: Communication barriers, different methodologies
15.5 Ethical Considerations
Consider impact on all stakeholders
Evaluate short-term and long-term consequences
Ensure fairness, privacy, and transparency
15.6 Implementation Challenges
Resistance to change: Stakeholders may resist new solutions
Resource constraints: Limited time, budget, or expertise
Unintended consequences: Solutions may create new problems
16. Communication & Documentation of Solutions
16.1 Importance of Communication
Solutions must be effectively communicated to stakeholders for understanding and acceptance
Clear communication ensures correct implementation and maintenance
16.2 Documentation Types
Problem Documentation: Problem statement, context, constraints
Solution Documentation: Approach, methodology, implementation details
User Documentation: How to use the solution
Technical Documentation: Architecture, code, APIs
16.3 Documentation Best Practices
Clarity: Use simple, precise language
Completeness: Include all necessary information
Organization: Logical structure with headings and sections
Accuracy: Ensure information is correct and current
Maintainability: Easy to update as solution evolves
16.4 Presenting Solutions
Know Your Audience: Adjust technical level based on audience
Structure: Problem → Analysis → Solution → Benefits → Implementation
Visual Aids: Diagrams, charts, demos enhance understanding
Handle Questions: Be prepared to explain reasoning
16.5 Code Documentation
Comments: Explain why, not just what
Function Documentation: Purpose, parameters, return values
README Files: Project overview, setup, usage instructions
API Documentation: Endpoints, parameters, examples
16.6 Knowledge Transfer
Ensuring others can understand and maintain the solution
Methods: Training sessions, walkthroughs, documentation, mentoring
Importance: Ensures solution sustainability beyond original team
16.7 Version Control for Documentation
Track changes to documentation over time
Maintain revision history and changelogs
Enable collaboration and rollback capability