Foundations-of-Computer-Science WGU Foundations of Computer Science Questions and Answers

NumPy supports a powerful technique calledBoolean indexing(also called Boolean masking) to filter arrays based on a condition. When you write bmi > 23, NumPy performs an element-wise comparison and produces a Boolean array of the same shape, containing True where the condition holds and False otherwise. Using that Boolean array inside square brackets, as in bmi[bmi > 23], tells NumPy to return a new 1D array containing only the elements whose mask value is True. This approach is heavily emphasized in scientific computing curricula because it expresses selection logic without explicit loops and runs efficiently in optimized compiled code.

Option B looks close but is not standard NumPy usage. The function commonly used is np.where(condition) or np.where(condition, x, y). While np.where(bmi > 23) can return indices, bmi.where(...) is not a NumPy array method; it is more associated with pandas objects. Options A and C are not valid NumPy APIs for filtering.

Boolean indexing is central in data analysis tasks such as removing invalid measurements, selecting a population subgroup, applying thresholds, and building feature subsets. It composes cleanly with vectorized computation, for example bmi[bmi > 23].mean(), enabling concise and high-performance numerical workflows.

Ahypervisoris the software layer that enables virtualization—running multiple operating systems concurrently on the same physical hardware as separate, isolated virtual machines (VMs). Operating systems textbooks describe the hypervisor as managing and multiplexing core hardware resources such as CPU, memory, storage, and I/O devices among multiple guest operating systems. Each VM behaves as if it has its own hardware, while the hypervisor enforces isolation and schedules resource usage.

Hypervisors come in two broad categories.Type 1 (bare-metal)hypervisors run directly on the hardware (common in data centers), whileType 2 (hosted)hypervisors run as applications on top of a host OS (common on desktops). In both cases, the hypervisor is the key tool that makes “more than one OS at a time” possible.

System Restore is a recovery feature, not a virtualization platform. A partition manager can split a disk into multiple partitions, which can support dual-boot setups, but that runs only one OS at a time, not concurrently as VMs. A bootloader selects which OS to start at boot time; again, that is not simultaneous virtualization. Therefore, the correct tool that allows running multiple operating systems simultaneously as virtual machines is the hypervisor.

Selection sort is the algorithm that repeatedly scans the unsorted portion of a list to find the lowest (or highest) value and then places it into its correct position in the sorted portion. It begins at the first index (position 0) and treats that as the boundary between sorted and unsorted regions. On the first pass, it moves a scanning pointer through the entire list to determine the minimum element and swaps it into position 0. On the second pass, it starts from position 1, scans to the end to find the next minimum, and swaps it into position 1. This continues until the list is sorted.

This matches the question’s description: “starts at the first position and moves the pointer until the end of the list, determining the lowest value.” Textbooks often describe selection sort with two indices: one for the current boundary position and one for scanning the remainder of the list to find the minimum. The algorithm is simple and uses O(1) extra space, but it is inefficient for large lists because it performs O(n²) comparisons regardless of input order.

The other options are not standard algorithm names in typical computer science curricula. While many sorting algorithms exist (insertion sort, merge sort, quicksort, heap sort), “incremental,” “progressive,” and “pointer sort” are not canonical textbook algorithms in this context. Therefore, the correct answer is selection sort.

NumPy arrays use zero-based indexing, meaning counting starts at 0 rather than 1. In a 2D NumPy array, indexing is typically written in the form array[row_index, column_index]. The first index selects the row, and the second index selects the column. Therefore, the “first row” corresponds to row index 0. Within that row, the “third element” corresponds to column index 2, because the columns are indexed 0, 1, 2, 3, and so on.

So, np_2d[0, 2] directly selects the element at row 0 and column 2, which is the third element in the first row. This is considered an “alternative” to approaches like two-step indexing (np_2d[0][2]), and it is the standard idiom taught for multi-dimensional NumPy arrays.

The other choices point to different locations. np_2d[1, 3] is the fourth element of the second row, not the third element of the first row. np_2d[2, 0] and np_2d[3, 1] attempt to access the third or fourth row, which would often be out of bounds in a small 2-row example and would raise an IndexError. Correct indexing is a cornerstone of array programming because it determines which observation, feature, or matrix entry your computations will use.

TheHardware Abstraction Layer (HAL)is a software layer that sits between the operating system kernel and the physical hardware. Its purpose is to hide hardware-specific details behind a consistent interface, allowing the OS to be more portable and easier to maintain across different hardware platforms. Textbooks explain that without abstraction, the OS would need extensive device- and architecture-specific code scattered throughout the kernel, making updates and cross-platform support far more difficult.

The HAL typically provides standardized functions for interacting with low-level components such as interrupts, timers, memory mapping, and device I/O. With a HAL, the OS can call general routines (for example, to configure an interrupt controller) while the HAL handles the platform-specific implementation. This supports a key systems principle: separate policy (what the OS wants to do) from mechanism (how hardware accomplishes it).

