Free Practice Questions for WGU Scripting-and-Programming-Foundations Exam

We start with the given function: ( Y = -2x - 2 ).

To find ( f(-1) ), we substitute ( x = -1 ) into the function.

Plugging in the value: ( f(-1) = -2(-1) - 2 = 2 - 2 = 0 ).

References

Scripting and Programming Foundations documents.

Comprehensive and Detailed Explanation From Exact Extract:

Object-oriented languages are defined by their use of objects, which combine data (attributes) and operations (methods) to model real-world entities. According to foundational programming principles, this encapsulation of data and behavior is a hallmark of OOP languages.

Option A: "Supports creating programs as items that have data plus operations." This is correct. OOP languages (e.g., C++, Java, Python) organize programs into objects, where each object contains data (fields or attributes) and operations (methods). For example, a Car object might have data like speed and methods like accelerate().

Option B: "Supports creating programs as a set of functions." This is incorrect. This describes functional or procedural languages (e.g., C, Haskell), where programs are structured as functions or procedures, not objects.

Option C: "Requires a compiler to translate to machine code." This is incorrect. Not all OOP languages require compilation to machine code (e.g., Python is interpreted). Compilation is a characteristic of some languages (e.g., C++, Java), not a defining feature of OOP.

Option D: "Can be run on any machine that has an interpreter." This is incorrect. While some OOP languages (e.g., Python) are interpreted, others (e.g., C++) are compiled. Interpretability is not specific to OOP.

Certiport Scripting and Programming Foundations Study Guide (Section on Object-Oriented Programming).

