algorithm and flowchart for problem solving with sequential logic structure

Computersciencementor | Hardware, Software, Networking and programming

Algorithm and flowchart explained with examples, what is algorithm and flowchart.

Algorithm and flowchart are programming tools. A Programmer uses various programming languages to create programs. But before actually writing a program in a programming language, a programmer first needs to find a procedure for solving the problem which is known as planning the program. The program written without proper pre-planning have higher chances of errors. The tools that are used to plan or design the problem are known as programming tools. Algorithm and flowchart are widely used programming tools.

The word “algorithm” relates to the name of the mathematician Al- khowarizmi , which means a procedure or a technique. Programmer commonly uses an algorithm for planning and solving the problems.

An algorithm is a specific set of meaningful instructions written in a specific order for carrying out or solving a specific problem.

Types of Algorithm:

The algorithm and flowchart are classified into three types of control structures.

• Branching(Selection)
• Loop(Repetition)

According to the condition and requirement, these three control structures can be used.

In the  sequence structure, statements are placed one after the other and the execution takes place starting from up to down.

Whereas in branch control, there is a condition and according to a condition, a decision of either TRUE or FALSE is achieved. In the case of TRUE, one of the two branches is explored; but in the case of FALSE condition, the other alternative is taken. Generally, the ‘IF-THEN’ is used to represent branch control.

Write an algorithm to find the smallest number between two numbers

Write an algorithm to check odd or even number.

The Loop or Repetition allows a statements or block of statements to be executed repeatedly based on certain loop condition. ‘While’ and ‘for’ construct are used to represent the loop structure in most programming languages. Loops are of two types: Bounded and Unbounded loop. In bounded loop, the number of iterations is fixed while in unbounded loops the condition has to satisfy to end the loop.

An algorithm to calculate even numbers between 20 and 40

Write an algorithm to input a natural number, n, and calculate the odd numbers equal or less than n.

Characteristics of a good algorithm.

• The Finite number of steps:

After starting an algorithm for any problem, it has to terminate at some point.

• Easy Modification.

There can be numbers of steps in an algorithm depending on the type of problem. It supports easy modification of Steps.

• Easy and simple to understand

A Simple English language is used while writing an algorithm. It is not dependent on any particular programming language. People without the knowledge of programming can read and understand the steps in the algorithm.

An algorithm is just a design of a program. Every program needs to display certain output after processing the input data. So one always expects the result as an output from an algorithm. It can give output at different stages. The result obtained at the end of an algorithm is known as an end result and if the result is obtained at an intermediate stage of process or operation then the result is known as an intermediate result. Also, the output has to be as expected having some relation to the inputs.

The first design of flowchart goes back to 1945 which was designed by John Von Neumann . Unlike an algorithm, Flowchart uses different symbols to design a solution to a problem. It is another commonly used programming tool.

In general, a flowchart is a diagram that uses different symbols to visually present the flow of data. By looking at a flow chart one can understand the operations and sequence of operations performed in a system. This is why flowchart is often considered as a blueprint of a design used for solving a specific problem.

A flowchart is defined as a symbolic or a graphical representation of an algorithm that uses different standard symbols.

Flowchart Symbols:

Guidelines for drawing a flowchart.

• The Title for every flowchart is compulsory.
• There must be START and END point for every flowchart.
• The symbols used in flowchart should have only one entry point on the top. The exit point for symbols (except for decision/diamond symbol) is on the button.
• There should be two exit points for decision symbol; exit points can be on the bottom and one side or on the sides.
• The flow of flowchart is generally from top to bottom. But in some cases, it can also flow to upward direction
• The direction of the flow of control should be indicated by arrowheads.
• The operations for every step should be written inside the symbol.
• The language used in flowchart should be simple so that it can be easily understood.
• The flowlines that show the direction of flow of flowchart must not cross each other.
• While connecting different pages of the same flowchart, Connectors must be used.

Some examples of algorithm and flowchart.

Example1: To calculate the area of a circle

Step1: Start

Step2: Input radius of the circle say r

Step3: Use the formula πr 2 and store result in a variable AREA

Step4: Print AREA

Step5: Stop Flowchart:

Related Posts

Sampurna shrestha

Save my name, email, and website in this browser for the next time I comment.

• 1. Micro-Worlds
• 2. Light-Bot in Java
• 3. Jeroos of Santong Island
• 4. Problem Solving and Algorithms
• 5. Creating Jeroo Methods
• 6. Conditionally Executing Actions
• 7. Repeating Actions
• 8. Handling Touch Events
• 9. Adding Text to the Screen

Problem Solving and Algorithms

Learn a basic process for developing a solution to a problem. Nothing in this chapter is unique to using a computer to solve a problem. This process can be used to solve a wide variety of problems, including ones that have nothing to do with computers.

Problems, Solutions, and Tools

I have a problem! I need to thank Aunt Kay for the birthday present she sent me. I could send a thank you note through the mail. I could call her on the telephone. I could send her an email message. I could drive to her house and thank her in person. In fact, there are many ways I could thank her, but that's not the point. The point is that I must decide how I want to solve the problem, and use the appropriate tool to implement (carry out) my plan. The postal service, the telephone, the internet, and my automobile are tools that I can use, but none of these actually solves my problem. In a similar way, a computer does not solve problems, it's just a tool that I can use to implement my plan for solving the problem.

Knowing that Aunt Kay appreciates creative and unusual things, I have decided to hire a singing messenger to deliver my thanks. In this context, the messenger is a tool, but one that needs instructions from me. I have to tell the messenger where Aunt Kay lives, what time I would like the message to be delivered, and what lyrics I want sung. A computer program is similar to my instructions to the messenger.

The story of Aunt Kay uses a familiar context to set the stage for a useful point of view concerning computers and computer programs. The following list summarizes the key aspects of this point of view.

A computer is a tool that can be used to implement a plan for solving a problem.

A computer program is a set of instructions for a computer. These instructions describe the steps that the computer must follow to implement a plan.

An algorithm is a plan for solving a problem.

A person must design an algorithm.

A person must translate an algorithm into a computer program.

This point of view sets the stage for a process that we will use to develop solutions to Jeroo problems. The basic process is important because it can be used to solve a wide variety of problems, including ones where the solution will be written in some other programming language.

An Algorithm Development Process

Every problem solution starts with a plan. That plan is called an algorithm.

There are many ways to write an algorithm. Some are very informal, some are quite formal and mathematical in nature, and some are quite graphical. The instructions for connecting a DVD player to a television are an algorithm. A mathematical formula such as πR 2 is a special case of an algorithm. The form is not particularly important as long as it provides a good way to describe and check the logic of the plan.

The development of an algorithm (a plan) is a key step in solving a problem. Once we have an algorithm, we can translate it into a computer program in some programming language. Our algorithm development process consists of five major steps.

Step 1: Obtain a description of the problem.

Step 2: analyze the problem., step 3: develop a high-level algorithm., step 4: refine the algorithm by adding more detail., step 5: review the algorithm..

This step is much more difficult than it appears. In the following discussion, the word client refers to someone who wants to find a solution to a problem, and the word developer refers to someone who finds a way to solve the problem. The developer must create an algorithm that will solve the client's problem.

The client is responsible for creating a description of the problem, but this is often the weakest part of the process. It's quite common for a problem description to suffer from one or more of the following types of defects: (1) the description relies on unstated assumptions, (2) the description is ambiguous, (3) the description is incomplete, or (4) the description has internal contradictions. These defects are seldom due to carelessness by the client. Instead, they are due to the fact that natural languages (English, French, Korean, etc.) are rather imprecise. Part of the developer's responsibility is to identify defects in the description of a problem, and to work with the client to remedy those defects.

The purpose of this step is to determine both the starting and ending points for solving the problem. This process is analogous to a mathematician determining what is given and what must be proven. A good problem description makes it easier to perform this step.

When determining the starting point, we should start by seeking answers to the following questions:

What data are available?

Where is that data?

What formulas pertain to the problem?

What rules exist for working with the data?

What relationships exist among the data values?

When determining the ending point, we need to describe the characteristics of a solution. In other words, how will we know when we're done? Asking the following questions often helps to determine the ending point.

What new facts will we have?

What items will have changed?

What changes will have been made to those items?

What things will no longer exist?

An algorithm is a plan for solving a problem, but plans come in several levels of detail. It's usually better to start with a high-level algorithm that includes the major part of a solution, but leaves the details until later. We can use an everyday example to demonstrate a high-level algorithm.

Problem: I need a send a birthday card to my brother, Mark.

Analysis: I don't have a card. I prefer to buy a card rather than make one myself.

High-level algorithm:

Go to a store that sells greeting cards Select a card Purchase a card Mail the card

This algorithm is satisfactory for daily use, but it lacks details that would have to be added were a computer to carry out the solution. These details include answers to questions such as the following.

"Which store will I visit?"

"How will I get there: walk, drive, ride my bicycle, take the bus?"

"What kind of card does Mark like: humorous, sentimental, risqué?"

These kinds of details are considered in the next step of our process.

A high-level algorithm shows the major steps that need to be followed to solve a problem. Now we need to add details to these steps, but how much detail should we add? Unfortunately, the answer to this question depends on the situation. We have to consider who (or what) is going to implement the algorithm and how much that person (or thing) already knows how to do. If someone is going to purchase Mark's birthday card on my behalf, my instructions have to be adapted to whether or not that person is familiar with the stores in the community and how well the purchaser known my brother's taste in greeting cards.

When our goal is to develop algorithms that will lead to computer programs, we need to consider the capabilities of the computer and provide enough detail so that someone else could use our algorithm to write a computer program that follows the steps in our algorithm. As with the birthday card problem, we need to adjust the level of detail to match the ability of the programmer. When in doubt, or when you are learning, it is better to have too much detail than to have too little.

Most of our examples will move from a high-level to a detailed algorithm in a single step, but this is not always reasonable. For larger, more complex problems, it is common to go through this process several times, developing intermediate level algorithms as we go. Each time, we add more detail to the previous algorithm, stopping when we see no benefit to further refinement. This technique of gradually working from a high-level to a detailed algorithm is often called stepwise refinement .

The final step is to review the algorithm. What are we looking for? First, we need to work through the algorithm step by step to determine whether or not it will solve the original problem. Once we are satisfied that the algorithm does provide a solution to the problem, we start to look for other things. The following questions are typical of ones that should be asked whenever we review an algorithm. Asking these questions and seeking their answers is a good way to develop skills that can be applied to the next problem.

Does this algorithm solve a very specific problem or does it solve a more general problem ? If it solves a very specific problem, should it be generalized?

For example, an algorithm that computes the area of a circle having radius 5.2 meters (formula π*5.2 2 ) solves a very specific problem, but an algorithm that computes the area of any circle (formula π*R 2 ) solves a more general problem.

Can this algorithm be simplified ?

One formula for computing the perimeter of a rectangle is:

length + width + length + width

A simpler formula would be:

2.0 * ( length + width )

Is this solution similar to the solution to another problem? How are they alike? How are they different?

For example, consider the following two formulae:

Rectangle area = length * width Triangle area = 0.5 * base * height

Similarities: Each computes an area. Each multiplies two measurements.

Differences: Different measurements are used. The triangle formula contains 0.5.

Hypothesis: Perhaps every area formula involves multiplying two measurements.

Example 4.1: Pick and Plant

