Computational Thinking I
This process involves stripping away irrelevant details and focusing only on the essential characteristics needed to solve a problem.
What is abstraction?
Before writing a program to process a file, ensuring that the file actually exists on the system is an example of identifying this.
What is a precondition?
These are the data fields or variables defined within a class that represent the state or characteristics of an object.
What are attributes?
While time complexity measures the execution time of an algorithm, this metric evaluates the amount of memory an algorithm requires as the input size grows.
What is space complexity?
This fundamental control structure ensures instructions are executed precisely one after the other in the exact order they are written.
What is sequence?
This programming strategy saves time by storing previously calculated results in a temporary, high-speed storage layer so future requests can be served faster.
What is caching?
This element of computational thinking requires a programmer to break down a complex problem into smaller, manageable sub-procedures.
What is decomposition/thinking procedurally?)
Represented by methods or functions within a class, this defines the actions or operations that an object can perform.
What are behaviours?
An algorithm that processes a 1D array by visiting each element exactly once has this specific type of time complexity, denoted as O(n).
What is linear complexity?
Consider the following Python function:
def check_value(x):
----if x > 10:
--------print("High")
----else:
--------print("Low")
This code demonstrates this specific control structure used to determine it's output based on a condition.
What is selection/branching?
In an algorithm, this specific point determines which path the program execution will take next, typically represented by an IF statement.
What is a decision point/selection statement?)
This is the process of establishing the exact sequence of instructions and identifying which operations depend on previous ones to achieve the final outcome.
What is determining the order of steps?
This OOP principle restricts direct access to an object's data by bundling attributes and methods together, often using private access modifiers and public getters/setters.
What is encapsulation?
This highly efficient time complexity, denoted as O(\log n), is characteristic of algorithms like a binary search, where the problem size is halved with each step.
What is logarithmic complexity?
These variables are declared inside a specific function or subroutine, can only be accessed within that function, and are destroyed once the function finishes executing.
What are local variables?
This type of processing involves executing multiple parts of a problem or program at the same time using separate CPU cores.
What is concurrent processing?
London's Underground map is a classic real-world example of this, because it intentionally distorts geographic distances to favor functional clarity.
What is an abstract model?
This mechanism allows a new subclass to automatically absorb the attributes and methods of an existing superclass, promoting code reusability.
What is inheritance?
Algorithms that solve the Travelling Salesperson problem via brute force often exhibit this disastrously inefficient time complexity, typically denoted as O(2^n).
What is exponential complexity?
This programming technique is demonstrated by the following function, which calls itself until it hits a base case:
Python
def mystery(n):
----if n <= 1:
--------return 1
----else:
--------return n * mystery(n - 1)
What is recursion?
Using libraries, functions, or object-oriented classes that have already been written and tested to build a new program is an example of this practice.
What is using reusable program components?
While it can significantly speed up execution, this is a major drawback of concurrent processing, often caused by tasks competing for the same resources.
What is overhead/resource contention/a race condition/deadlock?
Literally meaning "many forms," this principle allows a method to behave differently depending on the object that is calling it, often achieved through method overriding.
What is polymorphism?
Both Depth-First Search (DFS) and Breadth-First Search (BFS) share this identical time complexity when traversing a graph with $V$ vertices and $E$ edges.
What is O(V + E)?
(linear time relative to vertices and edges )
When an argument is passed to a subroutine using this method, a copy of the data is created, meaning any changes made to the parameter inside the subroutine will not affect the original variable in the main program.
What is passing by value?