In NumPy, array slicing uses the format [start:stop:step]. To select the last two rows, the slice is [-2:], which starts from the second-to-last element and goes to the end. Similarly, to select the last two columns, the slice is [-2:]. Combining these for a 2D array results in the syntax array[-2:, -2:], which correctly subsets the desired rows and columns.

A. array[-2:, :] selects the last two rows but includes all columns, not just the last two.

B. array[-1:, -1:] selects only the very last row and the very last column, not the last two of each.

D. array[:, -2:] selects all rows and only the last two columns, failing to subset the rows.

1. NumPy v1.26 Manual, "Indexing on ndarrays," Section: "Slicing and striding." The documentation explains that negative indices count from the end of the array and that a slice i:j includes elements from i up to (but not including) j. A blank j implies the rest of the array. (Source: Official Vendor Documentation)

2. VanderPlas, J. (2016). Python Data Science Handbook. O'Reilly Media. Chapter 2, Section: "The Basics of NumPy Arrays," Sub-section: "Array Slicing: Accessing Subarrays." This section details how to use comma-separated slices to access subarrays, e.g., x[rowslice, colslice]. (Source: Peer-reviewed academic publication)

A compiler is a specialized program that translates source code written in a high-level programming language (e.g., C++, Java) into a lower-level language, such as assembly or machine code. This process, known as compilation, allows the computer's central processing unit (CPU) to directly execute the instructions. The compiler performs syntax checking, optimization, and code generation to create an efficient and executable program from the human-readable source code.

B. A device that stores files permanently is a storage device like a hard disk drive (HDD) or solid-state drive (SSD), not a compiler.

C. A user account permission manager is a component of an operating system that handles access control, which is unrelated to code translation.

D. A graphical tool for drawing charts is a type of application software, which serves a different purpose than a language processor like a compiler.

1. Aho, A. V., Lam, M. S., Sethi, R., & Ullman, J. D. (2007). Compilers: Principles, Techniques, and Tools (2nd ed.). Pearson/Addison Wesley. In Chapter 1, Section 1.1, "Language Processors," the text defines a compiler as a program that "reads a program written in one language—the source language—and translates it into an equivalent program in another language—the target language."

2. MIT OpenCourseWare. (2017). 6.004 Computation Structures, Spring 2017. Unit 4: The Digital Abstraction, Lecture 15. The lecture materials describe the compilation process as the translation from high-level languages down to the instruction set architecture that the hardware can execute.

Decomposition is a fundamental principle of computational thinking. It involves breaking down a complex problem or system into smaller, more manageable, and understandable sub-problems. Each sub-problem can then be solved independently, and the solutions can be combined to solve the original complex problem. This approach simplifies the development, testing, and maintenance process.

B. Turning off a computer is a user action related to hardware operation, not a problem-solving methodology.

C. Combining files is an act of aggregation or archiving, which is the conceptual opposite of decomposition.

D. Replacing variables with constants is a specific coding practice, not the broad problem-solving strategy of decomposition.

1. Wing, J. M. (2006). Computational thinking. Communications of the ACM, 49(3), 33-35. (Section: "The concepts of computational thinking", para. 2). https://doi.org/10.1145/1118178.1118215

2. Grover, S., & Pea, R. (2013). Computational Thinking in K–12: A Review of the State of the Field. Educational Researcher, 42(1), 38-43. (Section: "What is Computational Thinking?", p. 39). https://doi.org/10.3102/0013189X12463051

3. MIT OpenCourseWare. (2016). 6.0001 Introduction to Computer Science and Programming in Python, Fall 2016. Lecture 1: What is Computation? Notes. (The concept is introduced as a core problem-solving technique).

A tree is a widely used abstract data type that represents a hierarchical structure. It consists of a collection of nodes connected by directed (or undirected) edges. Each tree has a special "root" node, and every other node has exactly one parent, with the root having no parent. This parent-child relationship is the defining characteristic of a tree's hierarchical nature, distinguishing it from linear structures like lists or cyclical structures like graphs.

A. This describes a linear data structure, such as a doubly linked list, not a hierarchical tree structure.

C. Trees are abstract data types and can store any kind of data in their nodes, including strings, objects, or other complex types.

D. This describes a hardware monitoring function within an operating system, which is unrelated to the concept of a tree data structure.

1. Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2022). Introduction to Algorithms (4th ed.). MIT Press. (Chapter 10, Section 10.4 "Representing rooted trees," pp. 269-272, defines trees based on parent-child-sibling pointers.)

2. Aho, A. V., Hopcroft, J. E., & Ullman, J. D. (1983). Data Structures and Algorithms. Addison-Wesley. (Chapter 3, "Trees," p. 55, defines a tree recursively as a set of nodes with a root and disjoint subtrees.)

3. Stanford University. (n.d.). CS106B: Programming Abstractions Course Reader. (Section on "Trees," which introduces the concept as a collection of nodes organized in a hierarchy.)

Algorithm efficiency describes how the performance of an algorithm scales with the size of its input. It is primarily measured by its time complexity (the amount of time it takes to run) and its space complexity (the amount of memory it requires). This analysis, often expressed using asymptotic notation like Big O, quantifies the relationship between the input size (n) and the resources consumed, allowing for a standardized comparison of different algorithms' performance characteristics, especially as the input grows very large.

A. The visual design of an interface relates to user experience (UX) and usability, not computational efficiency.

C. Code comments are for human readability and maintainability; they do not affect the algorithm's execution performance.

D. The number of concurrent users relates to system scalability and architecture, a broader concept than single-algorithm efficiency.

1. Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms (3rd ed.). MIT Press. Chapter 2, "Getting Started," Section 2.2 Analyzing algorithms, p. 24-29.

2. Stanford University. (n.d.). CS161: Design and Analysis of Algorithms. Course Notes, "Asymptotic Analysis." Retrieved from https://web.stanford.edu/class/cs161/

3. MIT OpenCourseWare. (2011). 6.006 Introduction to Algorithms, Fall 2011. Lecture 1: Algorithmic Thinking, Peak Finding.