This section contains an extended example that demonstrates the algorithm development process. To complete the algorithm, we need to know that every Jeroo can hop forward, turn left and right, pick a flower from its current location, and plant a flower at its current location.

Problem Statement (Step 1)

A Jeroo starts at (0, 0) facing East with no flowers in its pouch. There is a flower at location (3, 0). Write a program that directs the Jeroo to pick the flower and plant it at location (3, 2). After planting the flower, the Jeroo should hop one space East and stop. There are no other nets, flowers, or Jeroos on the island.

Analysis of the Problem (Step 2)

The flower is exactly three spaces ahead of the jeroo.

The flower is to be planted exactly two spaces South of its current location.

The Jeroo is to finish facing East one space East of the planted flower.

There are no nets to worry about.

High-level Algorithm (Step 3)

Let's name the Jeroo Bobby. Bobby should do the following:

Get the flower Put the flower Hop East

Detailed Algorithm (Step 4)

Get the flower Hop 3 times Pick the flower Put the flower Turn right Hop 2 times Plant a flower Hop East Turn left Hop once

Review the Algorithm (Step 5)

The high-level algorithm partitioned the problem into three rather easy subproblems. This seems like a good technique.

This algorithm solves a very specific problem because the Jeroo and the flower are in very specific locations.

This algorithm is actually a solution to a slightly more general problem in which the Jeroo starts anywhere, and the flower is 3 spaces directly ahead of the Jeroo.

Java Code for "Pick and Plant"

A good programmer doesn't write a program all at once. Instead, the programmer will write and test the program in a series of builds. Each build adds to the previous one. The high-level algorithm will guide us in this process.

FIRST BUILD

To see this solution in action, create a new Greenfoot4Sofia scenario and use the Edit Palettes Jeroo menu command to make the Jeroo classes visible. Right-click on the Island class and create a new subclass with the name of your choice. This subclass will hold your new code.

The recommended first build contains three things:

The main method (here myProgram() in your island subclass).

Declaration and instantiation of every Jeroo that will be used.

The high-level algorithm in the form of comments.

The instantiation at the beginning of myProgram() places bobby at (0, 0), facing East, with no flowers.

Once the first build is working correctly, we can proceed to the others. In this case, each build will correspond to one step in the high-level algorithm. It may seem like a lot of work to use four builds for such a simple program, but doing so helps establish habits that will become invaluable as the programs become more complex.

SECOND BUILD

This build adds the logic to "get the flower", which in the detailed algorithm (step 4 above) consists of hopping 3 times and then picking the flower. The new code is indicated by comments that wouldn't appear in the original (they are just here to call attention to the additions). The blank lines help show the organization of the logic.

By taking a moment to run the work so far, you can confirm whether or not this step in the planned algorithm works as expected.

THIRD BUILD

This build adds the logic to "put the flower". New code is indicated by the comments that are provided here to mark the additions.

FOURTH BUILD (final)

Example 4.2: replace net with flower.

This section contains a second example that demonstrates the algorithm development process.

There are two Jeroos. One Jeroo starts at (0, 0) facing North with one flower in its pouch. The second starts at (0, 2) facing East with one flower in its pouch. There is a net at location (3, 2). Write a program that directs the first Jeroo to give its flower to the second one. After receiving the flower, the second Jeroo must disable the net, and plant a flower in its place. After planting the flower, the Jeroo must turn and face South. There are no other nets, flowers, or Jeroos on the island.

Jeroo_2 is exactly two spaces behind Jeroo_1.

The only net is exactly three spaces ahead of Jeroo_2.

Each Jeroo has exactly one flower.

Jeroo_2 will have two flowers after receiving one from Jeroo_1. One flower must be used to disable the net. The other flower must be planted at the location of the net, i.e. (3, 2).

Jeroo_1 will finish at (0, 1) facing South.

Jeroo_2 is to finish at (3, 2) facing South.

Each Jeroo will finish with 0 flowers in its pouch. One flower was used to disable the net, and the other was planted.

Let's name the first Jeroo Ann and the second one Andy.

Ann should do the following: Find Andy (but don't collide with him) Give a flower to Andy (he will be straight ahead) After receiving the flower, Andy should do the following: Find the net (but don't hop onto it) Disable the net Plant a flower at the location of the net Face South

Ann should do the following: Find Andy Turn around (either left or right twice) Hop (to location (0, 1)) Give a flower to Andy Give ahead Now Andy should do the following: Find the net Hop twice (to location (2, 2)) Disable the net Toss Plant a flower at the location of the net Hop (to location (3, 2)) Plant a flower Face South Turn right

The high-level algorithm helps manage the details.

This algorithm solves a very specific problem, but the specific locations are not important. The only thing that is important is the starting location of the Jeroos relative to one another and the location of the net relative to the second Jeroo's location and direction.

Java Code for "Replace Net with Flower"

As before, the code should be written incrementally as a series of builds. Four builds will be suitable for this problem. As usual, the first build will contain the main method, the declaration and instantiation of the Jeroo objects, and the high-level algorithm in the form of comments. The second build will have Ann give her flower to Andy. The third build will have Andy locate and disable the net. In the final build, Andy will place the flower and turn East.

This build creates the main method, instantiates the Jeroos, and outlines the high-level algorithm. In this example, the main method would be myProgram() contained within a subclass of Island .

This build adds the logic for Ann to locate Andy and give him a flower.

This build adds the logic for Andy to locate and disable the net.

This build adds the logic for Andy to place a flower at (3, 2) and turn South.

• Demo Videos
• Interactive Product Tours
• Request Demo

Flowchart Tutorial (with Symbols, Guide and Examples)

A flowchart is simply a graphical representation of steps. It shows steps in sequential order and is widely used in presenting the flow of algorithms, workflow or processes. Typically, a flowchart shows the steps as boxes of various kinds, and their order by connecting them with arrows.

What is a Flowchart?

A flowchart is a graphical representations of steps. It was originated from computer science as a tool for representing algorithms and programming logic but had extended to use in all other kinds of processes. Nowadays, flowcharts play an extremely important role in displaying information and assisting reasoning. They help us visualize complex processes, or make explicit the structure of problems and tasks. A flowchart can also be used to define a process or project to be implemented.

Flowchart Symbols

Different flowchart shapes have different conventional meanings. The meanings of some of the more common shapes are as follows:

The terminator symbol represents the starting or ending point of the system.

A box indicates some particular operation.

This represents a printout, such as a document or a report.

A diamond represents a decision or branching point. Lines coming out from the diamond indicates different possible situations, leading to different sub-processes.

It represents information entering or leaving the system. An input might be an order from a customer. Output can be a product to be delivered.

On-Page Reference

This symbol would contain a letter inside. It indicates that the flow continues on a matching symbol containing the same letter somewhere else on the same page.

Off-Page Reference

This symbol would contain a letter inside. It indicates that the flow continues on a matching symbol containing the same letter somewhere else on a different page.

Delay or Bottleneck

Identifies a delay or a bottleneck.

Lines represent the flow of the sequence and direction of a process.

When to Draw Flowchart?

Using a flowchart has a variety of benefits:

• It helps to clarify complex processes.
• It identifies steps that do not add value to the internal or external customer, including delays; needless storage and transportation; unnecessary work, duplication, and added expense; breakdowns in communication.
• It helps team members gain a shared understanding of the process and use this knowledge to collect data, identify problems, focus discussions, and identify resources.
• It serves as a basis for designing new processes.

Flowchart examples

Here are several flowchart examples. See how you can apply a flowchart practically.

Flowchart Example – Medical Service

This is a hospital flowchart example that shows how clinical cases shall be processed. This flowchart uses decision shapes intensively in representing alternative flows.

Flowchart Example – Simple Algorithms

A flowchart can also be used in visualizing algorithms, regardless of its complexity. Here is an example that shows how flowchart can be used in showing a simple summation process.

Flowchart Example – Calculate Profit and Loss

The flowchart example below shows how profit and loss can be calculated.

Creating a Flowchart in Visual Paradigm

Let’s see how to draw a flowchart in Visual Paradigm. We will use a very simple flowchart example here. You may expand the example when finished this tutorial.

• Select Diagram > New from the main menu.

• Enter the name of the flowchart and click OK .

• Enter Add items to Cart as the name of the process.

Turn every software project into a successful one.

We use cookies to offer you a better experience. By visiting our website, you agree to the use of cookies as described in our Cookie Policy .

© 2024 by Visual Paradigm. All rights reserved.

• Privacy statement

Popular Tutorials

Popular examples, learn python interactively, related articles.

• self in Python, Demystified
• Increment ++ and Decrement -- Operator as Prefix and Postfix
• Interpreter Vs Compiler : Differences Between Interpreter and Compiler
• Algorithm in Programming

Flowchart In Programming

A flowchart is a diagrammatic representation of an algorithm. A flowchart can be helpful for both writing programs and explaining the program to others.

Symbols Used In Flowchart

Examples of flowcharts in programming.

1. Add two numbers entered by the user.

2. Find the largest among three different numbers entered by the user.

3. Find all the roots of a quadratic equation ax 2 +bx+c=0

4. Find the Fibonacci series till term≤1000.

Note: Though flowcharts can be useful for writing and analyzing a program, drawing a flowchart for complex programs can be more complicated than writing the program itself. Hence, creating flowcharts for complex programs is often ignored.

Sorry about that.

UNIT 4: Control Structures: Making Decisions and Looping in computing. Data and Information Processing in Python.

Learning objectives.

• Read and write programs using the Python IF and IF/ELIF/ELSE statements to implement a simple decision structures.
• Write simple exception handling code to catch simple Python run-time errors.
• Read and write programs using the Python FOR and WHILE statements to implement a simple loop structures.
• Construct and implement algorithms that use decision and loop structures.
• Apply basic file processing concepts and techniques for reading and writing text files in Python.

Boolean Expressions

• Logical Operators
• Conditional Execution

Arithmetic expressions evaluate to numeric values; a Boolean expression may have only one of two possible values: false or true . While on the surface Boolean expressions may appear very limited compared to numeric expressions, they are essential for building more interesting and useful programs.

The simplest Boolean expressions in Python are True and False . In the Python interactive shell we see:

We see that bool is the name of the class representing Python’s Boolean expressions. The following code (booleanVars.py) is a simple program that shows how Boolean variables can be used.

# Assign some Boolean variables a = True b = False print('a =', a, ' b =', b) # Reassign a a = False print('a =', a, ' b =', b)

The results of running this program are shown below:

A Boolean variable is also a Boolean expression as we saw in Unit 2. An expression comparing numeric expressions for equality or inequality is also a Boolean expression. The simplest kinds of Boolean expressions use relational operators (or comparison operators) to compare two expressions. Table 6 lists the relational operators available in Python.

Table 6: Python Relationa/Comparisonl Operators

In the Python interactive shell we see some examples of Boolean expressions:

An expression like 10 < 20 is legal but of little use, since 10 < 20 is always true; the expression True is equivalent, simpler, and less likely to confuse human readers. Since variables can change their values during a program’s execution (and often do!), Boolean expressions are most useful when their truth values depend on the values of one or more variables.

The relational/comparison operators are binary operators and are all left associative. They all have a lower precedence than any of the arithmetic operators; therefore, Python evaluates the expression

x + 2 < y / 10

as if parentheses were placed as so:

(x + 2) < (y / 10)

Logical operators

There are three logical operators: and , or , and not . The semantics (meaning) of these operators is similar to their meaning in English. For example, x > 0 and x < 10 is true only if x is greater than 0 and less than 10.