The other options are not correct. A boot loader runs at startup to load the operating system into memory; it is not the general interface layer during normal operation. The task scheduler is a kernel subsystem that manages CPU time among processes, not a hardware-independence layer. The file system layer manages storage organization and access semantics; it is not the general abstraction for all hardware interactions.

Therefore, the programming layer that enables generalized OS interaction with hardware is the hardware abstraction layer.

In programming, a function takes inputs, performs computation, and may return an output. The standard term for a function’s inputs isarguments(also commonly discussed alongside the closely related termparameters). Textbooks typically distinguish the two:parametersare the names listed in the function definition, whileargumentsare the actual values supplied when the function is called. For example, in def f(x, y):, x and y are parameters. In the call f(3, 5), 3 and 5 are arguments. Many introductory materials use “arguments” informally to refer to the inputs overall, which matches the wording of this question.

Options A, B, and C do not fit the textbook definition. “Variables” is too broad; inputs can be literals, expressions, or variables, but the conceptual role is “arguments.” “Procedures” are callable units of code (often used in some languages to mean functions without return values), not the inputs. “Outputs” refers to returned results, not what you pass in.

Understanding arguments is important because it connects to call semantics, scope, and correctness. Different languages support positional arguments, keyword arguments, default values, and variadic arguments (e.g., *args, **kwargs in Python). This flexibility shapes API design and influences how programmers structure reusable code.

Quicksort is a divide-and-conquer sorting algorithm. It works by selecting a pivot element, partitioning the array into two subarrays (elements less than the pivot and elements greater than the pivot), and then recursively sorting those subarrays. In the average case, the partition step splits the array into roughly equal halves, so the recurrence is commonly written as (T(n) = T(n/2) + T(n/2) + O(n)), where (O(n)) is the cost of partitioning. This solves to (O(n \log n)), which is why quicksort is widely taught as an efficient general-purpose sorting method.

However, textbooks also emphasize that quicksort has a worst-case time complexity of (O(n^2)) when partitions are extremely unbalanced (for example, repeatedly choosing the smallest or largest element as the pivot on already sorted input). Practical implementations reduce the likelihood of worst-case behavior using randomized pivots or “median-of-three” pivot selection. Despite the worst-case, quicksort is often very fast in practice because it has good cache performance and low constant factors, and it sorts in place with only (O(\log n)) average recursion stack space.

Among the provided options, the correct expected complexity for quicksort (average-case, and commonly cited in coursework questions) is (O(n \log n)). The other options are too small to represent the cost of sorting arbitrary data.

NumPy arrays are not a built-in Python data structure. In a default Python installation, the interpreter includes core types such as int, float, str, list, tuple, dict, and set, plus the standard library. A NumPy array, typically created as numpy.ndarray, is provided by the third-party NumPy library. Therefore, if a “default Python configuration” does not recognize a NumPy array, the most likely cause is thatNumPy is not installed or not available in the active environment. This happens often when a user has multiple Python environments (system Python, virtual environments, conda environments) and installs NumPy into one environment while running code in another.

Option B is incorrect because Python’s standard-library array module is different from NumPy. Importing array does not create or enable NumPy’s ndarray type. Option C is possible in rare cases,but the typical, textbook-aligned explanation is missing dependencies rather than an incorrectly configured interpreter. Option D is also unlikely: while very old Python versions may cause compatibility issues with modern NumPy releases, the symptom described—NumPy arrays not being recognized at all—more directly indicates the package is absent in the running environment.

In practice, verifying import numpy and checking the installed packages for the current interpreter resolves the issue.

Python lists are mutable sequences, which means elements can be changed in place after the list has been created. The expression list1[0] = "California" uses indexing to target the element at position 0 (the first element, because Python uses zero-based indexing) and assignment (=) to replace that element with a new value. As a result, the list keeps the same length, but its first entry becomes "California".

This operation does not create a new list (so option A is incorrect); it modifies the existing list object referenced by list1. It also does not append to the end of the list (so option C is incorrect). Appending would use methods like list1.append("California"). Option D is not meaningful in Python list semantics; assignment to a single index replaces exactly one element rather than “adding a second element to the line.”

Textbooks highlight this difference between mutable and immutable sequence types. For example, strings are immutable, so you cannot assign to some_string[0]. Lists, however, are designed for collections that change over time, supporting updates, insertions, deletions, and reordering. Index assignment is fundamental for many algorithms: updating an array-like buffer, modifying a dataset row, replacing incorrect values, or implementing in-place transformations efficiently.

