Pseudocode is a design methodology that uses structured written language to show the design of the program.
Although there are no formal rules for Pseudocode, in Coltness we use the following rules.
This weeks task is to solve the maze. You are not allowed to touch the black lines.
You can use any Python Turtle commands you want including
Save the image as maze.png and use the boilerplate code below in Thonny to start the task.
# Solve the maze
# Mr Stratton
# 7/6/19
from turtle import *
# Help here https://docs.python.org/3/library/turtle.html
setup(1000,600) # set the window size to 480x360 pixels
bgcolor('yellow') # set BG to yellow
bgpic("maze.png") # BG pic only works with PNG and GIF
title("Mr. Stratton's Maze Tutorial") # Title of window
color("red") # Colour line
# shape("arrow") # Shape of the turtle (“arrow”, “turtle”, “circle”, “square”, “triangle”, “classic”)
turtlesize(3) # size of turtle (easier for some kids to see)
pensize(3) # Set the size of the pen
penup()
goto(-420,220)
pendown()
# vvvvvv Enter your code below here vvvvvv
After you have solved the maze answer these questions:
Save a new copy of the program and edit it to make it more efficient (fewer lines). The number of extra lines that my program needed is below.
Describe the role of firewalls.
Describe the use made of encryption in electronic communications.
Describe the purpose of the basic computer architecture components and how they are linked together:
Processor
Memory locations with unique addresses
Buses
Explain the need for interpreters and compilers to translate high-level program code to binary.
Describe and exemplify the use of binary to represent positive integers.
Convert from binary to denary and vice-versa.
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
| 0 | 0 | 1 | 0 | 0 | 1 | 0 | 1 |
Describe floating point representation of positive real numbers using the terms mantissa and exponent.
Describe extended ASCII code (8-bit) used to represent characters.
Describe the vector graphics method of graphic representation for common objects:
Describe the bit-mapped method of graphics representation.
Thanks to Mr. M. Hay for collating these
Describe the energy use of computer systems, the implications on the environment
and how these could be reduced through:
The count occurrences algorithm is very similar to the linear search v1. However, it includes an incrementing counter keep track of how many items it finds.
def countOcc(target,numbers):
#Count the number of times target is found in numbers
count=0
for number in numbers:
if number==target:
count=count+1
return count
You will notice that I have used a FOR EACH in this example as there is no requirement to track the position of the elements. This algorithm can also be used to count how many numbers are above or below a target value by simply changing the operator in the IF statment.
We spent a lot of last week on Standard Algorithms, most of them have the structure of an IF inside a FOR loop. While it is possible to use a FOR EACH loop this would mean that we could not know what the position was of the value we were searching for. In the examples below the returned value (max or min) could be changed to the position to allow this to be used elsewhere in the program.
To find the largest number in an array we would use the “Find Maximum” algorithm
def findMax(numbers):
# Find biggest number
max=numbers[0]
for counter in range(1,len(numbers)):
if numbers[counter]>max:
max=numbers[counter]
#position=counter
return max
To find the smallest number in an array we would use the “Find Minimum” algorithm
def findMin(numbers):
#Find smallest number
min=numbers[0]
for counter in range(1,len(numbers)):
if numbers[counter]<min:
min=numbers[counter]
#position=counter
return min
Notice that both of these functions are very similar with only the operator changing. Did you also notice that the for loop starts from index 1? Why do you think this is?
A linear search is used to check if a value is in an array. There are two ways of doing this:-
Check every value in the list, even if you find the value immediatly.
def linSearchV1(target,numbers):
#Search for target in all of the numbers
found=False
for counter in range(len(numbers)):
if numbers[counter]==target:
found=True
return found
Check until you find the value you are looking for, this is much more effient and can on average half the ammount of time taken for the program to run.
def linSearchV2(target,numbers):
#Search for the target numbers until it is found
counter=0
found=False
while not found and counter!=len(numbers):
if numbers[counter]==target:
found=True
else:
counter=counter+1
return found
The same algorithms can be used to find a string in an array of strings or a character in a string.