n%2 == 0 or n%3 == 0 is true if either or both of the conditions is true, that is, if the number is divisible by 2 or 3.

Finally, the not operator negates a Boolean expression, so not (x > y) is true if x > y is false, that is, if x is less than or equal to y .

Strictly speaking, the operands of the logical operators should be Boolean expressions, but Python is not very strict. Any nonzero number is interpreted as True :

This flexibility can be useful, but there are some subtleties to it that might be confusing. You might want to avoid it (unless you know what you are doing).

Conditional execution

In order to write useful programs, we almost always need the ability to check conditions and change the behavior of the program accordingly. Conditional statements give us this ability. The simplest form is the if statement:

Figure 41: Simple IF Conditional Flowchart

The Boolean expression after if is called the condition. If it is true, the indented statement runs. If not, nothing happens. See the corresponding flowchart in figure 42.

if statements have the same structure as function definitions: a header followed by an indented body. Statements like this are called compound statements.

There is no limit on the number of statements that can appear in the body, but there has to be at least one.

A second form of the if statement is “alternative execution” ( if-else ), in which there are two possibilities and the condition determines which one runs. The syntax looks like this:

if x % 2 == 0: print('x is even') else: print('x is odd')

Figure 42: Alternative Execution Conditional Flowchart

Modulus or remainder operator , ‘ % ’, returns the remainder of two numbers. So in this example, i f the remainder when x is divided by 2 is 0, then we know that x is even, and the program displays an appropriate message. If the condition is false, the second set of statements runs. Since the condition must be true or false, exactly one of the alternatives will run. The alternatives are called branches, because they are branches in the flow of execution. See the corresponding flowchart in figure 42.

The if statement is used to check a condition: if the condition is true, we run a block of statements (called the if-block ), else we process another block of statements (called the else-block ). The else clause is optional. In our earlier examples we only had one statement in a block. Sometimes there are more than two possibilities and we need more than two branches. One way to express a computation like that is a chained conditional ( if-elif-else ). The following program, ifElse.py , show s us multiple statements in each block.

number = 23 guess = int(input('Enter an integer : '))

if guess == number: # New block starts here print('Congratulations, you guessed it.') print('(but you do not win any prizes!)') # New block ends here elif guess < number: # Another block print('No, it is a little higher than that') # You can do whatever you want in a block ... else: print('No, it is a little lower than that') # you must have guessed > number to reach here

print('Done') # This last statement is always executed, # after the if statement is executed.

In this program, we take guesses from the user and check if it is the number that we have. We set the variable number to any integer we want, say 23. Then, we take the user’s guess using the input() function. We then convert this string to an integer using int and then store it in the variable guess .

Next, we compare the guess of the user with the number we have chosen. If they are equal, we print a success message. Notice that we use indentation levels to tell Python which statements belong to which block. Then, we check if the guess is less than the number, and if so, we inform the user that they must guess a little higher than that.

After Python has finished executing the complete if statement along with the associated elif and else clauses, it moves on to the next statement in the block containing the if statement. In this case, it is the main block (where execution of the program starts), and the next statement is the print('Done') statement. After this, Python sees the end of the program and simply finishes up.

The following code is another example of a conditional statement with more than two branches:

if x < y: print('x is less than y') elif x > y: print('x is greater than y') else: print('x and y are equal')

Figure 43: Two or More Branches Conditional Flowchart

elif is an abbreviation of “else if”. Again, exactly one branch will run. There is no limit on the number of elif statements. See the corresponding flowchart in figure 43. If there is an else clause, it has to be at the end, but there doesn’t have to be one. See the following example:

if choice == 'a': draw_a() elif choice == 'b': draw_b() elif choice == 'c': draw_c()

Each condition is checked in order. If the first is false, the next is checked, and so on. If one of them is true, the corresponding branch runs and the statement ends. Even if more than one condition is true, only the first true branch runs. It is good practice to include the else clause as the final branch in the if-elif-else statement.

Practic e – Write a program to accept a test score as input and print out the corresponding letter grade. First examine the flowchart (figure 44) of the problem we are solving. Then, using the Python editor, enter the following code (save as testGrade.py ):

Figure 44: if-elif-else Conditional Flowchart

#accept a test score as input and print out the corresponding letter grade testScore = float(input("Enter a test score from 0 to 100: ")) # conditional statement to determine and print the test letter grade if testScore >= 90: print("your grade is A") elif testScore >= 80: print("your grade is B") elif testScore >= 70: print("your grade is C") elif testScore >= 60: print("your grade is D") else: print("your grade is F")

Let us examine how this program works.

One conditional can also be nested within another called nested conditionals . Earlier in this section we saw the following example using a chained conditional ( if-elif-else ).

if x < y:

print('x is less than y') elif x > y: print('x is greater than y') else: print('x and y are equal')

We could have just as easily written this code using nested conditionals like this:

if x == y: print('x and y are equal') else: if x < y: print('x is less than y') else: print('x is greater than y')

The outer conditional contains two branches. The first branch contains a simple statement. The second branch contains another if statement, which has two branches of its own. Those two branches are both simple statements, although they could have been conditional statements as well.

Although the indentation of the statements makes the structure apparent, nested conditionals become difficult to read very quickly. It is a good idea to avoid them when you can.

Logical operators often provide a way to simplify nested conditional statements. For example, we can rewrite the following code using a single conditional:

if 0 < x: if x < 10: print('x is a positive single-digit number.')

The print statement runs only if we make it past both conditionals, so we can get the same effect with the and operator:

if 0 < x and x < 10: print('x is a positive single-digit number.')

For this kind of condition, Python provides even a more concise option:

Exception Handling

In our programming experience so far we have encountered several kinds of programming run-time exceptions, such as division by zero, attempting to read a variable that has not been defined, and attempting to convert a non-number to an integer. We have seen these and other run-time exceptions immediately terminate a running program.

Exceptions are a means of breaking out of the normal flow of control of a code block in order to handle errors or other exceptional conditions. An exception is raised at the point where the error is detected; it may be handled by the surrounding code block or by any code block that directly or indirectly invoked the code block where the error occurred. The Python interpreter raises an exception when it detects a run-time error (such as division by zero).

Python provides a standard mechanism called exception handling that allows programmers to deal with these kinds of run-time exceptions and many more. Rather than always terminating the program’s execution (this is called a program “crash”), an executing program can detect the problem when it arises and possibly execute code to correct the issue it in some way.

Exceptions occur when exceptional situations occur in your program. Similarly, what if your program had some invalid statements? This is handled by Python which raises its hands and tells you there is an error.

Consider the simple print function call. What if we misspell print as Print ? Note the capitalization. In this case, Python raises a syntax error. The following output appears in the Python shell. Observe that a NameError is raised and also the location of the error detected is printed. This is what an error handler for this error does.

>>>Print("hello there!") Traceback (most recent call last):     File "<pyshell#0>", line 1, in <module>         Print("hello there!") NameError: name 'Print' is not defined >>> print("hello there!") hello there! >>>

Let us try to read input from the user. In the Python shell we enter the first line below and hit the Enter key. When the computer prompts for input, instead press [ctrl-c] (this example is with Windows) and see what happens.

Python raises an error called KeyboardInterrupt which basically means it was interrupted when it expected to get user input.

Let us look at another example. Here we will read input from the user and then attempt to convert the string input into an integer.

Python raises an error called ValueError which is letting us know that the string ’no’ cannot be converted to an integer value. Programmers can avoid this scenario by checking that a string’s value can be converted to a number value.

Another common exception occurs when we try to evaluate a comparison which does not make sense. Consider the following Python conditional statements executed in the Shell window:

Python raises an error called TypeError which is letting us know that the condition 12 < 'a' cannot be performed.

Handling Exceptions

Essentially, exceptions are events that modify program’s flow, either intentionally or due to errors. They are special events that can occur due to an error, e.g. trying to divide a number by zero. Exceptions, by definition, don’t occur very often; hence, they are the “exception to the rule”.

Exceptions are everywhere in Python. Virtually every module in the standard Python library uses them, and Python itself will raise them in a lot of different circumstances. One use of exceptions is to catch an error and allow the program to continue working instead of crashing ungracefully.

This is the most common way to use exceptions. When programming with the Python command line interpreter (in the Shell window), you don’t need to worry about catching exceptions. Your program is usually short enough to not be hurt too much if an exception occurs. Plus, having the exception occur at the command line is a quick and easy way to tell if your code logic has a problem. However, if the same error occurred in your saved .py file program, it will crash (fail) and stop working.

Exceptions can be thought of as a special form of the if-else statements. You can realistically do the same thing with if blocks as you can with exceptions. However, as already mentioned, exceptions aren’t processed until they occur; if blocks are processed all the time. Proper use of exceptions can help the performance of your program. The more infrequent the error might occur, the better off you are to use exceptions; using if blocks requires Python to always test extra conditions before continuing. Exceptions also make code management easier: if your programming logic is mixed in with error-handling if statements, it can be difficult to read, modify, and debug your program.

We can handle exceptions using the try-except-else statement. Briefly, try creates a block that attempts to perform an action. If that action fails, the except block catches any exception that is raised and notifies the user that an error occurred, then stops executing the program. If the code within the try block does not produce an exception, the program’s execution continues with code in the else block.

Practice – Here is a simple program that uses exception processing. It simply produces the quotient of 2 numbers. Try entering, saving and running the following program ( exceptionHandling.py ).

# exception handling first_number = input ( "Enter the first number: ") #gets input from keyboard sec_number = input ( "Enter the second number: " ) try : num1 = float( first_number ) #try turning keyboard input into floats num2 = float( sec_number ) result = num1/num2 #try dividing num1 by num2 except: print("Error: enter numbers only; num2 cannot equal zero") else : print(str(num1) + "/" + str(num2) + "=" + str(result))

The output from executing this program, three separate times, is shown below.

In this example we simply print out a message to the user in the except block and then gracefully terminate our program. We use the else statement at the end to perform the rest of the program logic if all goes well. As stated before, the whole try block could also have been written as if/else statements but that would have required Python to process each statement to see if they matched. By using exceptions, the “default” case is assumed to be true until an exception actually occurs. This speeds up processing.

It’s better to include error-checking, such as exceptions, in your code as you program rather than as an afterthought. A special “category” of programming involves writing test cases (we wrote test cases for our algorithms in Unit 1!) to ensure that most possible errors are accounted for in the code, especially as the code changes or new versions are created. Recall the test cases we were introduced to when writing our algorithms in Unit 1. By planning ahead and putting exception handling into your program at the outset, you ensure that problems are caught before they can cause problems.

Practice with Handling Exceptions in our Programs

Let us review some examples of handling exceptions in some of our programs we have written.

Practice #1 – Calculating the distance between two points:

# calculates the distance between two points

import math

print("This program calculates the distance between two points.") print() #print a blank line

x1 = float(input("Enter the x for the first point: ")) y1 = float(input("Enter the y for the first point: ")) print() x2 = float(input("Enter the x for the second point: ")) y2 = float(input("Enter the y for the second point: "))

distance = math.sqrt((x2-x1)**2  + (y2-y1)**2)

print() print("The distance between the points is", distance)

The output when executing this program with non-numeric input is seen below:

Rewrite this program to include exception handling to catch the ValueError when we try and convert our user input into floating point numbers.

# Calculates the distance between two points

