problem solving and algorithm designing notes

• school Campus Bookshelves
• menu_book Bookshelves
• perm_media Learning Objects
• login Login
• how_to_reg Request Instructor Account
• hub Instructor Commons
• Download Page (PDF)
• Download Full Book (PDF)
• Periodic Table
• Physics Constants
• Scientific Calculator
• Reference & Cite
• Tools expand_more
• Readability

selected template will load here

This action is not available.

1: Algorithmic Problem Solving

• Last updated
• Save as PDF
• Page ID 46789

• Harrison Njoroge
• African Virtual University

Unit Objectives

Upon completion of this unit the learner should be able to:

• describe an algorithm
• explain the relationship between data and algorithm
• outline the characteristics of algorithms
• apply pseudo codes and flowcharts to represent algorithms

Unit Introduction

This unit introduces learners to data structures and algorithm course. The unit is on the different data structures and their algorithms that can help implement the different data structures in the computer. The application of the different data structures is presented by using examples of algorithms and which are not confined to a particular computer programming language.

• Data: the structural representation of logical relationships between elements of data
• Algorithm: finite sequence of steps for accomplishing some computational task
• Pseudo code: an informal high-level description of the operating principle of a computer program or other algorithm
• Flow chart: diagrammatic representation illustrates a solution model to a given problem.

Learning Activities

• 1.1: Activity 1 - Introduction to Algorithms and Problem Solving In this learning activity section, the learner will be introduced to algorithms and how to write algorithms to solve tasks faced by learners or everyday problems. Examples of the algorithm are also provided with a specific application to everyday problems that the learner is familiar with. The learners will particularly learn what is an algorithm, the process of developing a solution for a given task, and finally examples of application of the algorithms are given.
• 1.2: Activity 2 - The characteristics of an algorithm This section introduces the learners to the characteristics of algorithms. These characteristics make the learner become aware of what to ensure is basic, present and mandatory for any algorithm to qualify to be one. It also exposes the learner to what to expect from an algorithm to achieve or indicate. Key expectations are: the fact that an algorithm must be exact, terminate, effective, general among others.
• 1.3: Activity 3 - Using pseudo-codes and flowcharts to represent algorithms The student will learn how to design an algorithm using either a pseudo code or flowchart. Pseudo code is a mixture of English like statements, some mathematical notations and selected keywords from a programming language. It is one of the tools used to design and develop the solution to a task or problem. Pseudo codes have different ways of representing the same thing and emphasis is on the clarity and not style.
• 1.4: Unit Summary In this unit, you have seen what an algorithm is. Based on this knowledge, you should now be able to characterize an algorithm by stating its properties. We have explored the different ways of representing an algorithm such as using human language, pseudo codes and flow chart. You should now be able to present solutions to problems in form of an algorithm.

Algorithms and Problem Solving ​

Algorithms and flowcharts (designing a program) ​.

Reference this presentation for your first homework.

Five Simple Ideas Used to Create All Programs ​

• A list of instructions performed in order
• If…, then…, else…
• Repeated behavior (i.e., while there are cookies on the plate, keep eating cookies)
• Breaking the problem into sub-problems that can be solved independently.
• A set of instructions that return a single result (answer a question).

Complexity ​

Most computers only really “understand” about 100 different instructions.

Powerful applications take advantage of the extreme number of possible instruction combinations.

Chess is a good analogy:

• 6 types of pieces; each piece moves in a simple pattern.
• Possible/playable chess games (assuming an avg. game has 30 moves) are 4,670,033.

Algorithms ​

An algorithm is A step-by-step list of instructions for solving a problem. The solution must be determined in a finite amount of time.

Algorithms can be expressed in many kinds of notations (e.g., natural language, pseudocode, flowcharts, etc.)

Flowcharts ​

A flowchart is one way to represent an algorithm and uses the following symbols.

Creating Solutions ​

• Step-by-step problem-solving process
• In a finite amount of time
• Programming is a process of problem-solving.

Programming with the Problem Analysis–Coding–Execution Cycle ​

Analyze the problem

• Does the program require user interaction?
• Does the program manipulate data?
• What is the output?
• Analyze and design algorithms for each subproblem
• Can test using sample data
• Some mathematical analysis might be required

Implement the algorithm

• Enter the program using a text editor. This is called the implementation of the algorithm.
• Compile code
• Look at the code and remove errors
• Run code again through the compiler
• The compiler guarantees that the program follows the rules of the language. It does not guarantee that the program will run correctly.
• Linker links machine code with system resources

Execution (run the compiles program)

• Once compiled and linked, the loader can place the program into the main memory for execution.
• The final step is to execute the program.

Maintenance