Python lists maintain an order, and sometimes you need to reverse that order so the last element becomes first and the first becomes last. The standard list method for reversing the elementsin placeis reverse(). For example, if nums = [1, 2, 3, 4], then nums.reverse() mutates the list so it becomes [4, 3, 2, 1]. This is a built-in operation taught in introductory programming texts because it is efficient and conceptually simple: it does not create a new list unless you explicitly copy the data.

It is important to distinguish reversing from sorting. Reversing changes the sequence order as-is, while sorting rearranges elements according to comparisons. The question refers to converting the index order to the opposite, which is reversing. If you wanted descendingsortedorder, you would typically use sort(reverse=True) or sorted(nums, reverse=True). But the direct method that reverses the list’s order is reverse().

The other options are not standard Python list methods. sortDescending(), flip(), and invert() are not part of Python’s built-in list API. Textbooks emphasize learning the correct method names because Python’s standard library provides a consistent, widely used interface across programs. Thus, reverse() is the correct answer for reversing the index order of a list.

In data structures and algorithms,traversalrefers to systematicallyvisiting nodesin a tree or graph in order to process them. “Visiting” typically means performing some operation at each node, such as reading its value, marking it as seen, computing a property, or collecting it into an output structure. Traversal is foundational because many algorithms—search, path finding, connectivity checks, topological analysis, and evaluation of expressions—are built on traversal patterns.

Intrees, traversal has classic forms: preorder, inorder, and postorder depth-first traversals, as well as breadth-first traversal (level-order). Each defines a rule for the order in which nodes are visited relative to their children. Ingraphs, traversal must additionally handle the possibility of cycles and multiple paths; textbooks therefore emphasize maintaining a “visited” set to avoid infinite loops. The two principal graph traversal strategies areDepth-First Search (DFS)andBreadth-First Search (BFS). DFS explores along a path as far as possible before backtracking, while BFS explores layer by layer outward from a start node.

Options A, B, and C do not define traversal. Changing values may happen during traversal, but it is not what traversal means. Removing all nodes is deletion, not traversal. Connecting all nodes is not a standard traversal concept. The correct definition is the process of visiting all nodes (typically reachable from a starting node, or all nodes in the structure if fully connected).

A linked list is a dynamic data structure made up of nodes, where each node typically contains two components: a data field (the value being stored) and a link field (commonly called a pointer or reference). The pointer’s role is to store the memory address (or reference) of the next node in the sequence, thereby maintaining the logical order of the list even though nodes may be scattered throughout memory. This is a key contrast with arrays, which store elements contiguously and rely on index arithmetic to locate the next element.

Because each node explicitly points to the next node, linked lists support efficient insertion and deletion operations compared with arrays. To insert a node, you allocate it and then adjust pointers so it fits into the chain. To delete a node, you redirect the pointer of the previous node to skip over the removed node. Traversal is performed by starting at the head node and repeatedly following the pointer until a null reference indicates the end of the list.

The other options do not correctly describe what stores the location of the next node. An index is used in array-like structures, not in a standard linked list node. The value is the payload data, not the link. The “header” (often called the head pointer) is an external reference to the first node, not the field inside each node that links to the next. Therefore, the correct answer is the pointer.

A central rule in NumPy is that an ndarray has a single, fixed data type called itsdtype. That dtype is chosen when the array is created (for example, int64, float64, etc.), and it normally does not change just because you assign a new value into one element. When you attempt an assignment, NumPy tries tocastthe assigned value into the array’s existing dtype. If the cast is possible, the assignment succeeds; if the cast is impossible, NumPy raises an error.

So, if you have a numeric array such as arr = np.array([1, 2, 3]), its dtype is an integer type. Trying arr[0] = "hello" cannot be converted into an integer, so NumPy raises a ValueError (a casting/conversion error). This is exactly the behavior textbooks highlight when contrasting NumPy arrays with Python lists: lists can hold mixed types freely, but NumPy arrays trade that flexibility for speed and memory efficiency via uniform typing.

Option A is a common misconception. While NumPy may “upcast” values to a more general dtype at array creation time when mixed types are provided (e.g., numbers and strings in the same constructor), a pre-existing numeric array will not automatically convert itself into a string array during a single-element assignment. Options C and D do not reflect NumPy’s assignment rules.

In object-oriented programming, amethodis a function that is associated with an object (or its class) and is called using the dot operator. In Python, everything is an object, and many operations are provided through methods. For example, "hello".upper() calls the upper method of a str object, and [1, 2, 3].append(4) calls the append method of a list object. Textbooks emphasize that methods operate on an object’s internal state and typically receive the object itself as an implicit first argument (commonly named self in class definitions). This is what distinguishes methods from standalone functions.

Modules, scripts, and libraries are different organizational concepts. Amoduleis a file containing Python code, including function and class definitions. Ascriptis a Python program intended to be run directly. Alibraryis a collection of modules that provides reusable functionality. None of these terms specifically mean “functions that belong to objects.”

