mistakes 2

Question 1

linear s

Answer 1

Compare the search item with the first value
* ….then compare the search item with the next value
* ….repeat the above process until either
* ….the end of the array has been reached or
* ….the search item is found and then stop
* ….then return the array position // return -1 / False if not found

Question 2

by value vs by reference

Answer 2

By reference the function receives the memory location of the data
* By value the function receives a copy of the variable

• By reference will make changes to the original variable
• By value will make changes to the copy of the variable
• By reference will overwrite data in the original variable
• By value will not overwrite the data in the original variable
• By reference will keep the changes after the function ends
• By value will not keep the changes after the function ends

Question 3

define local and global

Answer 3

Local variables:
* Scope within the module defined
within
* Cannot access externally unless
passed as parameter, or returned
from function
* When module is exited, memory of
variable is freed

Global variables:
* Scope within the entire program
* Can access from anywhere
* Retained in memory permanently
ByRef Points to location of variable
ByVal Sends the value

Question 4

Local adv + dis

Answer 4

need to be passed as parameters
byreference

Can send ByVal – but not always
possible with arrays in some
languages

Modules are self contained and then
can be reused in other programs he
wants to create without needing to
take the global variables with them

+ve Local = memory efficient
-ve Local = more difficult to
trace/debug/follow where the values
are passed

Question 5

Global adv + dis

Answer 5

can be accessed from all modules by direct reference
might not be memory intensive,
unlikely anyone else is going to
access/amend e.g. use as a library –
therefore global would not waste
significant resources

Benefits:
* 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
easier programming,
simpler to follow, easier to debug

Drawback:
* 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.
memory inefficient, not
good programming technique

Question 6

IDE writing

Answer 6

• Auto-complete
• Start typing an identifier/command and it fills in the rest
• Auto-indent
• Indents code automatically within structures to avoid errors
• syntax highlighting
• Shows which commands are correct // help identify key elements

autocorrect - Tell you when you make a syntax error

Question 7

IDE testing

Answer 7

• Breakpoints
• Stop the program running at a set point to check variables
• Variable watch window
• Display the values of the variables while the program is run
• Stepping
• Run one line at a time and check variables

Unit Testing
* Automated tests to be run to check changes ensure changes haven’t introduced errors.

Question 8

IDE debugging

Answer 8

Underlines syntax errors dynamically
 Can be corrected before running // saves times

 Watch window
 View how variables change during running of the program
 Break points
 Stop the program at set points to check the values of variables

 Error message list
 Tells you where errors are and suggests corrections

 Step-mode
 Executes program one statement at a time to watch variable values and program pathways

 Traces
 Print-outs of variable values for each statement execution within a program

 Crash-dump/post-mortem routine
 Shows the state of variables where an error occurs

 Stack contents
 Shows sequencing through procedures/modules

 Cross-referencers
 Identifies where variables/constants are used in a
program to avoid duplications

Question 9

Reusable components

Answer 9

Saves time from having to write the same algorithm repeatedly
* Reduced testing requirements
* Can be taken and used in different programs as well as the program they are
written in // can be used in a program library

Question 10

Breadth?

Answer 10

takes first value then visits all
nodes connected to it. It then takes all
nodes connected to those nodes.

more efficient when the data
searched for is closer to the root

Question 11

Depth?

Answer 11

note same as post order
left node, this
becomes a new tree. It continues going to
the left until a leaf. It then returns this, then
goes right and repeats from the start. Follow
left, follow right, take root.

Question 12

breath vs depth

Answer 12

Breadth is more efficient when the data
searched for is closer to the root.
* Depth is more efficient when data to be
search for is further down.
* Depth memory requirement is linear
* Depth can be written recursively to aid
understanding.
* Breadth in general is better time complexity
* In large trees depth may never return a
value

Question 13

why use array instead of separate v?

Answer 13

all values can be indexed in one
array
* The numbers can be passed as a single parameter
* Does not need 50 variables to be declared/passed

Question 14

Merge vs bubble vs insertion vs quick

Answer 14

Merge sort splits data into individual lists and merges
* Insertion makes first value sorted list, then inserts each item into the sorted list
* Bubble sort looks through each item in turn, number of items times