• Use and modify the program if the problem domain changes.

Programming Methods ​

Two popular approaches to programming design

• Structured (e.g., Procedural)
• Object-oriented

There are many other programming paradigms .

Structured Programming ​

Procedural design is a subset of structured design:

• Dividing a problem into smaller subproblems
• A solution to a subproblem is a “module” or “procedure” and is simply a series of computation steps to be carried out.
• Top-down (or bottom-up) design
• Stepwise refinement
• Modular programming

Object-Oriented Programming ​

Object-oriented design :

• Identify components called objects.
• Determine how objects interact with each other
• Specify relevant data and possible operations to be performed on that data.
• Each object consists of data and operations on that data.
• An object combines data and operations on the data into a single unit
• A language that supports object-oriented design is called an object-oriented programming (OOP) language
• Must learn how to represent data in computer memory, how to manipulate data, and how to implement operations.
• C++ was designed to support object-oriented programming.
• Object-oriented design is used with structured design.

Notes-for-CAIE

2.1 algorithm design and problem-sovling, 2.1.1 algorithms.

show understanding that an algorithm is a solution to a problem expressed as a sequence of defined steps use suitable identifier names for the representation of data used by a problem summarise identifier names using an identifier table show understanding that many algorithms are expressed using the four basic constructs of assignment, sequence, selection and repetition show understanding that simple algorithms consist of input, process, output at various stages document a simple algorithm using: structured English pseudocode (on the examination paper, any given pseudocode will be presented using the Courier New font) program flowchart derive pseudocode or a program flowchart from a structured English description of a problem derive pseudocode from a given program flowchart or vice versa use the process of stepwise refinement to express an algorithm to a level of detail from which the task may be programmed decompose a problem into sub-tasks leading to the concept of a program module (procedure/function) show an appreciation of why logic statements are used to define parts of an algorithm solution use logic statements to define parts of an algorithm solution

Step-wise refinement

s19 23 Q2 [3]

• The breaking down of an algorithm
• to a level of sub-tasks
• from which it can be programmed

2.1.2 Structure chart

use a structure chart to express the parameters passed between the various modules/procedures/functions which are part of the algorithm design describe the purpose of a structure chart construct a structure chart for a given problem derive equivalent pseudocode from a structure chart

Features [4]

• Module hierarchy
• The parameters that are passed
• The sequence of module execution
• Selection and Iteration

2.1.3 Corrective maintenance

perform white-box testing by: selecting suitable data using a trace table identify any error(s) in the algorithm by using the completed trace table amend the algorithm if required

White-box testing

s19 23 Q5 [1] To test every path through the code

2.1.4 Adaptive maintenance

make amendments to an algorithm and data structure in response to specification changes analyse an existing program and make amendments to enhance functionality

Adaptive maintenance : Updating a program as a result of changes to requirements

Algorithms, design and problem-solving

Designing and understanding algorithms.

• Program development life cycle
• Decomposition and sub-systems
• Methods of designing a solution
• Explain the purpose of an algorithm

Common algorithms

• Standard solutions

Validation and verification

• Data validation
• Data verification

Testing and fixing programs

• Suggest and apply suitable test data
• Using trace tables
• Identify errors in algorithms and suggest corrections

Notes mentioning this note

There are no notes linking to this note.

Here are all the topics on this website, along with their links, visualized as a graph.

On a mission to end educational inequality for young people everywhere.

ZNotes Education Limited is incorporated and registered in England and Wales, under Registration number: 12520980 whose Registered office is at: Docklands Lodge Business Centre, 244 Poplar High Street, London, E14 0BB. “ZNotes” and the ZNotes logo are trademarks of ZNotes Education Limited (registration UK00003478331).

THE PATH TO SUCCESS IN EXAM...

Introduction to Problem Solving – Notes

Introduction to problem solving.

• Steps for problem solving ( analysing the problem, developing an algorithm, coding, testing and debugging).
• flow chart and
• pseudo code,

Decomposition

Introduction

Computers is machine that not only use to develop the software. It is also used for solving various day-to-day problems.

Computers cannot solve a problem by themselves. It solve the problem on basic of the step-by-step instructions given by us.

Thus, the success of a computer in solving a problem depends on how correctly and precisely we –

• Identifying (define) the problem
• Designing & developing an algorithm and
• Implementing the algorithm (solution) do develop a program using any programming language.

Thus problem solving is an essential skill that a computer science student should know.

Steps for Problem Solving-

1. Analysing the problem

Analysing the problems means understand a problem clearly before we begin to find the solution for it. Analysing a problem helps to figure out what are the inputs that our program should accept and the outputs that it should produce.

2. Developing an Algorithm

