Pass the WGU Courses and Certificates Foundations-of-Computer-Science Questions and answers with ExamsMirror

Selection sort works by growing a sorted portion of the list one element at a time. The algorithm conceptually divides the array into two regions: asorted prefixon the left and anunsorted suffixon the right. At the beginning, the sorted prefix is empty and the entire list is unsorted. The first step is to consider position 0 as the target location for the smallest element. The algorithm scans the unsorted region (initially the whole list) tofind the smallest valueand records its index. That action is exactly what option C describes: determine the lowest value starting from the first position.

After identifying the minimum element, selection sort swaps it into position 0 (if it isn’t already there). Then it repeats the process for position 1, scanning the remaining unsorted suffix to find the next smallest element, swapping it into place, and so on. Textbooks emphasize that the key characteristic of selection sort is the repeated “select min (or max) from unsorted region and place it into the sorted region.”

Option A is not the standard first step; finding both min and max is unnecessary. Option B describes an unrelated swap that doesn’t ensure progress toward sorting. Option D is not a “first step” but rather a different ordering goal; selection sort can be adapted for descending order, but the canonical version begins by selecting the minimum for the first position.

Python slicing uses the notation sequence[start:stop], where start is inclusive and stop is exclusive. When start is omitted, it defaults to 0, meaning the slice starts from the beginning of the sequence. Therefore, fam[:3] is equivalent to fam[0:3]. Because the stop index 3 is excluded, the slice includes elements at indices 0, 1, and 2—exactly the first three elements.

This convention is emphasized in programming textbooks because it makes many tasks natural and reduces boundary errors. For example, “take the first n items” is written as [:n], and “drop the first n items” is written as [n:]. The length of the slice is also easy to reason about: with step 1, it is stop - start, so here it is 3 - 0 = 3.

Option B is incorrect because including four elements would require fam[:4]. Option C would correspond to fam[:2]. Option D describes taking elements from the end, which would use negative indexing such as fam[-3:].

Slicing is widely used for batching, windowing in algorithms, splitting datasets into training/testing segments, and extracting prefixes in parsing tasks. Understanding the inclusive start and exclusive stop rule is essential for correct Python programming.

AType 1 hypervisor, also called abare-metal hypervisor, runs directly on the host machine’s hardware rather than on top of a general-purpose operating system. This design is widely described in virtualization textbooks because it improves performance and isolation: the hypervisor controls CPU scheduling, memory management, and I/O virtualization with minimal overhead from an intermediate OS layer. Type 1 hypervisors are therefore common in servers and data centers.

Among the options,VMware ESXiis the well-known Type 1 hypervisor product. It is installed directly onto physical server hardware and provides the virtualization layer used to run multiple virtual machines. In contrast, Parallels Desktop, VirtualBox, and VMware Workstation are typically categorized asType 2 hypervisors, meaning they run as applications on top of a host operating system like Windows, macOS, or Linux. Type 2 hypervisors are excellent for desktops, development, testing, and learning, but they generally rely on the host OS for device drivers and resource management, which can add overhead.

This distinction matters in practice: data centers favor Type 1 hypervisors for efficiency, centralized management, and robust isolation between workloads. Desktop users often choose Type 2 hypervisors for convenience and easier installation. Therefore, the commonly used Type 1 hypervisor brand listed here is VMware ESXi.

Binary search is designed for searching in asorted (ordered) sequence. Its efficiency comes from repeatedly comparing the target to the middle element and discarding half of the remaining search space. This halving logic only works when the data is ordered, because the algorithm relies on the guarantee that all elements on one side of the midpoint are smaller (or larger) than the midpoint. In textbooks, this requirement is stated explicitly: binary search assumes the collection is sorted according to the same ordering used for comparisons.

An “ordered list” is therefore the correct focus among the options. Binary search can be implemented on arrays or other random-access structures where you can quickly access the middle element by index. While you can conceptually perform binary search on a linked list, it becomes inefficient because finding the middle requires linear traversal, losing the O(log n) advantage. Stacks and queues are not appropriate because they restrict access to ends only (LIFO for stacks, FIFO for queues), preventing direct access to the midpoint and making the binary search strategy infeasible.

Thus, the central requirement for binary search is a sorted/ordered sequence, typically supporting efficient indexing, which is why the correct choice is an ordered list.

In Python, id(x) returns the “identity” of an object, which in CPython (the most common implementation) is typically the object’s memory address. When you write m = 30 and n = 30, both names may refer to thesame integer objectbecause CPython caches a range of small integer objects for efficiency. This optimization means that commonly used small integers are pre-created and reused, so repeated occurrences of the same small integer literal often point to the same object, producing identical id() values. As a result, print(id(m), id(n)) will most likely displaytwo identical numbersin standard CPython builds when 30 falls within the cached range. (Real Python)

This behavior is an implementation detail, but it is widely discussed in Python education because it illustrates the difference between object identity (whether two variables reference the same object) and value equality (whether two objects have the same value). Even if id(m) and id(n) were different in some edge environment, m == n would still be True because the values are equal; id() is about identity, not value. The options “0 0” and “Error” are not consistent with how id() works for valid objects.

