2.2.1 - programming techniques

Question 1

algorithm

Answer 1

A set of rules or a sequence of steps specifying how to solve a problem.

Question 2

variables

Answer 2

Identifiers (names} given to memory locations whose contents will change during the course of the program.

Question 3

2 reasons why variable names should be standardised

Answer 3

• makes the program easy to follow and update when required.
• leaves less room for errors and
  inconsistencies in the names in a large program

Question 4

3 basic programming constructs

Answer 4

• sequence
• selection
• iteration

Question 5

define sequence

Answer 5

just two or more statements executed one after the other

Question 6

define selection

Answer 6

used to select which statement will be executed next, depending on some
condition

Question 7

iteration

Answer 7

involves performing a
loop in the program to repeat a number of statements

Question 8

3 types of loops

Answer 8

• while…endwhile
• repeat…until
• for…next

Question 9

integrated development environment (IDE)

Answer 9

A single program used for developing programs made from a number of components.

Question 10

compiler/ interpretor

Answer 10

Translates high level code into machine code.

Question 11

3 IDE tools to spot logic errors

Answer 11

• breakpoint
• watch
• step through

Question 12

subroutine

Answer 12

A named block of code which performs a specific task within a program.

Question 13

2 types of subroutines

Answer 13

• functions
• procedures

Question 14

function

Answer 14

A named section of a program that performs a specific task. Returns a value.

Question 15

procedure

Answer 15

Performs a task but doesn’t return a value.

Question 16

by value

Answer 16

A copy of the variable is passed to the subroutine. Changing a parameter inside the subroutine will not affect its value outside the subroutine.

Question 17

by reference

Answer 17

The memory location of the variable is passed to the subroutine. If it is changed in the subroutine, its value in the main program will also change.

Question 18

global variables

Answer 18

Declared in the main program and can be used anywhere in the program, including subroutines.

Question 19

local variables

Answer 19

Can be used within the subroutine and exist only during the execution of the subroutine. Cannot be accessed outside the subroutine.

Question 20

modular programming

Answer 20

The process of subdividing a computer program into separate sub-programs.

Question 21

advantages of subroutines

Answer 21

• Small so relatively easy to understand, debug and maintain.
• Can be tested independently.
• Can be reused indifferent programs or parts of the same program.
• Programmers can work on different subroutines.
• A large project becomes easier to monitor and control.

Question 22

2 searching algorithms

Answer 22

• linear search
• binary search

Question 23

linear search pseudocode

Answer 23