It is essential to device a solution before writing a program code for a given problem. The solution is represented in natural language and is called an algorithm.

Algorithm: A set of exact steps which when followed, solve the problem or accomplish the required task.

Coding is the process of converting the algorithm into the program which can be understood by the computer to generate the desired solution.

You can use any high level programming languages for writing a program.

4. Testing and Debugging

The program created should be tested on various parameters.

• The program should meet the requirements of the user.
• It must respond within the expected time.
• It should generate correct output for all possible inputs.
• In the presence of syntactical errors, no output will be obtained.
• In case the output generated is incorrect, then the program should be checked for logical errors, if any.

Software Testing methods are

• unit or component testing,
• integration testing,
• system testing, and
• acceptance testing

Debugging – The errors or defects found in the testing phases are debugged or rectified and the program is again tested. This continues till all the errors are removed from the program.

Algorithm is a set of sequence which followed to solve a problem.

Algorithm for an activity ‘riding a bicycle’: 1) remove the bicycle from the stand, 2) sit on the seat of the bicycle, 3) start peddling, 4) use breaks whenever needed and 5) stop on reaching the destination.

Algorithm for Computing GCD of two numbers:

Step 1: Find the numbers (divisors) which can divide the given numbers.

Step 2: Then find the largest common number from these two lists.

A finite sequence of steps required to get the desired output is called an algorithm. Algorithm has a definite beginning and a definite end, and consists of a finite number of steps.

Characteristics of a good algorithm

• Precision — the steps are precisely stated or defined.
• Uniqueness — results of each step are uniquely defined and only depend on the input and the result of the preceding steps.
• Finiteness — the algorithm always stops after a finite number of steps.
• Input — the algorithm receives some input.
• Output — the algorithm produces some output.

While writing an algorithm, it is required to clearly identify the following:

• The input to be taken from the user.
• Processing or computation to be performed to get the desired result.
• The output desired by the user.

Representation of Algorithms

There are two common methods of representing an algorithm —

Flowchart — Visual Representation of Algorithms

A flowchart is a visual representation of an algorithm. A flowchart is a diagram made up of boxes, diamonds and other shapes, connected by arrows. Each shape represents a step of the solution process and the arrow represents the order or link among the steps. There are standardised symbols to draw flowcharts.

Start/End – Also called “Terminator” symbol. It indicates where the flow starts and ends.

Process – Also called “Action Symbol,” it represents a process, action, or a single step. Decision – A decision or branching point, usually a yes/no or true/ false question is asked, and based on the answer, the path gets split into two branches.

Input / Output – Also called data symbol, this parallelogram shape is used to input or output data.

Arrow – Connector to show order of flow between shapes.

Question: Write an algorithm to find the square of a number. Algorithm to find square of a number. Step 1: Input a number and store it to num Step 2: Compute num * num and store it in square Step 3: Print square

The algorithm to find square of a number can be represented pictorially using flowchart

A pseudocode (pronounced Soo-doh-kohd) is another way of representing an algorithm. It is considered as a non-formal language that helps programmers to write algorithm. It is a detailed description of instructions that a computer must follow in a particular order.

• It is intended for human reading and cannot be executed directly by the computer.
• No specific standard for writing a pseudocode exists.
• The word “pseudo” means “not real,” so “pseudocode” means “not real code”.

Keywords are used in pseudocode:

Question : Write an algorithm to calculate area and perimeter of a rectangle, using both pseudocode and flowchart.

Pseudocode for calculating area and perimeter of a rectangle.

INPUT length INPUT breadth COMPUTE Area = length * breadth PRINT Area COMPUTE Perim = 2 * (length + breadth) PRINT Perim The flowchart for this algorithm

Benefits of Pseudocode

• A pseudocode of a program helps in representing the basic functionality of the intended program.
• By writing the code first in a human readable language, the programmer safeguards against leaving out any important step.
• For non-programmers, actual programs are difficult to read and understand, but pseudocode helps them to review the steps to confirm that the proposed implementation is going to achieve the desire output.

Flow of Control :

The flow of control depicts the flow of process as represented in the flow chart. The process can flow in

In a sequence steps of algorithms (i.e. statements) are executed one after the other.

In a selection, steps of algorithm is depend upon the conditions i.e. any one of the alternatives statement is selected based on the outcome of a condition.

Conditionals are used to check possibilities. The program checks one or more conditions and perform operations (sequence of actions) depending on true or false value of the condition.

Conditionals are written in the algorithm as follows: If is true then steps to be taken when the condition is true/fulfilled otherwise steps to be taken when the condition is false/not fulfilled

