OCR A-Level Computer Science Programming and computational thinking overview quiz quiz

removing or hiding detail that is not relevant to the problem

adding in as much fine-grained detail about the problem as is possible

breaking a single problem down into many separate sub-problems

running several different tasks at exactly the same time

hiding how a complicated process actually works behind a single name

breaking a large problem into smaller, more manageable sub-problems

storing previously computed results in order to avoid recomputation

estimating how long an algorithm will take to run on large inputs

It encrypts data as it travels in transit across the whole network

It removes the base case so that a recursive routine can keep on going indefinitely

It stores results so they can be reused without recomputing or refetching

It sorts a list of values in place without using extra memory

trying every possible combination of options all at the same instant

always greedily choosing whichever option happens to be nearest

ignoring all of the constraints of the problem entirely and simply accepting the very first result that happens to be found

exploring options step by step and returning to the last decision when a path fails

finding the exact best solution is computationally infeasible in reasonable time

an exact optimal solution is always quick and easy to compute for absolutely every possible input

the problem being solved happens to have no inputs of any kind at all

recursion is not allowed by the chosen programming language being used

runs several different instructions at the exact same physical instant

rapidly switches between tasks so they only appear simultaneous

always requires multiple processor cores in order to function at all

is exactly the same thing as genuine true parallel processing

A count-controlled (for) loop running a fixed number of times

A simple sequence of statements with no repetition

A condition-controlled (while) loop

A constructor method that initialises a new object

a global variable shared across the whole program

a count-controlled loop that repeats a fixed number of times

a public attribute that other classes can read

a base case that stops the recursion

the variable's memory address is sent, so changes affect the caller's original

a separate copy of the data is sent across, so the original stays unchanged

the parameter is read-only and so it can never be changed inside the subroutine

the subroutine returns no value at all back to the code that called it

is accessible from anywhere throughout the entire program at any time

exists only within the subroutine in which it is declared

is always guaranteed to run faster than any global variable

is unable to hold a numeric value of any kind whatsoever

deletes an existing object and frees up the memory it was using

is a private attribute that stores the internal state of the object

is run when an object is instantiated, initialising its attributes

overrides an inherited method defined in the parent superclass

run the exact same fixed identical code for every single object in turn

ignore the objects' types entirely and then fail with an error

delete the superclass that all of the objects inherit from

run the version appropriate to each object's actual class