print("This program calculates the distance between two points.") print() try: x1 = float(input("Enter the x for the first point: ")) y1 = float(input("Enter the y for the first point: ")) print() x2 = float(input("Enter the x for the second point: ")) y2 = float(input("Enter the y for the second point: ")) except: print("Error: enter numeric values only") else: distance = math.sqrt((x2-x1)**2 + (y2-y1)**2) print() print("The distance between the points is", distance)

The output when executing the revised program with non-numeric input is far more user friendly!

>>> RESTART: C:/Users/lh166266.UALBANY/distanceBetweenPointsExceptionHandling.py This program calculates the distance between two points. Enter the x for the first point: 17 Enter the y for the first point: 23 Enter the x for the second point: 88 Enter the y for the second point:9p Error: enter numeric values only >>>

Practice # 2 – Guess the Number:

number = 23 guess = int(input('Enter an integer : ')) if guess == number: print('Congratulations, you guessed it.') print('(but you do not win any prizes!)') elif guess < number: print('No, it is a little higher than that') else: print('No, it is a little lower than that')

print('Done')

Rewrite this program to include exception handling to catch the ValueError when we try and convert the user input into an integer.

# Guess my number

number = 23 .           #this is ‘my number’ try: guess = int(input('Enter an integer : ')) except: print("ERROR: enter whole numbers only") else: if guess == number: print('Congratulations, you guessed it.') print('(but you do not win any prizes!)') elif guess < number: print('No, it is a little higher than that') else: print('No, it is a little lower than that')

The output when executing the revised program with non-numeric input gracefully ends rather than crashing!

This section is about iteration, which is the ability to run a block of statements repeatedly. Computers are often used to automate repetitive tasks. Repeating identical or similar tasks without making errors is something that computers do well and people do poorly. In a computer program, repetition is also called iteration.

The while Statement

A while statement is an iterative control statement that repeatedly executes a set of statements based on a provided Boolean expression (condition). All iterative control needed in a program can be achieved by use of the while statement, though, as we will see later, other iterative control statements can be more useful for solving some computational problems.

Here is a version of a countdown function that uses a while statement:

def countdown(n): while n > 0: print(n) n = n - 1 print('Blastoff!')

Figure 45: While Loop Flowchart

  You can almost read the while statement as if it were English. It means, “While n is greater than 0, display the value of n and then decrement n. When you get to 0, display the word Blastoff!”

Here is the flow of execution for a while statement:

• Determine whether the condition is true or false.
• If false, exit the while statement and continue execution at the next statement.
• If the condition is true, run the body and then go back to step 1.

This type of flow is called a loop because the third step loops back around to the top.

The body of the loop should change the value of one or more variables so that the condition becomes false eventually and the loop terminates. Otherwise the loop will repeat forever, which is called an infinite loop.

In the case of the countdown function, we can prove that the loop terminates: if n is zero or negative, the loop never runs. Otherwise, n gets smaller each time through the loop, so eventually we have to get to 0.

Practice 1 : Try executing the following program which uses the countdown function ( countdown.py ).

def countdown(n): while n > 0: print(n) n = n - 1 print('Blastoff!') num = input("enter a positive number to countdown from: ")

try: num=int(num) except: print("ERROR: enter a whole number") else: countdown(num)

An example of the output after execution:

The variable n in the countdown.py program is referred to as a counter . A counter variable is used to count something, usually initialized to zero and then incremented (or decremented) and is commonly used in programs.

The while statement allows you to repeatedly execute a block of statements as long as a condition is true. A while statement is an example of what is called a looping statement. A while statement can have an optional else clause. Let us look at the following program ( while.py )

number = 23 running = True

while running: guess = int(input('Enter an integer : ')) if guess == number: print('Congratulations, you guessed it.') # this causes the while loop to stop running = False elif guess < number: print('No, it is a little higher than that.') else: print('No, it is a little lower than that.') else: print('The while loop is over.') # Do anything else you want to do here

In this program, we are still playing the guessing game, but the advantage is that the user is allowed to keep guessing until he guesses correctly – there is no need to repeatedly run the program for each guess, as we have done in the previous section. This aptly demonstrates the use of the while statement. Let us examine more closely the code in this program ( while.py ) .

The following is a sample of output after running this program:

This is an example of an interactive loop because it allows the user to repeat something (in this example the user is guessing a number) on demand.

Practice 2 : The following program allows a user to enter any number of nonnegative integers. When the user enters a negative value, the program no longer accepts input, and it displays the sum of all the nonnegative values. If a negative number is the first entry, the sum is zero. This is also an example of interactive loop . [ addNonNegatives.py ]

Figure 46: Sample Output from addNonNegatives.py

Figure 47: While Loop Flowchart

  Let us examine more closely the code in this program.

Practice 3 : Now let us rewrite this program to add additional functionality. In addition to finding the sum of nonnegative values we will calculate the average. [ avgNonNegatives.py ]

The program needs not only an accumulator variable (i.e. sum ) but a counter variable also (named count ) to keep track of how many numbers have been entered. We can then calculate the average by dividing the sum by the count.

RESTART: C:/Users/lh166266.UALBANY/Code/avgNonNegatives.py Enter positive numbers to sum (entering a negative number ends the program). number: 12 number: 55 number: 31 number: -11 Sum = 98 Average = 32.666666666666664

Figure 48: Sample Output from avgNonNegatives.py

The break Statement

Sometimes you don’t know it’s time to end a loop until you get half way through the body. In that case you can use the break statement to jump out of the loop.

For example, suppose you want to take input from the user until they type done . You could write:

The loop condition is True , which is always true, so the loop runs until it hits the break statement.

Each time through, it prompts the user with an angle bracket. If the user types done, the break statement exits the loop. Otherwise the program echoes whatever the user types and goes back to the top of the loop. Here’s a sample run:

This way of writing while loops is common because you can check the condition anywhere in the loop (not just at the top) and you can express the stop condition affirmatively (“stop when this happens”) rather than negatively (“keep going until that happens”).

Note that the break statement works with the for loop as well.

The continue Statement

The continue statement is used to tell Python to skip the rest of the statements in the current loop block and to continue to the next iteration of the loop.

Let us examine the following example (save as continue.py ):

# user is to enter a string of at minimum 3 words # to end the user is to enter the word 'quit' while True: data = input('Enter at least 3 words: ') if data == 'quit': break if len(data) < 3: print('Too small') continue print('Input (data) is of sufficient length') # Do other kinds of processing here...

Sample Output:

In this program, we accept input from the user, but we process the input string only if it is at least 3 words long or the user enters the word ‘quit’. So, we use the built-in len function to get the length and if the length is less than 3, we skip the rest of the statements in the block by using the continue statement. Otherwise, the rest of the statements in the loop are executed, doing any kind of processing we want to do here. When the user enters the word ‘ quit’ we exit the loop using the break statement, then end the program. This is an example of an input validation loop . In an input validation loop (commonly designed using the while loop) the program inspects user input before it is processed by the program and if input is invalid it prompts user to enter correct data.

Note that the continue statement works with the for loop as well.

The for…in Statement

The for..in statement is another looping statement which iterates over a sequence of objects i.e. go through each item in a sequence. Recall that a sequence is just an ordered collection of items. Let us look at the following program, for.py .

for i in range(1, 5): print(i) else: print('The for loop is over')

This is what the output of the program looks like in the Python shell after it runs:

In this program, we are printing a sequence of numbers. We generate this sequence of numbers using the built-in range function.

What we do here is supply it two numbers and range returns a sequence of numbers starting from the first number and up to the second number. For example, range ( 1,5 ) gives the sequence [1, 2, 3, 4] . By default, range takes a step count of 1 . If we supply a third number to range , then that becomes the step count. For example , range(1,5,2) gives [1,3] . Remember that the range extends up to the second number i.e. it does not include the second number.

The for loop then iterates over this range – for i in range(1,5) is equivalent to for i in [1, 2, 3, 4] which is like assigning each number (or object) in the sequence to i , one at a time, and then executing the block of statements for each value of i . In this case, we just print the value in the block of statements.

The general form of the range expression is range( begin,end,step ) where

• begin is the first value in the range; if omitted, the default value is 0
• end is one past the last value in the range; the end value is always required and may not be omitted
• step is the amount to increment or decrement; if the step parameter is omitted, it defaults to 1 (counts up by ones)

begin , end , and step must all be integer expressions; floating-point expressions and other types are not allowed. The arguments in the range expression may be literal numbers (like 10), variables (like x , if x is equal to an integer), and arbitrarily complex integer expressions.

The range expression is very flexible. Consider the following loop that counts down from 21 to 3 by threes:

for n in range(21, 0, -3): print(n, end=' ')

21 18 15 12 9 6 3

Thus range(21, 0, -3) represents the sequence 21;18;15;12;9; 3 .

The expression range(1000) produces the sequence 0;1;2; : : : ; 999.

The following code computes and prints the sum of all the positive integers less than 100:

sum = 0 # Initialize sum for i in range(1, 100): sum += i print(sum)

Remember that the else block is optional. When included, it is always executed once after the for loop is over unless a break statement is encountered.

So far we have used the for loop to iterate over integer sequences because this is a useful and common task in developing apps. The for loop, however, can iterate over any iterable object , such as a string .

We can use a for loop to iterate over the characters that comprise a string. The following program uses a for loop to print the individual characters of a string (printLetters.py ) .

word = input('Enter a word: ') for letter in word: print(letter)

Sample output :

Practice 1 : Write a program to solve the following problem. [printWords.py]

# Ask the user how many words they want to enter # then print the words together on one line. sentence = "" num = input("How many words do you want to enter? ") try: num=int(num) except: print ("ERROR: enter a number") else: if num > 0: #check for a positive number for i in range(num): word = input("enter a word: ") sentence = sentence + " " + word print(sentence) else: print("Will only accept a positive integer number. Ending program")

Note the error checking performed in the program:

• Ensures the user only enters integer numbers as input
• Ensures the user enters a positive integer

Practice 2 : Write a program to solve the following problem. [numWords.py]

Unlike the example where we use d a for loop to iterate over the characters of a word, we need to use a string object’s method to break the string into words. When you need to break a large string down into smaller chunks, or strings , you use the split() string method. By default, split() takes whitespace as the delimiter. Try executing this program (numWords.py)

Example output:

Once you have used split to break the string into a list of words, you can use the index operator (square bracket) to look at a particular word in the list.