Understanding methods matters because it connects to encapsulation and abstraction: objects provide behaviors (methods) that manipulate their data in well-defined ways. This design enables clearer APIs and supports polymorphism, where different object types can expose methods with the same name but different implementations. In Python, method calls are central to working with built-in types (strings, lists, dictionaries) and with user-defined classes, making “methods” the correct term for functions that belong to specific objects.

Python lists are ordered sequences indexed starting from 0. This zero-based indexing is standard in many programming languages and is a core concept in data structures. For the list `employees = ["Anika", "Omar", "Li", "Alex"]`, the mapping of indices to elements is: index 0 → "Anika", index 1 → "Omar", index 2 → "Li", index 3 → "Alex". Therefore, the expression `employees[3]` selects the element at index 3, which is `"Alex"`, and `print(employees[3])` outputs `Alex` (strings print without quotes in normal output).

Option A would be correct for `employees[1]`, option D would be correct for `employees[2]`, and option C would be correct for `employees[0]`. This kind of question tests understanding of list indexing, which is essential for iteration, slicing, and algorithm implementation.

# Textbooks also note the difference between indexing and slicing: indexing returns a single element, while slicing returns a sublist. Here, because square brackets contain a single integer index, it is indexing. If you attempted an index that is out of range, Python would raise an `IndexError`, which reinforces careful reasoning about list length and positions. Understanding these fundamentals is critical for correctly manipulating datasets, where row/column positions and offsets frequently matter.

Thekernelis the central component of an operating system responsible for managing core system resources. It controls CPU scheduling, memory management, process creation and termination, device I/O coordination, and system calls—the controlled interface through which user programs request services. In operating systems textbooks, the kernel is described as running in a privileged mode (often called kernel mode or supervisor mode), which restricts direct user access for security and stability. User programs typically run in user mode and cannot directly manipulate hardware or critical OS structures; instead, they must request operations via system calls, which the kernel validates and executes.

This separation prevents accidental or malicious actions from crashing the entire system or compromising other processes. For example, a user application cannot directly write to arbitrary memory addresses or reprogram devices; the kernel mediates access and enforces protection boundaries. This model is foundational to modern OS design and underpins features like virtual memory, access control, and multitasking.

File Explorer and the user interface layer are user-facing components that provide interaction and file browsing; they are not the privileged core resource manager. “Device driver manager” is not typically the name of a single OS component; while drivers and driver subsystems exist, they operate under kernel control and are part of the kernel or closely integrated with it.

Therefore, the OS component that manages core resources while disallowing direct user access is the kernel.

Selection sort works by maintaining a boundary between a sorted prefix and an unsorted suffix. On each pass, the algorithm finds the smallest value in the unsorted portion and places it into the first position of that unsorted portion (which is also the next position in the sorted prefix). This is usually done by swapping the element at the minimum’s index with the element at the boundary index (the “first unsorted element”). That description matches option D.

If the first element of the unsorted portion is already the smallest, then the minimum’s index equals the boundary index. In textbook implementations, the algorithm may still execute a swap operation, but it becomes a swap of an element with itself (a no-op), leaving the array unchanged. Many implementations include a small optimization: perform the swap only if the minimum index differs from the boundary index. Either way, conceptually the “action taken” by selection sort is still “swap the selected minimum into the first unsorted position,” which is exactly what option D states.

Options A and B are unrelated to sorting; selection sort never increases or duplicates values. Option C is incorrect because selection sort swaps the minimum with thefirstunsorted element, not the last. After the swap (or no-op), the sorted region grows by one element, and the algorithm repeats from the next boundary position.

This logic is fundamental for understanding how selection sort ensures correctness: after pass i, the smallest i+1 elements are fixed in their final positions.

A hash table is a data structure that supports fast lookup, insertion, and deletion by using ahash functionto map keys to positions in an underlying storage structure. In Python, the built-in data structure that provides hash-table behavior is thedictionary, written with curly braces like {"a": 1, "b": 2}. Dictionaries store key–value pairs and are designed so that accessing a value by key, such as d["a"], is efficient on average. Textbooks typically describe this expected efficiency as average-case constant time, often written as O(1), assuming a good hash function and a well-managed table size.

Tuples and lists are sequence types. Lists provide indexed access by integer position, not hashing by arbitrary keys. Tuples are immutable sequences and likewise do not provide key-based hashing semantics. “Array” is not the core built-in mapping structure in Python; while Python has an array module and NumPy has arrays, neither is the built-in hash table abstraction for general key–value storage.

Python dictionaries require keys to be hashable, meaning the key’s hash value is stable during its lifetime (common examples: strings, numbers, tuples of hashable items). This requirement is directly tied to hash-table implementation. Dictionaries are used throughout computer science applications: symbol tables in interpreters, caches and memoization, frequency counting, indexing, and implementing graphs via adjacency maps.