In NumPy, every ndarray has a shape attribute that describes the size of the array along each dimension. For a 2D array, shape returns a tuple with two integers: (number_of_rows, number_of_columns). For example, if a = np.array([[1, 2, 3], [4, 5, 6]]), then a.shape is (2, 3), meaning 2 rows and 3 columns. This is a fundamental idea in matrix and array computing, because shape governs how indexing, slicing, broadcasting, and linear algebra operations behave.

Option A describes the dtype, which can be accessed with a.dtype, not a.shape. Option C is incorrect because shape provides per-dimension sizes, not their sum. Option D refers to the total number of elements, which NumPy provides via a.size (or equivalently np.prod(a.shape)).

Textbooks emphasize shape because many errors in numerical computing come from mismatched dimensions. For example, matrix multiplication requires compatible inner dimensions, and broadcasting rules depend on dimension sizes. By checking .shape, programmers can verify their data layout before applying algorithms, ensuring rows represent observations and columns represent features (or vice versa). Thus, for a 2D NumPy array, .shape indicates the number of rows and columns.

A function definition in Python specifies a function name and a list of parameters. Here, def linear_search(customersList, search_value): defines a function named linear_search that requirestwo argumentswhen called: a list (or sequence) of customer items and the value being searched for. A correct call must therefore supply both arguments in the same order: linear_search(customersList, search_value). Option B is correct because it calls the function properly and then prints the returned result.

Textbooks describe linear search as scanning the list from the beginning to the end, comparing each element to search_value until a match is found or the list ends. The function typically returns an index (e.g., position of the match) or a Boolean, or possibly -1/None if not found. Wrapping the call in print(...) is a standard way to display the returned value for testing or demonstration.

Option A is incorrect because it calls a different function name, not linear_search. Option C is incorrect because linear_search() would attempt to call the function with zero arguments, which would raise a TypeError, and then it tries to call the result as if it were another function. Option D uses a different function name (search_linear) and also contains a spelling mismatch compared to the given definition.

Python provides built-in type conversion functions that construct a value of a target type from a supplied object when possible. To convert an integer to a string, Python uses the constructor function str(). For example, str(42) produces the string "42". This operation is fundamental in programming textbooks because it enables tasks like formatting output, concatenating numbers into messages, building file names, or preparing numeric values for text-based storage and transmission.

Python distinguishes clearly between numeric types (int, float) and text type (str). You cannot concatenate an integer directly with a string (e.g., "Age: " + 30 raises a TypeError) because the types are different. Using str(30) resolves this by converting the integer into its string representation: "Age: " + str(30) becomes valid. Modern Python commonly uses f-strings (f"Age: {30}"), which perform conversion automatically, but str() remains the canonical and explicit method.

Options A, B, and C are not standard Python built-ins for conversion. While some libraries define helper functions with similar names, the language’s standard approach is str(...). Textbooks also highlight that str() is not limited to integers: it can convert many objects into readable string representations, often by invoking the object’s __str__ method. This ties conversion to Python’s object model and supports consistent display and logging across programs.

Binary search is a classic algorithm for finding a target value in asortedlist or array. Its key idea is to eliminate half of the remaining search space at each step. The algorithm compares the target with the middle element. If the target is smaller, it continues searching in the left half; if larger, it searches the right half. Because each comparison reduces the problem size from n to approximately n/2, the number of steps grows with the number of times you can halve n before reaching 1 element.

This repeated halving leads to a logarithmic running time. Formally, the recurrence is often written as T(n) = T(n/2) + O(1), which solves to T(n) = O(log n). (GeeksforGeeks) Textbooks emphasize that this is dramatically faster than linear search (O(n)) for large datasets, but only when the data is already sorted (or can be sorted once and searched many times).

The other options do not match binary search behavior: O(n^2) is typical of certain nested-loop algorithms, and O(2^n) is associated with exponential-time brute force in combinatorial problems. Binary search’s hallmark is its logarithmic growth in comparisons, making it a foundational technique in algorithms courses. (GeeksforGeeks)

In Python, external libraries are brought into a program using the import statement. NumPy, which provides the ndarray type and a large collection of numerical computing functions, is conventionally imported with an alias for convenience. The standard and widely taught pattern is import numpy as np. This imports the numpy module and binds it to the shorter name np, making code more readable and reducing repeated typing, especially in mathematical expressions such as np.array(...), np.mean(...), or np.dot(...).

Option A is incorrect because the module name is numpy, not num_py. Options C and D resemble syntax from other languages (for example, “using” in C# or “include” in C/C++), but they are not valid Python import mechanisms. Python’s module system is based on imports, and the aliasing feature (as np) is built into the import statement.

Textbooks also emphasize that importing a package requires that it be installed in the active Python environment. If NumPy is not installed, import numpy as np will raise an ImportError (or ModuleNotFoundError in modern Python). Once imported, the alias np is used consistently in scientific computing materials, notebooks, and professional data analysis codebases, which is why this option is considered the correct and expected answer.