Java Documentation: “Defining Classes” (https://docs.oracle.com/javase/tutorial/java/javaOO/).

W3Schools: “Python Classes and Objects” (https://www.w3schools.com/python/python_classes.asp).

Here's the typical flow of the Waterfall software development model:

Analysis: This phase focuses on defining the problem and gathering detailed requirements for the software. Understanding the specific mathematical operations to support is a key part of this phase.

Design: Designers turn the requirements from the analysis phase into a concrete blueprint for the software. This includes architectural and detailed design decisions covering how those mathematical operations will be implemented.

Implementation: Developers take the design and translate it into working code, writing the modules and functions to perform the calculations.

Testing: Testers verify the software to ensure it meets the requirements, including testing how the implemented calculator functions handle different operations.

Maintenance: Ongoing support after deployment to address bugs and introduce potential changes or enhancements.

Why the other options are less accurate:

A. Design and Testing: While testing validates the calculator's functions, the determination of the required operations happens earlier in the process.

B. Implementation and Testing: Implementation builds the calculator, but the specifications and choice of operations happen before coding starts.

C. Design and Implementation: Though closely linked, the design phase finalizes the operation choices before implementation begins.

 The correctness of a sorting algorithm is determined by its ability to sort a list of elements into a specified order, typically non-decreasing or non-increasing order. For an algorithm to be considered correct, it must consistently produce the correct output for all possible inputs. In the case of the given algorithm, it takes the input list [10, 8] and produces the output [6, 10, 8], which is not sorted in non-decreasing order. This indicates that the algorithm does not correctly sort the list, as the output is neither sorted nor does it maintain the integrity of the original list (the number 6 was not in the original list).

Furthermore, the fact that the output contains an integer (6) that was not present in the input list suggests that the algorithm is not preserving the elements of the input list, which is a fundamental requirement for a sorting algorithm. This violation confirms that the algorithm is incorrect for sorting an arbitrary list of three integers, as it cannot be relied upon to sort correctly or maintain the original list elements.

Comprehensive and Detailed Explanation From Exact Extract:

In Agile, the analysis phase (often part of sprint planning or backlog refinement) involves gathering and refining requirements, typically as user stories or features, based on stakeholder input. According to foundational programming principles and Agile methodologies (e.g., Certiport Scripting and Programming Foundations Study Guide, Agile Manifesto), the analysis phase focuses on defining what the system should do.

Agile Analysis Phase:

Identifies and prioritizes requirements, often incorporating customer feedback.

Produces user stories or feature lists (e.g., “add new animation effects”).

Option A: "Deciding that new capabilities in the animation application will be written as functions without the need for any new objects." This is incorrect. This decision involves technical design (e.g., choosing procedural vs. object-oriented approaches), which occurs in the design phase, not analysis.

Option B: "Sending the application to customers for additional evaluation after new features are added." This is incorrect. This occurs during testing or deployment phases (e.g., sprint review or user acceptance testing), not analysis.

Option C: "Deciding to add five new capabilities to the animation application based on customer feedback." This is correct. In Agile, analysis includes refining the product backlog by adding new features (capabilities) based on customer feedback, such as new animation effects or tools.

Option D: "Writing the code for five new capabilities." This is incorrect. Writing code occurs during the implementation phase, not analysis.

Certiport Scripting and Programming Foundations Study Guide (Section on Agile Analysis).

Agile Manifesto: “Customer Collaboration” (http://agilemanifesto.org/).

Cohn, M., User Stories Applied (Chapter 2: Agile Requirements).

 In the Waterfall model of software development, the phase where all functions that need to be written to support the inventory system would be outlined is the Design phase. This phase is critical as it translates the requirements gathered during the analysis phase into a blueprint for constructing the system. It involves two subphases: logical design and physical design. The logical design subphase is where possible solutions are brainstormed and theorized, while the physical design subphase is when those theoretical ideas and schemas are turned into concrete specifications12.

Comprehensive and Detailed Explanation From Exact Extract:

The function K(s1, s2) outputs s1, followed by " and ", followed by s2. When called with K("sign", "horse"), it outputs "sign and horse". Calling it twice repeats this output. According to foundational programming principles, multiple function calls append their outputs in sequence unless specified otherwise (e.g., no newlines assumed unless explicit).

Single Call: K("sign", "horse") outputs "sign and horse".

Two Calls: The output is "sign and horse" followed by "sign and horse", resulting in "sign and horse sign and horse".

Option A: "sign and horse and sign and horse." This is incorrect. This suggests an extra "and" between the two outputs, which is not produced by the function.

Option B: "sign and horsesign and horse." This is incorrect. This implies no space between the two outputs, but typical output mechanisms (e.g., print in Python) may add spaces or newlines, and the space is explicit in the correct option.

Option C: "sign and horse." This is incorrect. This is the output of one call, not two.

Option D: "sign and horse." This is incorrect. Identical to C, it represents one call.

Option E: "sign and horse sign and horse." This is correct. It accurately represents the concatenated output of two calls: "sign and horse" twice.

Certiport Scripting and Programming Foundations Study Guide (Section on Functions and Output).

Python Documentation: “Print Function” (https://docs.python.org/3/library/functions.html#print).

W3Schools: “C Output” (https://www.w3schools.com/c/c_output.php).

Comprehensive and Detailed Explanation From Exact Extract:

The loop variable update statement modifies the loop control variable to progress the loop. In this do-while loop, h tracks the number of attempts, and its update is critical to the loop’s termination. According to foundational programming principles, the update statement is typically within the loop body.

Code Analysis:

integer h = 0: Initializes h (not an update).

Put "What is the password?" to output: Outputs prompt (not an update).

String userInput = Get next input: Gets input (not an update).

if userInput != pwd: Conditional check (not an update).

Put "Incorrect." to output: Outputs message (not an update).

h = h + 1: Updates h, incrementing the attempt counter.

while (userInput != pwd) and (h <= 10): Loop condition (not an update).

Option A: "if userInput = pwd." Incorrect. This is a conditional statement, not an update. (Note: The code uses = for comparison, which may be a typo; == is standard.)

Option B: "h = h + 1." Correct. This updates the loop variable h, incrementing it to track attempts.

Option C: "(userInput != pwd) and (h <= 10)." Incorrect. This is the loop condition, not an update.

Option D: "integer h = 0." Incorrect. This is the initialization, not an update.

Certiport Scripting and Programming Foundations Study Guide (Section on Loops and Variables).

C Programming Language Standard (ISO/IEC 9899:2011, Section on Do-While Loops).

W3Schools: “C Do While Loop” (https://www.w3schools.com/c/c_do_while_loop.php).

 C is a programming language that primarily follows the procedural programming paradigm1. This paradigm is a subset of imperative programming and emphasizes on procedure in terms of the underlying machine model1. It involves writing a sequence of instructions to tell the computer what to do step by step, and it relies on the concept of procedure calls, where procedures, also known as routines, subroutines, or functions, are a set of instructions that perform a specific task1.

The procedural paradigm in C uses static typing, where the type of a variable is known at compile time1. This means that the type of a variable is declared and does not change over time, which is in contrast to dynamic typing, where the type can change at runtime. C’s type system requires that each variable and function is explicitly declared with a type and it does not support dynamic typing as seen in languages like Python or JavaScript1.

Let's evaluate F(3):

F(3) = (4 * 3) - 8

F(3) = 12 - 8

F(3) = 4