function LinearSearch(alist,itemSought}
index = -1
i = 0
found = False
while i < length(alist) and found = False
if alist[iI = itemSought then
index = i
found = True
endif
i = i + 1
endwhile
return index
endfunction

Question 24

linear search

Answer 24

If the items are not in any particular sequence, the data items have to be searched one by one until the required one is found or the end of the list is reached.

Question 25

binary search

Answer 25

The algorithm works by repeatedly dividing in half the portion of the SORTED data list that could contain the required data item. This is continued until there is only one item in the list.

Question 26

binary search pseudocode

Answer 26

function binarySearch(aList, itemSought} found = False index = -1 first = C last = len (aList)-1 while first <= last and found = False midpoint = Integer part of ((first + last)/2) if aList[midpoint) = itemSought then found = True index = midpoint else if aList(midpoint) < itemSought then first = midpoint + l else last = midpoint - i endif endif endwhile return index endfunction

Question 27

bubble sort

Answer 27

* Go through the array, comparing each item with the one next to it. If it is greater, swap them. * The last element of the array will be in the correct place after the first pass * Repeat n-2 times, reducing by one on each pass the number of elements to be examined

Question 28

bubble sort pseudocode

Answer 28

numItems = len(numbers) for i = 0 to numItems - 2 for j = 0 to(numItems - i - 2) if numbers [j] > numbers [j + 1] temp = numbers[j] numbers [ j ] = numbers[ j + 1] numbers [j+1] = temp endif next j print (numbers) next i

Question 29

insertion sort

Answer 29

The algorithm takes one data item from the list and places It in the correct location in the list. This process is repeated until there are no more unsorted data items in the list.

Question 30

insertion sort pseudocode

Answer 30

procedure inaertionSort(alist) n = len(alist) for index = 1 to n - 1 currentvalue = alist[index] position = index while position > 0 and alist[position - l| > currentvalue alist(position] = alist[position - 1] position = position - l endwhile alist(position) = currentvalue next index endprocedure

Question 31

breakpoint

Answer 31

Allows the program to be stopped at a predetermined point in order to inspect its state.

Question 32

step-through

Answer 32

Allows the programmer to watch the effects of each line of code.

Question 33

watch

Answer 33

Code can be examined as it is running which allows logical errors to be pinpointed.

Question 34

crash dump

Answer 34

Shows the state of variables at the point where an error occurs.

Question 35

disadvantages of global variables

Answer 35

- they make it difficult to integrate modules - they increase the complexity of a program - may cause conflicts with names in other modules - may be inadvertently changed when a program is complex

Question 36

Why is parameter passing to a function a better alternative to global variables?

Answer 36

Only a copy of the data passed may be changed so no unforeseen errors will occur in other modules.

Question 37

recursion

Answer 37

When a function calls itself from within the function.

Question 38

parameter

Answer 38

An item of data passed into a subroutine when it is called that is used as a variable in the subroutine.

Question 39

procedural programming language

Answer 39

A high-level language that gives a series of instructions in a logical order.

Question 40

scope

Answer 40

A procedure that the variable is valid for.

Question 41

scope in relation to global and local variables

Answer 41

A local variable takes precedence over a global variable of the same name.

Question 42

4 similarities between graphs and trees

Answer 42

* Both consists of nodes * Both are connected by edges/links * Both are non-linear data structures * Both are dynamic data structures

Question 43

4 differences between graphs and trees

Answer 43

* Tree is 1-directional whereas a graph is 2-directional * Tree has a root node whereas a graph does not have a (clear) root node * Tree will not have cycles whereas graphs can contain cycles * Tree will not be weighted whereas edges in a graph can be weighted

Question 44

Explain the difference between branching and iteration.

Answer 44

 Branching decides which code is run / only runs code once  Iteration repeatedly runs the same code in the same sequence

Question 45

benefits of using iteration instead of recursion

Answer 45

 The program can/might run faster  Cannot run out of stack space/memory  Easier to trace/follow

Question 46

disadvantages of using iteration instead of recursion

Answer 46

 Iteration can lead to lengthier code  Iteration can lead to code that looks more complex / is harder to understand  some problems are more elegantly coded with a recursive solution

Question 47

Why are reusable components used in programs?

Answer 47

* One piece of code can be used many times / in multiple places / makes code more efficient * No need to write the same code multiple times * Takes less time to plan/design/code the program * Easier error detection as fix once and it corrects in each place // less likely to have errors as code is not written multiple times * Makes it easier to maintain the program

Question 48

syntax highlighting

Answer 48

to identify key words, variables and help identify syntax errors

Question 49

auto-complete

Answer 49

start typing a command/identifier and it completes it

Question 50

benefits of oop rather than procedural

Answer 50

* Code can easily be reused… * …classes can be used in other programs * …inheritance can be to extend upon existing classes * …as a class can be based on an existing class * Easier to maintain…. * ….as classes can be modified or extended * …debugging can be easier as encapsulation limits how attibutes are changed. * Code can be more secure… * … as access to attributes can be restricted to being via methods. * Better for coding as part of a team… * …as classes can be distributed between team members.

Question 51

disadvantages of global instead of local

Answer 51

* Increases memory usage (as it is used until full program execution is over) * Alterations within the function may have unwanted side effects elsewhere in the program.

Question 52

advantages of global instead of local

Answer 52

* Variable doesn’t need passing as a parameter (byref) * You don’t need to return a value * Can be accessed from any function / anywhere in the program

Question 53

state one way directed graph different from undirected

Answer 53

In directed arcs/edges may only go in 1 direction

Question 54

difference between do and while loop

Answer 54

* While loop will check the condition at the start of the loop // pre-condition loop * Do loop will check the condition at the end of the loop // post-condition * The code in a while loop may never run (if the condition is already met) * The code in a do loop will always run at least one.