Enhance this program to loop through each word in the list named words and print each word in uppercase on its own line ( uppercaseWords.py .

How to choose between the for and while loop?

Use a for loop if you know, before you start looping, the maximum number of times that you’ll need to execute the body. For example, if you’re traversing a list of elements, you know that the maximum number of loop iterations you can possibly need is “all the elements in the list”. Or if you need to print the 12 times table, we know right away how many times the loop will need to run.

So any problem like “iterate this weather model for 1000 cycles”, or “search this list of words”, “find all prime numbers up to 10000” suggest that a for loop is best.

By contrast, if you are required to repeat some computation until some condition is met, and you cannot calculate in advance when (of if) this will happen, as we did in this 3n + 1 problem, you’ll need a while loop.

We call the first case definite iteration — we know ahead of time some definite bounds for what is needed. The latter case is called indefinite iteration — we’re not sure how many iterations we’ll need — we cannot even establish an upper bound!

Nested Loops

Just like with if statements, while and for blocks can contain arbitrary Python statements, including other loops. A loop can therefore be nested within another loop. To see how nested loops work, consider a program that prints out a multiplication times tables ( multiplication.py ).

#multiplcation tables try: table = int(input("which multiplication times table do you want to print? (choose from 1 to 12) “)) x = table except: print("ERROR: enter a whole number") else: if table > 0 and table < 13: for y in range(1, 13): print (x,'*', y,'=', x*y) else: print ("ERROR: multiplication tables can be generated from 1 to 12 only")

Let us examine more closely the code in this program.

Now let us consider adding to this program to generate all the multiplication times tables from 1 to 12. This is easily done with nested loops.

#multiplcation times tables tables for x in range(1, 13): for y in range(1, 13): print (x,'*', y,'=', x*y)

The output after execution of this 3-lines-of-code program generates 144 lines of output!

1 * 1 = 11 * 2 = 21 * 3 = 31 * 4 = 41 * 5 = 51 * 6 = 61 * 7 = 71 * 8 = 81 * 9 = 91 * 10 = 101 * 11 = 111 * 12 = 122 * 1 = 22 * 2 = 42 * 3 = 62 * 4 = 82 * 5 = 102 * 6 = 122 * 7 = 142 * 8 = 162 * 9 = 182 * 10 = 202 * 11 = 222 * 12 = 24...12 * 1 = 1212 * 2 = 2412 * 3 = 3612 * 4 = 4812 * 5 = 6012 * 6 = 7212 * 7 = 8412 * 8 = 9612 * 9 = 10812 * 10 = 12012 * 11 = 13212 * 12 = 144

Basic File Processing

While a program is running, its data is stored in random access memory (RAM) on the computer it is execution on. RAM is fast and inexpensive, but it is also volatile, which means that when the program ends, or the computer shuts down, the data in RAM disappears. To make data available the next time the computer is turned on and the program is started, it has to be written to a non-volatile storage medium, as a file. By reading and writing files, programs can save information between program runs.

So far, the data we have used in this book have all been either coded right into the program, or have been entered by the user. In real life data reside in files.

For our purposes, we will assume that our data files are text files–that is, files filled with characters. The Python programs that you write are stored as text files as are any HTML webpage files. We can create these files in any of a number of ways. For example, we could use a text editor to type in and save the data. We could also download the data from a website and then save it in a file. Regardless of how the file is created, Python will allow us to manipulate the contents. Note that text files have an End-Of-Line (EOL) character to indicate each line’s termination.

Reading and Writing Text Files

In Python, we must open files before we can use them and close them when we are done with them. As you might expect, once a file is opened it becomes a Python object just like all other data. The following table shows the functions and methods that can be with files.

Table 7: File Functions and Methods

Python file object attributes provide information about the file and file state. The following table shows how to identify some of the object’s attributes.

Table 8: File Object Attributes

The statement

file1 = open('myfile.txt', 'r')

creates and returns a file object in the variable named file1 . The first argument to open is the name of the file, and the second argument is a mode (in this example the mode is to read the file). This statement will attempt to read the content of the text file named myfile.txt . If the file does not exist or the user of the program does not have adequate permissions to open the file, the open function will raise an exception.

print(“ERROR: unable to open or locate the file”)

# Do other kinds of processing here...

Similar to handling an error of invalid user input we need to use the try-except-else block to handle trying to read from a file which does not exist The following is an example:

file2 = open('myfile.txt', 'w')

creates and returns a file object in the variable named file2 which will write data to the text file named myfile.txt . If the file does not exist, the function creates the file on disk; no exceptions are raised when writing to a file. If a file by that name currently exists, new data will replace the current data stored in the file. This means any pre-existing data in the file will be lost.

Once you have a file object capable of writing (opened with ‘w’) you can save data to the file associated with that file object using the write method. For a file object named file2 , the statement

file2.write('data')

stores the string ‘data’ to the file. The three statements

file2.write('compute')

file2.write('process')

writes the text 'datacomputeprocess' to the file. If our intention is to retrieve the three separate original strings, we must add delimiters to separate the pieces of data. Newline characters serve as good delimiters:

file2.write('data\n')

file2.write('compute\n')

file2.write('process\n')

This places each word on its own line in the text file. The advantage of storing each piece of data on its own line of text is that it makes it easier to read the data from the file with a for statement. If file2 is a file object created for reading, the following code:

for line in file2:

print(line.strip())

reads in each line of text from the file and prints it out. The variable line is a string, and we use the strip method to remove the trailing newline ( '\n' ) character.

We also can read the contents of the entire file into a single string using the file object’s read method:

contents = file2.read()

Given the text file from above, the code

in = open('compterms.txt', 'r')

str = in.read()

assigns to str the string 'data\ncompute\nprocess\n' .

The open method opens a file for reading or writing, and the read , write , and other such methods enable the program to interact with the file. When the executing program is finished with its file processing it must call the close method to close the file properly. Failure to close a file can have serious consequences when writing to a file, as data meant to be saved could be lost. Every call to the open function should have a corresponding call to the file object’s close method.

Practice – Following are two simple programs designed to write data to a file and then read and print each line of a file. Try entering, saving and running the following programs ( writeFile.py and readFile.py ).

Figure 49: writeFile.py

Figure 50: readFile.py

This is the output after running this program:

We can also read and process each line of data in a file by using the readline() method. Try entering, saving and running the following programs (readFile2.py) . The output is the same.

try: file1 = open('compterms.txt','r') # try to find & open the file except: print('ERROR: unable to open or locate the file') else: line = file1.readline() # Read the first line while line: # Enter the loop as long as there is a line of data to read print(line.strip()) # Remove trailing newline character and print the line line = file1.readline() # Read the next line file1.close() # Close the file after processing data

Processing “Big Data”

Big data is large, and often times complex, data sets that need to be processed into useful information. Python has emerged over the past few years as a leader in data science programming including the analysis and visualization of large data sets.

Data sets grow rapidly – in part because they are increasingly gathered by cheap and numerous information-sensing internet of things devices such as mobile devices, aerial (remote sensing), software logs, cameras, microphones, radio-frequency identification (RFID) readers and wireless sensor networks. The world’s technological per-capita capacity to store information has roughly doubled every 40 months since the 1980s; as of 2012, every day 2.5 exabytes (2.5×1018) of data are generated. Based on an IDC (International Data Corporation) report prediction, the global data volume will grow exponentially from 4.4 zettabytes to 44 zettabytes between 2013 and 2020. By 2025, IDC predicts there will be 163 zettabytes of data. [1]

Figure 51: “Data Information”(www.maxpixel.net/Circle-Know-Arrangement-Data-Information-Learn-229113) is licensed under CC-BY 0

An example of a successful business that uses python for collecting and analyzing data is ForecastWatch. ForecastWatch.com is in the business of rating the accuracy of weather reports from companies such as Accuweather, MyForecast.com, and The Weather Channel. Over 36,000 weather forecasts are collected every day for over 800 U.S. cities, and later compared with actual climatological data. These comparisons are used by meteorologists to improve their weather forecasts, and to compare their forecasts with others. They are also used by consumers to better understand the probable accuracy of a forecast. [2]

We will use real data from open source data sets (that is saved as text files) for programming practice.

Problem Statement : Using the text file, NYScoastalFlooding.txt , identify each of the New York State counties (zones) effected by coastal flooding during the month of August within the dataset provided.

The first step in finding a solution for this problem is to review and understand the format of the data set provided. Open the text in a text editor and note the field headings in the first line of the file. The following is a small sample from the NYScoastalFlooding.txt file.

We see that the data set has six fields:

• year: Four digit year for the event in this record
• month_name: Name of the month for the event in this record (spelled out; not abbreviated)
• event_type spelled out; not abbreviated
• cz_type: Indicates whether the event happened in a (C) county/parish, (Z) zone or (M) marine
• cz_fips: The county FIPS number is a unique number assigned to the county by the National Institute for Standards and Technology (NIST) or NWS Forecast Zone Number
• cz_name: County/Parish, Zone or Marine Name assigned to the county FIPS number or NWS Forecast Zone

We also notice that all but the first field on each line has a blank space before it (this is important!).

We will break this problem into smaller pieces. Let us start with a program that reads each of the records and keeps a count of the number of records in the file (dataRecordNumb.py). This program is a modification of our readFile.py program.

try: file1 = open('NYScoastalFlooding.txt ','r') # try to find & open the file except: print('ERROR: unable to open or locate the file') else: count = 0 # Initialize recount cout to zero for line in file1: # Read each line as text print(line.strip()) # Print the record count = count + 1 # increment record counter print("There are",count,"data records in this file") file1.close() # Close the file after processing data

The last line of the output from running this program:

Recall from Unit 2 when we used the split() method to identify each individual word in a sentence. What the method does is split or breakup a string and add the data to a list of separate ‘chunks’ using a defined separator. So if this line is read

2017, January, Coastal Flood, Z, 79, NORTHEAST SUFFOLK

and we split the line into individual fields we could identify those records effected by coastal flooding during the month of August.

fields = line.split(‘,’)

If we now print fields we have a list of all the fields which we can now access.

>>> print(fields)

['2017', ' January', ' Coastal Flood', ' Z', ' 79', ' NORTHEAST SUFFOLK']

Notice the extra blank space before the string “January” in the list fields . When trying to identify those records with the string “August” the extra space must be dealt with!

Let us complete the second program to solve the problem of identifying (and print) each of the New York State counties (zones) effected by coastal flooding during the month of August ( NYScountiesAug.py ).

# identify each of the New York State counties (zones) effected by coastal flooding during the month of August print("The following are the NYS counties (zones) effected by coastal flooding during the month of August:") try: file1 = open('NYScoastalFlooding.txt ','r') # try to find & open the file except: print('ERROR: unable to open or locate the file') else: for line in file1: # Read each line as text fields = line.split(",") # split each line into a list of 'fields' if fields[1] == " August": # check if the 2nd field is August county = fields[5] # identify the county from the 6th field print(county.strip()) # Print the record file1.close() # Close the file after processing data

The output from running this program:

To test if the program correctly identified all records effected by coastal flooding during the month of August you would need to manually go through each of the 61 records and flag the records that should be found and printed (or use an app such as Excel to do a sort and count for you).

The actual data set I downloaded had a total of 56,921 records and 51 different fields (a lot more data than what we just worked with!). A professional data scientist would also test her program using a subset of the large data set until she could be satisfied that the program was running correctly and producing the correct results.

Unit Summary

Practice problems.

• Write a program to accept a number from the user and print whether it is positive or negative.
• Accept three numbers from the user and print the greatest number.
• Write a program that accepts a number in the range from 1 to 7 from the user and generates and displays the name of the weekday.
• Write a program to input 5 numbers from the user and calculates and displays their sum and average.
• Write a program that accepts an integer number and indicates whether it is negative, zero, or positive. Force the user to enter only valid data (repeatedly ask the user to enter only an integer number)
• range(5, 10)
• range(5, 20, 3)
• range(20, 5, -1)
• range(20, 5, -3)
• range(10, 5)
• range(10, 101, 10)
• range(10, -1, -1)
• range(-3, 4)
• range(0, 10, 1)
• Write a program to print a pattern like a right angle triangle with numbers where each number will repeat in a row. The pattern is as follows: 1 22 333 4444 55555

• Find a poem you like and save it as a text file named poem.txt. Write a program that counts the number of lines in your program. Print out the line count and each individual line in the program (no extra blank lines!)
• Write a program that stores the first 100 integers to a text file named numbers.txt. Each number should appear on a line all by itself.
• Write a program to find the longest word in a text file.
• Wikipedia contributors. "Big data." Wikipedia, The Free Encyclopedia. Wikipedia, The Free Encyclopedia, 4 Jul. 2018. Web. 12 Jul. 2018. ↵
• Python Software Foundation. Python Success Stories, https://www.python.org/about/success/forecastwatch/ . Accessed July 12, 2018 ↵

Privacy Policy

• System Design Tutorial
• What is System Design
• System Design Life Cycle
• High Level Design HLD
• Low Level Design LLD
• Design Patterns
• UML Diagrams
• System Design Interview Guide
• Crack System Design Round
• System Design Bootcamp
• System Design Interview Questions
• Microservices
• Scalability

An introduction to Flowcharts

• What is a Flowchart and its Types?
• Creating Interactive Plots with R and Highcharts
• Interactive Bubble Chart in R
• Charts.js Introduction
• RAPTOR Tool - A Flowchart Interpreter
• Introduction to Graphs | Class 8 Maths
• Python | Bar Charts in Vincent
• Pygal Introduction
• Introduction of Algorithmic State Machines (ASMs)
• Introduction to Matplotlib
• Flowchart for basic Machine Learning models
• Charts.js Installation Guide
• Dual Combination Chart in Tableau
• Data Visualization with Highcharter in R
• Short Note on Gantt Chart
• Gantt Chart in Tableau
• How to build Animated Charts like Hans Rosling
• How to Make a Gantt Chart in Excel
• Power BI - Cluster Bar and Column Charts
• Introduction to Pattern Designing
• Singleton Method Design Pattern
• Sequence Diagrams | Unified Modeling Language (UML)
• Unified Modeling Language (UML) Diagrams
• Prototyping Model - Software Engineering
• Factory method design pattern in Java
• Factory method Design Pattern
• MVC Design Pattern
• OOPs | Object Oriented Design
• Builder Design Pattern

What is a Flowchart?   Flowchart is a graphical representation of an algorithm. Programmers often use it as a program-planning tool to solve a problem. It makes use of symbols which are connected among them to indicate the flow of information and processing.  The process of drawing a flowchart for an algorithm is known as “flowcharting”. 

Basic Symbols used in Flowchart Designs

• Terminal: The oval symbol indicates Start, Stop and Halt in a program’s logic flow. A pause/halt is generally used in a program logic under some error conditions. Terminal is the first and last symbols in the flowchart.   

• Input/Output: A parallelogram denotes any function of input/output type. Program instructions that take input from input devices and display output on output devices are indicated with parallelogram in a flowchart.   

• Processing: A box represents arithmetic instructions. All arithmetic processes such as adding, subtracting, multiplication and division are indicated by action or process symbol.   

• Decision Diamond symbol represents a decision point. Decision based operations such as yes/no question or true/false are indicated by diamond in flowchart.   

• Connectors: Whenever flowchart becomes complex or it spreads over more than one page, it is useful to use connectors to avoid any confusions. It is represented by a circle.   

• Flow lines: Flow lines indicate the exact sequence in which instructions are executed. Arrows represent the direction of flow of control and relationship among different symbols of flowchart. 

Rules For Creating Flowchart :

A flowchart is a graphical representation of an algorithm.it should follow some rules while creating a flowchart Rule 1: Flowchart opening statement must be ‘start’ keyword. Rule 2:  Flowchart ending statement must be ‘end’ keyword. Rule 3: All symbols in the flowchart must be connected with an arrow line. Rule 4: The decision symbol in the flowchart is associated with the arrow line.  

Advantages of Flowchart:

• Flowcharts are a better way of communicating the logic of the system.
• Flowcharts act as a guide for blueprint during program designed.
• Flowcharts help in debugging process.
• With the help of flowcharts programs can be easily analyzed.
• It provides better documentation.
• Flowcharts serve as a good proper documentation.
• Easy to trace errors in the software.
• Easy to understand.
• The flowchart can be reused for inconvenience in the future.
• It helps to provide correct logic.  

Disadvantages of Flowchart:

• It is difficult to draw flowcharts for large and complex programs.
• There is no standard to determine the amount of detail.
• Difficult to reproduce the flowcharts.
• It is very difficult to modify the Flowchart.
• Making a flowchart is costly.
• Some developer thinks that it is waste of time.
• It makes software processes low.
• If changes are done in software, then the flowchart must be redrawn  

Example : Draw a flowchart to input two numbers from the user and display the largest of two numbers    

References:   Computer Fundamentals by Pradeep K. Sinha and Priti Sinha  

Please Login to comment...

Similar reads.

• CBSE - Class 11
• school-programming
• Design Pattern
• School Programming
• System Design
• Technical Scripter

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

• 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.1: Activity 1 - Introduction to Algorithms and Problem Solving

• Last updated
• Save as PDF
• Page ID 48194

Introduction

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.

An algorithm is a finite sequence of steps for accomplishing some computational task. It must

• Have steps that are simple and definite enough to be done by a computer, and
• Terminate after finitely many steps.

An algorithm can be considered as a computational procedure that consists of a set of instructions, that takes some value or set of values, as input, and produces some value or set of values, as output, as illustrated in Figure 1.3.1 . It can also be described as a procedure that accepts data, manipulate them following the prescribed steps, so as to eventually fill the required unknown with the desired value(s). The concept of an algorithm is best illustrated by the example of a recipe, although many algorithms are much more complex; algorithms often have steps that repeat (iterate) or require decisions (such as logic or comparison) until the task is completed. Correctly performing an algorithm will not solve a problem if the algorithm is flawed or not appropriate to the problem. A recipe is a set of instructions that show how to prepare or make something, especially a culinary dish.

Different algorithms may complete the same task with a different set of instructions in more or less time, space, or effort than others. Algorithms are essential to the way computers process information, because a computer program is essentially an algorithm that tells the computer what specific steps to perform (in what specific order) in order to carry out a specified task.

Algorithmic problem solving comes in two phases. These include:

• derivation of an algorithm that solves the problem, and
• conversion of the algorithm into code.

It is worth noting that:

• an algorithm is a sequence of steps, not a program.
• same algorithm can be used in different programs, or the same algorithm can be expressed in different languages, because an algorithm is an entity that is abstracted from implementation details.

An algorithm can be expressed in the following ways:

• human language
• pseudo code

Example \(\PageIndex{1}\)

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

Inputs: A list L of positive numbers. This list must contain at least one number.

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

• Set max to 0.
• For each number x in the list L, compare it to max. If x is larger, set max to x.
• max is now set to the largest number in the list.

The learner was introduced to the concept of algorithms and the various ways he/she can develop a solution to a task. In particular, the learner was introduced to the definition/s of an algorithm, the three main ways of developing or expressing an algorithm which are the human language, Pseudo code and the flow chart. An example was also given to reinforce the concept of the algorithm.

• Outline the algorithmic steps that can be used to add two given numbers.
• By using an example, describe how the concept of algorithms can be well presented to a group of students being introduced to it.

Problem Solving with the Sequential Logic Structure

Sep 15, 2012

390 likes | 1.98k Views

Problem Solving with the Sequential Logic Structure. Chapter 5. Review. Recall that the: Algorithm: set of instructions telling the computer how to process a module in a solution. A flowchart: visual illustration of an algorithm. In this chapter you will learn how to:

Share Presentation

• seventh step
• sequential logic structure
• simplest logic structure
• data dictionary

Presentation Transcript

Problem Solving with the Sequential Logic Structure Chapter 5

Review • Recall that the: • Algorithm: set of instructions telling the computer how to process a module in a solution. • A flowchart: visual illustration of an algorithm. • In this chapter you will learn how to: • Write an algorithm for each module in a program. • Draw a flowchart to accompany in each algorithm.

Algorithm Instructions and Flowchart Symbols

Exit is used to end a subordinate module if there is no return value . • Return is used when the module is to be processed within an expression . average = sum ( num1 , num2) / 2

Sequential Logic Structure • The most commonly used and the simplest logic structure . • all problem use the sequential structure . • most problem problems use it in conjunction with one or more of the other logic structure .

Sequential Logic Structure • The form of the algorithm looks like this : module name ( list of parameters) 1. instruction 2. instruction 3. ….. … x x.End,Exit,or Return (variable )

Flowchart Diagram for the Sequential Structure

Example: The algorithm and flowchart to enter a name and age into computer and print it on the screen. ( ) Notice that the algorithm instructions are numbered starting with the first instruction after the name of module

solution development • The problem analysis chart. • The interactivity chart . • The IPO chart . • The coupling diagram and the data dictionary . • The algorithms . • The flowcharts . • The seventh step in solving the problem is to test the solution to catch any errors in logic or calculation .

Let’s work a problem…

The Problem • Marry smith is looking for the bank that will give the most return on her money over the next five years. She has $2,000 to put into a savings account. • The standard equation to calculate principal plus interest at the end of a period of time is: Amount = p * (1+I/M)^(N*M) 12

The Problem • Amount = p * (1+I/M)^(N*M) • p= principal ( amount of money to invest) • I = interest ( percentage rate the bank pays to the invested) • N = number of years ( time for which the principle is invested ) • M = compound interval ( the number of times per year the interest is calculated and added to the principal )

The Interactivity (Structure) Chart

Coupling Diagram

Data Dictionary • in this problem all variables are local . • All coupling will be done through parameters .

Algorithm and Flowchart for InterestControl Module

Algorithm and Flowchart for Read Module

Algorithm and Flowchart for Calc Module

Algorithm and Flowchart for Print Module

• More by User

Sequential Logic

Sequential Logic ENEL 111 1 7 3 Sequential Logic Circuits So far we have only considered circuits where the output is purely a function of the inputs With sequential circuits the output is a function of the values of past and present inputs This particular example is not very useful

1.38k views • 37 slides

SEQUENTIAL LOGIC

SEQUENTIAL LOGIC. Sequential Logic. Positive Feedback: Bi-Stability. Meta-Stability. Gain should be larger than 1 in the transition region. R. S. Q. Q. S. 0. Q. 0. Q. S. Q. 0. 0. 1. 1. Q. R. 0. 1. 0. 1. R. 1. 0. 1. 0. S. Q. Q. R. SR-Flip Flop. Q. Q. R. S. Q.

604 views • 29 slides

PROBLEM SOLVING WITH LOOP AND CASE LOGIC STRUCTURE

Shaykhah. PROBLEM SOLVING WITH LOOP AND CASE LOGIC STRUCTURE. Lecturer: Shaykhah. 2. Objective:Develop problems using the loop logic structure Using nested loop constructsDistinguish the different uses of three loop constructs.. Shaykhah. Pre-requisites. Lecturer: Shaykhah. 3. Short hand Assi

568 views • 23 slides

UNIT 3 PROBLEM SOLVING WITH LOOP AND CASE LOGIC STRUCTURE

UNIT 3 PROBLEM SOLVING WITH LOOP AND CASE LOGIC STRUCTURE. Objective: Develop problems using the loop logic structure Using nested loop constructs Distinguish the different uses of three loop constructs. Pre-requisites. Short hand Assignment Operators

919 views • 22 slides

Sequential Logic. Combinational logic: Compute a function all at one time Fast/expensive e.g. combinational multiplier Sequential logic: Compute a function in a series of steps Slower/more efficient e.g. shift/add multiplier Key to sequential logic: circuit has feedback

323 views • 15 slides

EMT1111 Logic and Problem Solving

Dr. Benito Mendoza Lecture 1. EMT1111 Logic and Problem Solving. Outline. The professor Class objectives Text book and references In class conduct Homework, assignments, and evaluation Blackboard Basic computer skills you should know Create your portfolio. The Professor.

300 views • 20 slides

Sequential Logic. Handouts: Lecture Slides. 6.004: Progress so far…. PHYSICS: Continuous variables, Memory, Noise, f(RC) = 1 - e-t/R. COMBINATIONAL: Discrete, memoryless, noise-free, lookup table functions. What other building blocks do we need in order to compute?.

517 views • 41 slides

Problem Solving with the Sequential Logic Structure. Lesson 5. Overview. Algorithm Instructions Sequential Logic Structure Solution Development. Flowchart Symbols. Terminal Starts, Stops, Ends Input/Output Input data, Output information Assign Apply values to variables Process

406 views • 27 slides

Sequential Logic. Latches and Flip-Flops. Sequential Logic Circuits. The output of sequential logic circuits depends on the past history of the state of the outputs. Therefore, it incorporate a memory element (circuits must remember the past states of their outputs).

494 views • 31 slides

Sequential logic

Sequential logic. Sequential circuits simple circuits with feedback latches edge-triggered flip-flops Timing methodologies cascading flip-flops for proper operation clock skew Asynchronous inputs metastability and synchronization Basic registers shift registers. Sequential circuits.

625 views • 46 slides

Sequential Logic. Introduction to Computer Yung-Yu Chuang. with slides by Sedgewick &amp; Wayne ( introcs.cs.princeton.edu ), Nisan &amp; Schocken ( www.nand2tetris.org ) and Harris &amp; Harris (DDCA). ALU combinational. Memory state. Review of Combinational Circuits. Combinational circuits.

686 views • 51 slides

Sequential Logic. By Stephen Voglewede CS 147 2/23/10. What is Sequential Logic?. Combinational Logic. Combinational Logic. The output of a combinational circuit is a function of it’s input. Consequently, it doesn’t matter what the previous output was. Or what the future output will be.

341 views • 20 slides

Sequential Logic. Flip-Flop Circuits By Dylan Smeder. What Is A Sequential Circuit?. Circuit that has memory Sequence of inputs creates memory At the simplest a Flip-Flop circuit “Sequential Circuits along with combinational circuits are the building blocks of computers”. Simple memory.

563 views • 16 slides

Solving the Logic Satisfiability problem

Solving the Logic Satisfiability problem. Jesus De Loera. Overview. The Satisfiability Problem in its most general form is determining whether it is possible to satisfy a given set of logical constraints Could take many forms: Boolean expressions &amp; logic circuits

297 views • 12 slides

SEQUENTIAL LOGIC. A circuit’s output depends on its previous state (condition) in addition to its current inputs The state of the circuit is kept in memory devices The state dependency is accomplished by feedback path. LATCH. Active Low. LATCH. Active High. LATCH APPLICATION.

529 views • 40 slides

Sequential Logic. Sequential Circuits Simple circuits with feedback Latches Edge-triggered flip-flops Timing Methodologies Cascading flip-flops for proper operation Clock skew Asynchronous Inputs Metastability and synchronization Basic Registers Shift registers. Sequential Circuits.

616 views • 46 slides

Sequential Logic. Lecture #7. 강의순서. Latch FlipFlop Active-high Clock &amp; asynchronous Clear Active-low Clock &amp; asynchronous Clear Active-high Clock &amp; asynchronous Preset Active-high Clock &amp; asynchronous Clear &amp; Preset Shift Register Counter 4 bits Universal Counter : 74161

756 views • 49 slides

Sequential Logic. Lecture #7. 강의순서. Latch FlipFlop Shift Register Counter. SR Latch. Most simple “ storage element ” . Q next = (R + Q ’ current ) ’ Q ’ next = (S + Q current ) ’. NOR. In1 In2 Out 0 0 1 0 1 0 1 0 0 1 1 0. Function Table. Storing. SR latches are sequential.

957 views • 64 slides

Sequential Logic. Combinatorial components: the output values are computed only from their present input values. Sequential components: their output values are computed using both the present and past input values.

368 views • 26 slides

Sequential Logic. ENEL 111. 1. 7. 3. Sequential Logic Circuits. So far we have only considered circuits where the output is purely a function of the inputs With sequential circuits the output is a function of the values of past and present inputs This particular example is not very useful.

466 views • 37 slides

Logic and Problem Solving

Logic and Problem Solving. Advanced Computer Programming. Lecture Objective. After completing this Lecture: We will be able to apply the six-step approach to problem-solving. Enabling Objectives. Identify the six steps in problem solving Describe the purpose of each step in problem solving

315 views • 28 slides

522 views • 46 slides

• Get started with computers
• Learn Microsoft Office
• Apply for a job
• Improve my work skills
• Design nice-looking docs
• Getting Started
• Smartphones & Tablets
• Typing Tutorial
• Online Learning
• Basic Internet Skills
• Online Safety
• Social Media
• Zoom Basics
• Google Docs
• Google Sheets
• Career Planning
• Resume Writing
• Cover Letters
• Job Search and Networking
• Business Communication
• Entrepreneurship 101
• Careers without College
• Job Hunt for Today
• 3D Printing
• Freelancing 101
• Personal Finance
• Sharing Economy
• Decision-Making
• Graphic Design
• Photography
• Image Editing
• Learning WordPress
• Language Learning
• Critical Thinking
• For Educators
• Translations
• Staff Picks
• English expand_more expand_less

Computer Science  - Sequences, Selections, and Loops

Computer science  -, sequences, selections, and loops, computer science sequences, selections, and loops.

Computer Science: Sequences, Selections, and Loops

Lesson 5: sequences, selections, and loops.

/en/computer-science/programming-languages/content/

Sequences, selections, and loops

Behind all of the software we use on a daily basis, there's a code being run with all sorts of terms and symbols. Surprisingly, it can often be broken down into three simple programming structures called sequences , selections , and loops . These come together to form the most basic instructions and algorithms for all types of software.

Watch the video below to learn more about sequences, selections, and loops.

A sequence is a series of actions that is completed in a specific order . Action 1 is performed, then Action 2, then Action 3, etc., until all of the actions in the sequence have been carried out.

A sequence we do every day is a morning routine . You might wake up, drink some water, take a shower, eat breakfast, and so on. Everyone's routine is different, but they're all made up of a sequence of various actions .

Selections are a bit different. Instead of following a specific order of events, they ask a question in order to figure out which path to take next .  

Let's say you go to brush your teeth, and you find that you're out of toothpaste. You'd then ask, "Do I have any more toothpaste?" If the answer is no , then you would add it to your shopping list . But if the answer is yes , you would just use the toothpaste . This is really all a selection is doing: answering a question based on what it finds .

The third programming structure is a loop . Like selections, loops ask questions. However, the difference is that they ask the same question over and over and over again, until a certain task is complete .

For example, take the act of hammering a nail. Even though you may not realize it, you're constantly asking yourself, "Is the nail all the way in?" When the answer is no , you hammer the nail again . You continue to repeat this question until the answer is yes , and then you stop . Loops allow programmers to efficiently code repetitive tasks instead of having to write the same actions over and over again.

These three programming structures may seem pretty simple on their own, but when combined they can create some pretty complex software.

/en/computer-science/should-i-learn-to-code/content/

Problem-Solving Flowchart: A Visual Method to Find Perfect Solutions

Lucid Content

Reading time: about 7 min

“People ask me questions Lost in confusion Well, I tell them there's no problem Only solutions” —John Lennon, “Watching the Wheels”

Despite John Lennon’s lyrics, nobody is free from problems, and that’s especially true in business. Chances are that you encounter some kind of problem at work nearly every day, and maybe you’ve had to “put out a fire” before lunchtime once or twice in your career.

But perhaps what Lennon’s saying is that, no matter what comes our way, we can find solutions. How do you approach problems? Do you have a process in place to ensure that you and your co-workers come to the right solution?

In this article, we will give you some tips on how to find solutions visually through a problem-solving flowchart and other methods.

What is visual problem-solving?

If you are a literal thinker, you may think that visual problem-solving is something that your ophthalmologist does when your vision is blurry. For the rest of us, visual problem-solving involves executing the following steps in a visual way:

• Define the problem.
• Brainstorm solutions.
• Pick a solution.
• Implement solutions.
• Review the results.

How to make your problem-solving process more visual

Words pack a lot of power and are very important to how we communicate on a daily basis. Using words alone, you can brainstorm, organize data, identify problems, and come up with possible solutions. The way you write your ideas may make sense to you, but it may not be as easy for other team members to follow.

When you use flowcharts, diagrams, mind maps, and other visuals, the information is easier to digest. Your eyes dart around the page quickly gathering information, more fully engaging your brain to find patterns and make sense of the data.

Identify the problem with mind maps

So you know there is a problem that needs to be solved. Do you know what that problem is? Is there only one problem? Is the problem sum total of a bunch of smaller problems?

You need to ask these kinds of questions to be sure that you are working on the root of the issue. You don’t want to spend too much time and energy solving the wrong problem.

To help you identify the problem, use a mind map. Mind maps can help you visually brainstorm and collect ideas without a strict organization or structure. A mind map more closely aligns with the way a lot of our brains work—participants can bounce from one thought to the next defining the relationships as they go.

Mind mapping to solve a problem includes, but is not limited to, these relatively easy steps:

• In the center of the page, add your main idea or concept (in this case, the problem).
• Branch out from the center with possible root causes of the issue. Connect each cause to the central idea.
• Branch out from each of the subtopics with examples or additional details about the possible cause. As you add more information, make sure you are keeping the most important ideas closer to the main idea in the center.
• Use different colors, diagrams, and shapes to organize the different levels of thought.

Alternatively, you could use mind maps to brainstorm solutions once you discover the root cause. Search through Lucidchart’s mind maps template library or add the mind map shape library to quickly start your own mind map.

Create a problem-solving flowchart

A mind map is generally a good tool for non-linear thinkers. However, if you are a linear thinker—a person who thinks in terms of step-by-step progression making a flowchart may work better for your problem-solving strategy. A flowchart is a graphical representation of a workflow or process with various shapes connected by arrows representing each step.

Whether you are trying to solve a simple or complex problem, the steps you take to solve that problem with a flowchart are easy and straightforward. Using boxes and other shapes to represent steps, you connect the shapes with arrows that will take you down different paths until you find the logical solution at the end.

Flowcharts or decision trees are best used to solve problems or answer questions that are likely to come up multiple times. For example, Yoder Lumber , a family-owned hardwood manufacturer, built decision trees in Lucidchart to demonstrate what employees should do in the case of an injury.

To start your problem-solving flowchart, follow these steps:

• Draw a starting shape to state your problem.
• Draw a decision shape where you can ask questions that will give you yes-or-no answers.
• Based on the yes-or-no answers, draw arrows connecting the possible paths you can take to work through the steps and individual processes.
• Continue following paths and asking questions until you reach a logical solution to the stated problem.
• Try the solution. If it works, you’re done. If it doesn’t work, review the flowchart to analyze what may have gone wrong and rework the flowchart until you find the solution that works.

If your problem involves a process or workflow , you can also use flowcharts to visualize the current state of your process to find the bottleneck or problem that’s costing your company time and money.

Lucidchart has a large library of flowchart templates to help you analyze, design, and document problem-solving processes or any other type of procedure you can think of.

Draw a cause-and-effect diagram

A cause-and-effect diagram is used to analyze the relationship between an event or problem and the reason it happened. There is not always just one underlying cause of a problem, so this visual method can help you think through different potential causes and pinpoint the actual cause of a stated problem.

Cause-and-effect diagrams, created by Kaoru Ishikawa, are also known as Ishikawa diagrams, fishbone diagrams , or herringbone diagrams (because they resemble a fishbone when completed). By organizing causes and effects into smaller categories, these diagrams can be used to examine why things went wrong or might go wrong.

To perform a cause-and-effect analysis, follow these steps.

1. Start with a problem statement.

The problem statement is usually placed in a box or another shape at the far right of your page. Draw a horizontal line, called a “spine” or “backbone,” along the center of the page pointing to your problem statement.

2. Add the categories that represent possible causes.

For example, the category “Materials” may contain causes such as “poor quality,” “too expensive,” and “low inventory.” Draw angled lines (or “bones”) that branch out from the spine to these categories.

3. Add causes to each category.

Draw as many branches as you need to brainstorm the causes that belong in each category.

Like all visuals and diagrams, a cause-and-effect diagram can be as simple or as complex as you need it to be to help you analyze operations and other factors to identify causes related to undesired effects.

Collaborate with Lucidchart

You may have superior problem-solving skills, but that does not mean that you have to solve problems alone. The visual strategies above can help you engage the rest of your team. The more involved the team is in the creation of your visual problem-solving narrative, the more willing they will be to take ownership of the process and the more invested they will be in its outcome.

In Lucidchart, you can simply share the documents with the team members you want to be involved in the problem-solving process. It doesn’t matter where these people are located because Lucidchart documents can be accessed at any time from anywhere in the world.

Whatever method you decide to use to solve problems, work with Lucidchart to create the documents you need. Sign up for a free account today and start diagramming in minutes.

About Lucidchart

Lucidchart, a cloud-based intelligent diagramming application, is a core component of Lucid Software's Visual Collaboration Suite. This intuitive, cloud-based solution empowers teams to collaborate in real-time to build flowcharts, mockups, UML diagrams, customer journey maps, and more. Lucidchart propels teams forward to build the future faster. Lucid is proud to serve top businesses around the world, including customers such as Google, GE, and NBC Universal, and 99% of the Fortune 500. Lucid partners with industry leaders, including Google, Atlassian, and Microsoft. Since its founding, Lucid has received numerous awards for its products, business, and workplace culture. For more information, visit lucidchart.com.

Related articles

Sometimes you're faced with challenges that traditional problem solving can't fix. Creative problem solving encourages you to find new, creative ways of thinking that can help you overcome the issue at hand more quickly.

Dialogue mapping is a facilitation technique used to visualize critical thinking as a group. Learn how you and your team can start dialogue mapping today to solve problems and bridge gaps in knowledge and understanding (plus get a free template!).

Bring your bright ideas to life.

or continue with

• Create more than 280 types of diagrams
• Supply more than 1500 built-in templates and 26,000 symbols
• Share your work and collaborate with your team in any file format

• What is a Flowchart
• How to Draw a FlowChart
• Flowchart Symbol and Their Usage
• Flowchart Examples & Templates
• Free Flowchart Maker
• What is a Floor Plan
• How to Draw Your Own Floor Plan
• Floor Plan Symbols
• Floor Plan Examples & Templates
• Floor Plan Maker
• What is a UML Diagram
• How to Create A UML Class Diagram
• UML Diagram Symbol
• UML Diagram Examples & Templates
• UML Diagram Tool
• Wiring Diagram
• Circuit Diagram
• How to Create a Basic Electrical Diagram
• Basic Electrical Symbols and Their Usage
• Electrical Drawing Software
• What is a Mind Map
• How to Create A Mind Map on Microsoft Word
• Mind Map Examples & Templates
• Free Mind Map Software
• What is an Organizational Chart
• How to Create an Org Chart
• Basic Organizational Chart Symbols
• Free Org Chart Templates
• Organizational Chart Software
• What is a P&ID
• How to Read P&ID
• How to Create a P&ID Drawing
• P&ID Symbol Legend
• P&ID Software
• What is a Gantt Chart
• What is a Milestone in a Gantt Chart
• How to Make a Gantt Chart
• Gantt Chart Examples
• Gantt Chart Symbols
• Gantt Chart Maker
• What is an Infographic
• 50+ Editable Infographic Templates
• How to Make an Infographic
• 7 Easy Tips to Make Your Infographics Stand Out
• Infographic Maker
• Diagram Center

Explain Algorithm and Flowchart with Examples

The algorithm and flowchart are two types of tools to explain the process of a program. In this page, we discuss the differences between an algorithm and a flowchart and how to create a flowchart to illustrate the algorithm visually. Algorithms and flowcharts are two different tools that are helpful for creating new programs, especially in computer programming. An algorithm is a step-by-step analysis of the process, while a flowchart explains the steps of a program in a graphical way.

In this article

Definition of algorithm, definition of flowchart, difference between algorithm and flowchart.

• Recursive Algorithm
• Divide and Conquer Algorithm
• Dynamic Programming Algorithm
• Greedy Algorithm
• Brute Force Algorithm
• Backtracking Algorithm

Use Flowcharts to Represent Algorithms

Writing a logical step-by-step method to solve the problem is called the algorithm . In other words, an algorithm is a procedure for solving problems. In order to solve a mathematical or computer problem, this is the first step in the process.

An algorithm includes calculations, reasoning, and data processing. Algorithms can be presented by natural languages, pseudocode, and flowcharts, etc.

A flowchart is the graphical or pictorial representation of an algorithm with the help of different symbols, shapes, and arrows to demonstrate a process or a program. With algorithms, we can easily understand a program. The main purpose of using a flowchart is to analyze different methods. Several standard symbols are applied in a flowchart:

The symbols above represent different parts of a flowchart. The process in a flowchart can be expressed through boxes and arrows with different sizes and colors. In a flowchart, we can easily highlight certain elements and the relationships between each part.

During the reading of this article, if you find an icon type picture that you are interested in, you can download EdrawMax products to discover more or experience creating a free diagram of your own. All drawings are from EdrawMax .

If you compare a flowchart to a movie, then an algorithm is the story of that movie. In other words, an algorithm is the core of a flowchart . Actually, in the field of computer programming, there are many differences between algorithm and flowchart regarding various aspects, such as the accuracy, the way they display, and the way people feel about them. Below is a table illustrating the differences between them in detail.

• It is a procedure for solving problems.
• The process is shown in step-by-step instruction.
• It is complex and difficult to understand.
• It is convenient to debug errors.
• The solution is showcased in natural language.
• It is somewhat easier to solve complex problem.
• It costs more time to create an algorithm.
• It is a graphic representation of a process.
• The process is shown in block-by-block information diagram.
• It is intuitive and easy to understand.
• It is hard to debug errors.
• The solution is showcased in pictorial format.
• It is hard to solve complex problem.
• It costs less time to create a flowchart.

EdrawMax provides beginners and pros the cutting-edge functionalities to build professional-looking diagrams easier, faster, and cheaper! It allows you to create more than 280 types of diagrams and should be an excellent Visio alternative.

Types of Algorithm

It is not surprising that algorithms are widely used in computer programming. However, it can be applied to solving mathematical problems and even in everyday life. Here comes a question: how many types of algorithms? According to Dr. Christoph Koutschan, a computer scientist working at the Research Institute for Symbolic Computation (RISC) in Austria, he has surveyed voting for the important types of algorithms. As a result, he has listed 32 crucial algorithms in computer science. Despite the complexity of algorithms, we can generally divide algorithms into six fundamental types based on their function.

#1 Recursive Algorithm

It refers to a way to solve problems by repeatedly breaking down the problem into sub-problems of the same kind. The classic example of using a recursive algorithm to solve problems is the Tower of Hanoi.

#2 Divide and Conquer Algorithm

Traditionally, the divide and conquer algorithm consists of two parts: 1. breaking down a problem into some smaller independent sub-problems of the same type; 2. finding the final solution of the original issues after solving these more minor problems separately. The key points of the divide and conquer algorithm are:

• If you can find the repeated sub-problems and the loop substructure of the original problem, you may quickly turn the original problem into a small, simple issue.
• Try to break down the whole solution into various steps (different steps need different solutions) to make the process easier.
• Are sub-problems easy to solve? If not, the original problem may cost lots of time.

#3 Dynamic Programming Algorithm

Developed by Richard Bellman in the 1950s, the dynamic programming algorithm is generally used for optimization problems. In this type of algorithm, past results are collected for future use. Like the divide and conquer algorithm, a dynamic programming algorithm simplifies a complex problem by breaking it down into some simple sub-problems. However, the most significant difference between them is that the latter requires overlapping sub-problems, while the former doesn’t need to.

#4 Greedy Algorithm

This is another way of solving optimization problems – greedy algorithm. It refers to always finding the best solution in every step instead of considering the overall optimality. That is to say, what he has done is just at a local optimum. Due to the limitations of the greedy algorithm, it has to be noted that the key to choosing a greedy algorithm is whether to consider any consequences in the future.

#5 Brute Force Algorithm

The brute force algorithm is a simple and straightforward solution to the problem, generally based on the description of the problem and the definition of the concept involved. You can also use "just do it!" to describe the strategy of brute force. In short, a brute force algorithm is considered as one of the simplest algorithms, which iterates all possibilities and ends up with a satisfactory solution.

#6 Backtracking Algorithm

Based on a depth-first recursive search, the backtracking algorithm focusing on finding the solution to the problem during the enumeration-like searching process. When it cannot satisfy the condition, it will return "backtracking" and tries another path. It is suitable for solving large and complicated problems, which gains the reputation of the "general solution method". One of the most famous backtracking algorithm example it the eight queens puzzle.

Now that we have learned the definitions of algorithm and flowchart, how can we use a flowchart to represent an algorithm? To create an algorithm flowchart, we need to use a handy diagramming tool like EdrawMax to finish the work.

Algorithms are mainly used for mathematical and computer programs, whilst flowcharts can be used to describe all sorts of processes: business, educational, personal, and algorithms. So flowcharts are often used as a program planning tool to organize the program's step-by-step process visually. Here are some examples:

Example 1: Print 1 to 20:

• Step 1: Initialize X as 0,
• Step 2: Increment X by 1,
• Step 3: Print X,
• Step 4: If X is less than 20 then go back to step 2.

Example 2: Convert Temperature from Fahrenheit (℉) to Celsius (℃)

• Step 1: Read temperature in Fahrenheit,
• Step 2: Calculate temperature with formula C=5/9*(F-32),
• Step 3: Print C.

Example 3: Determine Whether A Student Passed the Exam or Not:

• Step 1: Input grades of 4 courses M1, M2, M3 and M4,
• Step 2: Calculate the average grade with formula "Grade=(M1+M2+M3+M4)/4"
• Step 3: If the average grade is less than 60, print "FAIL", else print "PASS".

From the above, we can come to the conclusion that a flowchart is a pictorial representation of an algorithm, an algorithm can be expressed and analyzed through a flowchart. An algorithm shows you every step of reaching the final solution, while a flowchart shows you how to carry out the process by connecting each step. An algorithm uses mainly words to describe the steps while you can create a flowchart with flowchart symbols to make the process more logical.

You May Also Like

Related articles