Question : Write an algorithm to check whether a number is odd or even. • Input: Any number • Process: Check whether the number is even or not • Output: Message “Even” or “Odd” Pseudocode of the algorithm can be written as follows: PRINT “Enter the Number” INPUT number IF number MOD 2 == 0 THEN PRINT “Number is Even” ELSE PRINT “Number is Odd”

The flowchart representation of the algorithm

Repetitions are used, when we want to do something repeatedly, for a given number of times.

Question : Write pseudocode and draw flowchart to accept numbers till the user enters 0 and then find their average. Pseudocode is as follows:

Step 1: Set count = 0, sum = 0 Step 2: Input num Step 3: While num is not equal to 0, repeat Steps 4 to 6 Step 4: sum = sum + num Step 5: count = count + 1 Step 6: Input num Step 7: Compute average = sum/count Step 8: Print average The flowchart representation is

Once an algorithm is finalised, it should be coded in a high-level programming language as selected by the programmer. The ordered set of instructions are written in that programming language by following its syntax.

The syntax is the set of rules or grammar that governs the formulation of the statements in the language, such as spelling, order of words, punctuation, etc.

Source Code: A program written in a high-level language is called source code.

We need to translate the source code into machine language using a compiler or an interpreter so that it can be understood by the computer.

Decomposition is a process to ‘decompose’ or break down a complex problem into smaller subproblems. It is helpful when we have to solve any big or complex problem.

• Breaking down a complex problem into sub problems also means that each subproblem can be examined in detail.
• Each subproblem can be solved independently and by different persons (or teams).
• Having different teams working on different sub-problems can also be advantageous because specific sub-problems can be assigned to teams who are experts in solving such problems.

Once the individual sub-problems are solved, it is necessary to test them for their correctness and integrate them to get the complete solution.

• Input Output in Python

Related Posts

Society, Law, and Ethics: Societal Impacts – Notes

Data structure: stacks – notes.

Python Revision Tour I : Basics of Python – Notes

Introduction to Python Module – Notes

Sorting Techniques in Python – Notes

Dictionary handling in python – notes, tuples manipulation in python notes, list manipulation – notes, leave a comment cancel reply.

You must be logged in to post a comment.

You cannot copy content of this page

Teach Computer Science

Problem Solving and Algorithm Design GCSE Resources

Gcse computer science: problem solving and algorithm design.

Do you want to save hours of lesson preparation time? Get your evenings and weekends back and focus your time where it's needed! Be fully prepared with presentations, notes, activities, and more.

All Computer Science topics are covered, and each module comes complete with:

• Classroom Presentations
• Revision Notes
• Activities & Quizzes
• Mind Maps, Flashcards & Glossaries

Download free samples

Frequently Asked Questions

What is problem solving in the context of computer science.

Problem solving in computer science refers to the process of identifying, understanding, and resolving issues or challenges related to programming or computational systems. It involves critical thinking, logical reasoning, and the application of various techniques, such as abstraction and decomposition, to create effective solutions that can be executed by computers.

What is abstraction and why is it important?

Abstraction is the process of simplifying complex problems by focusing on the most critical aspects while ignoring irrelevant details. It is important because it helps programmers conceptualize and understand problems more easily, enabling them to create efficient and effective solutions. Abstraction also allows for the creation of reusable and modular components in software, enhancing maintainability and scalability.

What is decomposition and how does it help in problem solving?

Decomposition is a technique that involves breaking down a large, complex problem into smaller, more manageable components. It helps in problem solving by making complex problems easier to understand and tackle. Additionally, decomposition promotes collaboration and teamwork, as individual components can be assigned to different team members, allowing them to work on different aspects of the problem simultaneously.

What is algorithm design and what are some common algorithmic techniques?

Algorithm design is the process of creating step-by-step procedures to solve specific problems. Some common algorithmic techniques include sequential, conditional, and iterative constructs. Sequential constructs involve executing a series of steps in a specific order, while conditional constructs involve making decisions based on certain conditions. Iterative constructs involve executing a set of instructions repeatedly until a specific condition is met.

What is Big O notation and why is it important for analyzing algorithms?

Big O notation is a mathematical notation used to describe the performance of algorithms in terms of their time complexity or the number of operations they require as a function of the input size. It is important for analyzing algorithms because it helps programmers understand how an algorithm's performance scales with the size of the input, allowing them to choose the most efficient and optimized solution for a given problem.

• Engineering & Technology
• Computer Science
• Data Structures

CSEC IT - A Guide to Problem Solving and Program Design

Related documents

Add this document to collection(s)

You can add this document to your study collection(s)

Add this document to saved

You can add this document to your saved list

Suggest us how to improve StudyLib

(For complaints, use another form )

Input it if you want to receive answer