Merge uses more memory as new lists are needed. Insertion and Bubble need constant memory.
Quick increases not as much as merge

Best time:
* Bubble and Insertion have the best times, both O(n) because they run through data once. (increase at same rate as # elements)
Quick and merge increase at greater rate merge sort requires a minimum number of stages so best case is longer (O(n log(n))
* Merge average is the same as best.
Insertion and Bubble has average o(n^2).

Worst time: insertion and quick increase significantly by n for each additional item. O(n^2) for bubble + insertion
Merge sort increases less per
element - same number of stages
are needed.

Question 15

When use bubble, merge, insertion, quick?

Answer 15

small number - bubble or insertion as no further space needed and tc small

merge may not need lots of memory too but timewise theyre all similar ish as small number - space not imp tho

large
Log more appropriate for large number
of elements
but memory imp although logarithmic more appropriate

Question 16

Differences bet reality and simulation

Answer 16

Removal of visual elements such as buildings on the ground
* Simplification of controls
* Focus on important elements such as weather, height, speed

Question 17

Why abstract?

Answer 17

Reduce memory requirements
* Reduce processing requirements
* Simplify the problem being solved
 Reduces complexity of design
 Reduces complexity of programming
 Could involve a large number of images that would take
excessive memory
 Reality contains things that aren’t relevant to a computer program

Question 18

How use caching?

Answer 18

Store data that has been used in cache/RAM in case needed again

Question 19

Directed vs undirected

Answer 19

ARCS/EDGES in 1 direction for directed

Question 20

Graph vs tree

Answer 20

Graphs:
multiple paths
no (clear) root node
weighted (can be)
loops/cycles
bi-directional

tree has hierarchy

Both:
nodes, connected by edges, non-linear DS, dynamic

Question 21

Visualisation

Answer 21

benefit humans rather than computers
present the information in a simpler form to understand
best explain complex situations

symbols

edges for physical connections bet addresses not actual physical routes

Question 22

D vs A*

Answer 22

both pathfinding algos to find shortest route
A* is (usually) more efficient // dijkstra’s is (usually) slower
* A* uses heuristics to find a solution faster // Dijkstra’s does not use heuristics

Question 23

Performance modelling?

Answer 23

Simulate/model behaviour of the system (before it is) used under load
* Because it would be too expensive/unsafe/time critical to test the real system

Test with large and small values
* Model how well the system scales with increasing use

Question 24

recursive func

Answer 24

A function that calls itself // a function that is defined in terms of itself
* …has a base case (that terminates the recursion)

Question 25

use array for queue?

Answer 25

* Queue has head pointer and tail pointer * When an item is enqueued the tail pointer increments * When an item is dequeued the head pointer increments

Question 26

Describe OOP

Answer 26

defines an object as an independent entity defines the attributes of the object and the methods that can be applied to it attributes could be private to restrict accidental changes Many instances of can then be declared in the main program without having to re-write all of the declarations reduces amount of code needed fewer errors are likely as code is written once and used multiple times reduce mistakes because the subroutines are self-contained

Question 27

Describe procedural

Answer 27

statements are executed in the order they are written Procedural will need each queue to be declared individually * Procedural will need to make use of subroutines where the queue will need to be sent and returned each time. have to write separate code for each new need to make sure the correct values are passed and returned, or global variables may be required which uses excess memory.

Question 28

how abstract?

Answer 28

remove unnecessary details No actual images shown  Items are named / labelled  Simplified layout with shapes e.g. simplify real life - remove complexity from realistic entities represent _ with specific objects/shapes remove outside world remove character features - unneeded if tree: represent _ w vertices state represented by letter - tree doesn't show details

Question 29

Application of concurrent p?

Answer 29

* Multiple requests to the server can be made at the same time * Programming on server will need to allow multiple threads to manipulate a list of requests * Programming will need to restrict access to the database of seats/sales etc. * Will allow those reading and writing to manipulate at the same time * Record locking will need implementing – more complex programming * May be selling alongside other systems, therefore needs to communicate with external systems that will also use record locking to avoid two different external companies accessing and selling the same tickets. * Will allow for multiple access to the website at the same time by different customers – as it would happen in real life multiple ticket sales for the same event without selling the same seat twice

Question 30

concurrent p?

Answer 30

Multiple processes being executed at the same time // appearing to happen simultaneously * Giving processes a slice of the processor time * Having multiple processors each carrying out a different process * One process may need to start before a second has finished * Individual processes are threads, each thread has a life line * One request will be sent to the server, this will have a thread

Question 31

heuristics?

Answer 31

rule of thumb/estimate estimates distance/cost from each node to destination n speeds up finding solution as identify which paths first follow h approach: Rule of thumb/educated guess approach (1 – AO1.1) which is used when unfeasible to analyse all eventualities (1 – AO1.1).  This leads to a “good enough” result (1 – AO1.2) although it is not 100% reliable

Question 32

Data m - what is it

Answer 32

searches large amounts of data * Searches for relationships between facts/components/events that may not be obvious * May include pattern matching algorithms * May involve anomaly detection algorithms * Used for business modelling * Used to plan for future eventualities

Question 33

Data m examples/application

Answer 33

* Can look for how people use the website e.g. visiting times, what they click on, how long they spend on certain features, what they do first, which elements are used least * Give recommendations for future changes to the game e.g. features to add, or remove * Can use to introduce new features * Increase use from users * Increase revenue by selling features used more often * Make the game more appealing * Remove features people don’t use * Use to target advertising * Privacy concerns from users * Misuse of information

Question 34

Quick sort

Answer 34

Choose a pivot // identify start and end pointers * Compare each element to the pivot… // compare start and end pointers * Put items < pivot in the left sublist * Put items > pivot in the right sublist * Choose a pivot in each sublist * If start pointer is larger than end pointer… * …then swap data items around * And repeat the process until each item becomes a pivot

Question 35

Why is quicksort divide and conquer

Answer 35

decomposing data sets into smaller subsets * and then sorting each split subset * until each subset is sorted * and then combining the subsets to provide a solution

Question 36

What IDE why?

Answer 36

software that includes an editor, compiler, run-time environment Allows you to write and run the code in one piece of software * Suggests code so you don’t have to remember code, autocorrect spelling * Helps you trace the program so you can see what happens when values change without having to manually insert print statements * Autogenerate boilerplate code. * Reduce errors through autocorrect + suggestions * Reduce time to write the program because features help you spot errors before running code, some errors will be corrected so you don’t have to * Write and test in one environment so you don’t have to close and run elsewhere, then re-open etc.

Question 37

constructor?

Answer 37

create instance of object from class

Question 38

inheritance

Answer 38

child class takes on attributes/methods from parent class

Question 39

pipelining?

Answer 39

Reduces/removes latency * … CPU is not idle while waiting for next instruction * Next instruction is fetched while current one is decoded/executed * All parts of the processor can be used at any instance in time

Question 40

procedure of enqueue?

Answer 40

Check if the queue is full * … if the firstElement pointer (+1) = lastElement * … if it is return False * Adds element at lastElement (+1) position * … increments lastElement pointer * If lastElement is greater than last Index // pointer becomes pointer MOD array.size * …reset to 0

Question 41

Why decompose?

Answer 41

Splits the problem into smaller sub p * Smaller problems are more manageable & easier to solve * To see where code can be reused in the solution * To split tasks between different programmers - division lead to logical div bet programmers + dev of modules/subroutines (repeated d - gives solvable parts) Good as work concurrently on diff parts

Question 42

Why decompose?

Answer 42

Splits the problem into smaller chunks * Smaller problems are more manageable & easier to solve * To see where code can be reused in the solution * To split tasks between different programmers

Question 43

Why not binary search tree?

Answer 43

more than 2 connections nodes aren't ORDERED

Question 44

delete node from tree?

Answer 44

search tree to find nodes location replace content of node w null make node pointing to this point to one after add new node to empty node list

Question 45

add node?

Answer 45

search tree to find node adding after create new node w value _ add pointer from prev to point to it make new node null point to null

Question 46

recursion vs iteration

Answer 46

Recursion uses more memory… as declares new variables //variables are put onto the stack each time… * can run out of memory/stack space… * ...iteration reuses the same variables - cannot run out of memory * Recursion can express a problem more elegantly // in fewer lines of code… * iteration can take more lines of code // be harder to understand * Recursion will be self-referential // will call itself… * … whereas iteration does not

Question 47

why pass array by reference and not value?

Answer 47

By reference will change the actual contents of the array in the main program// when control returns to the main program the array will be sorted * By value would create a copy and not change the original // when control returns to the main program the array will not be sorted * By value the array is local to the func reference uses less memory

Question 48

bubble sort?

Answer 48

Compare each pair of adjacent elements * If they are not in the correct order then swap the elements * If they are in the correct order then do no swap elements * When you read the end of the array return to the start * Repeat n elements time * Set a flag to be false whenever a swap is made * …repeat the loop if the flag is not false

Question 49

implement queue to circular w pointers?

Answer 49

* Check if either head or tail are incremented to above 99 * … set to be 0 instead * When checking if array is full check if (queueTail == queueHead – 1) OR (queueTail==99 AND queueHead==0)

Question 50

add priorities to queue?

Answer 50

Use a different structure e.g. a linked list * …items can be added at different points in the linked list depending on priority * …by changing the pointers to items needing priority * Have different queues for different priorities * …add the job to the queue relevant to its priority * …print all the jobs in the highest priority queue first

Question 51

Set vs get method

Answer 51

A get method allows the attribute to be accessed / returned * A set method allows the attribute to be changed (with parameters)

Question 52

iteration vs recursion?

Answer 52

Benefit:  The program can/might run faster  Cannot run out of stack space/memory  Easier to trace/follow Drawback:  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 53

Set vs get method

Answer 53

A get method allows the attribute to be accessed / returned * A set method allows the attribute to be changed (with parameters)

Question 54

insertion use less memory than merge?

Answer 54

erge sort might create a new array each time it splits and merges / often implemented recursively which places additional data on the stack  Insertion sort does not use any additional arrays//Insertion sort is an in-place algorithm.

Question 55

data input?

Answer 55

number, name, location, dimensions of things

Question 56

recognition

Answer 56

identify problem to be solved

Question 57

data mining

Answer 57

Turning large quantities of data into useful information / Finding patterns within large quantities of information e.g. customer trends, profitable items involves searching through unconnected data (1), pattern matching (1) and calculation of correlation (1). There may be no predetermined matching criteria (1); a brute force approach is possible with high speed computers

Question 58

performance modelling

Answer 58

simulate/test behaviour of system before used e.g. stress testing - large customers or orders

Question 59

reusbale c

Answer 59

the components can be used in a future programs + already tested  they do not need to be rewritten / saves time

Question 60

record vs class

Answer 60

Record is a data structure…  …A class is a template for making data structures (objects)  Class also has methods (which describes functionality)  Both store data of different types  Which can be accessed by their names  But classes can make them accessible via methods  Both can have multiple ‘instances’  Class can include visibility of properties / private

Question 61

record vs class

Answer 61

Record is a data structure…  …A class is a template for making data structures (objects)  Class also has methods (which describes functionality)  Both store data of different types  Which can be accessed by their names  But classes can make them accessible via methods  Both can have multiple ‘instances’  Class can include visibility of properties / private

Question 62

how do private attributes improve data integrity

Answer 62

Properties (are encapsulated) and can only be accessed through their methods  Enforce validation through the method // inappropriate data can be caught before entered  Cannot be changed/accessed accidentally

Question 63

ensure items and queue exists when the program is run next time?

Answer 63

Store the items and queue to an external file (when the program closes)  Load the items and queue from the file when it starts

Question 64

depth vs breadth

Answer 64

Depth first advantage:  Depth first requires less memory than breadth first search (1). It is quicker if you are looking at deep parts of the tree (1). Depth first disadvantage:  Depth first isn’t guaranteed to find the quickest solution (1) and possibly may never find the solution (1) if we don’t take precautions not to revisit previously visited states

Question 65

why is big o estimate?

Answer 65

Big O notation shows the limiting behaviour of an algorithm (to classify its complexity) (1).  Other processes may be taking up some of the processor time