WGU C949 Data Structures & Algorithms I | Objective Assessment 2026-2027 Version 2 | 100% Verified Answers
WGU C949 Data Structures & Algorithms I
OBJECTIVE ASSESSMENT
Latest Updated Edition | Version 2
Questions & Verified Answers | 100% Correct | Grade A
Course: WGU C949 Data Structures and Algorithms I | Total Questions: 70 | Format: Multiple Choice
Aligned with WGU C949 Course Competencies & Objective Assessment Blueprint (2026-2027)
Sections: Data Types (36%) • Data Structures (30%) • Algorithms (34%)
EXAM INSTRUCTIONS: This Objective Assessment consists of 70 multiple-choice questions divided into
three sections aligned with WGU C949 competencies: Data Types (Q1-Q25), Data Structures (Q26-Q45), and
Algorithms (Q46-Q70). Each question has four options (A, B, C, D) with only ONE correct answer. The
correct answer is identified by the green highlighted option followed by [CORRECT]. A detailed rationale
explaining the correct answer and why other options are incorrect accompanies each question. Cognitive
distribution: 30% recall, 45% application, 25% analysis. Question style: 70% scenario-based, 30% direct
recall/complexity identification. Language-agnostic interpretation (pseudocode samples are conceptual, not
language-specific).
Section 1: Data Types
Primitive Types, Abstract Data Types, Classes, & Type Systems (Q1-Q25)
Q1:
A programmer declares a variable as `float price = 19.99;`. Which characteristic distinguishes this
primitive data type from an Abstract Data Type (ADT) such as a Stack?
A. A float can hold only whole numbers, while an ADT can hold decimal values.
B. A primitive type is a built-in, single-value type defined by the language, while an ADT is
defined by its behavior (operations) rather than its underlying representation. [CORRECT]
C. A primitive type supports method calls, while an ADT does not.
D. A primitive type must always be stored on the heap, while an ADT is stored on the stack.
Correct Answer: B
Rationale:
Primitive types (int, float, boolean, char) are built-in single-value types defined by the language's type system.
An Abstract Data Type (ADT) such as a Stack, Queue, List, or Map is defined by its behavioral contract (the
operations it supports like push/pop) rather than its internal storage representation. The same ADT can be
implemented using an array or a linked list. Floats do store decimal values, but option A is wrong because ADTs
are not defined by what values they hold. Primitive types in most languages do not support method calls (option
C), and storage location depends on the language runtime, not the type classification (option D).
Page 1 | WGU C949 Objective Assessment | 70 Questions
,WGU C949 Data Structures & Algorithms I | Objective Assessment 2026-2027 Version 2 | 100% Verified Answers
Q2:
Which of the following is a key distinction between a primitive data type and an Abstract Data
Type (ADT)?
A. Primitive types are user-defined, while ADTs are language-defined.
B. ADTs encapsulate both data and the operations on that data, exposing behavior through an
interface, while primitive types expose only the value itself. [CORRECT]
C. ADTs use less memory than primitive types because they avoid built-in language overhead.
D. Primitive types can only be used in object-oriented languages, while ADTs work in any paradigm.
Correct Answer: B
Rationale:
An ADT bundles data with the operations that act on that data, exposing behavior through an interface while
hiding the internal representation (encapsulation). Primitive types are language-defined built-in types that expose
only the raw value (option A is backwards). ADTs typically require MORE memory than primitives because they
maintain metadata, pointers, or container overhead (option C is wrong). Both primitives and ADTs can be used
across paradigms (option D is incorrect). Examples of ADTs include List, Stack, Queue, Set, and Map, each
defined by their behavioral contract rather than implementation.
Q3:
A programmer is choosing between an `int` and a `boolean` to represent whether a user is logged
in. Which statement BEST justifies choosing `boolean`?
A. A boolean can represent more states than an int.
B. A boolean most accurately represents the two-state domain (logged in / not logged in),
improving semantic clarity and reducing invalid-state risk compared to a multi-valued int.
[CORRECT]
C. A boolean uses more memory, which improves performance.
D. A boolean can be safely used in arithmetic, while an int cannot.
Correct Answer: B
Rationale:
Choosing the most semantically accurate primitive type (boolean for true/false, int for counting, float for
measurements, char for single characters) improves readability and prevents invalid states. A boolean has only
two possible values (true/false), matching the domain exactly, while an int allows arbitrary integers (e.g., 5, -3)
that have no meaning in the context of login status. Option A is wrong because booleans have fewer states than
ints. Option C is wrong because booleans use less memory (typically 1 byte). Option D is wrong because booleans
cannot be used in arithmetic directly (most languages require explicit conversion).
Q4:
Which of the following is NOT a primitive data type in most mainstream programming languages
(Java, C, Python's core types)?
A. Integer
B. Float
C. String [CORRECT]
D. Boolean
Correct Answer: C
Page 2 | WGU C949 Objective Assessment | 70 Questions
, WGU C949 Data Structures & Algorithms I | Objective Assessment 2026-2027 Version 2 | 100% Verified Answers
Rationale:
In most mainstream languages, Integer, Float, and Boolean are primitive types. String is generally NOT a
primitive type; it is an ADT (often a class or array-backed structure) that bundles character data with operations
like concatenation, length, and substring. In Java, `String` is a class (reference type), not a primitive. In C, there
is no String type at all—only `char` arrays. In Python, `str` is an immutable object type, not a primitive. Treating
String as primitive is a common C949 exam pitfall. A character (`char`) is primitive, but a sequence of
characters is an ADT.
Q5:
A programmer creates a class `BankAccount` with fields `balance` (double) and `accountHolder`
(String), plus methods `deposit()` and `withdraw()`. This is an example of:
A. A primitive data type.
B. An Abstract Data Type (ADT) implemented as a class, encapsulating data and operations.
[CORRECT]
C. A type system error because classes cannot store primitive fields.
D. A function, not a type, because it has methods.
Correct Answer: B
Rationale:
A class that encapsulates both data (balance, accountHolder) and the operations on that data (deposit,
withdraw) is an implementation of an Abstract Data Type. ADTs are defined by behavior rather than
representation; the same ADT could be implemented differently. Option A is wrong because primitive types hold
a single value, not multiple fields with methods. Option C is wrong—classes routinely store primitive fields.
Option D is wrong because methods alone do not prevent a construct from being a type; classes define types. The
principle of encapsulation hides internal state and exposes only the operations through a public interface.
Q6:
A programmer is implementing a List ADT and must choose between an array-based and a
linked-list-based implementation. The application requires frequent insertions and deletions at
the FRONT of the list, but random access by index is rarely needed. Which implementation is the
BETTER choice and why?
A. Array-based, because contiguous memory enables O(1) access time.
B. Linked-list-based, because insertion and deletion at the front are O(1) without shifting
elements. [CORRECT]
C. Array-based, because resizing is amortized O(1) and faster than pointer manipulation.
D. Both perform identically for front-of-list operations.
Correct Answer: B
Rationale:
A linked list supports O(1) insertion and deletion at the front by simply adjusting the head pointer and one next
pointer—no element shifting is required. An array-based list requires shifting all elements one position to make
(or close) space at index 0, an O(n) operation. Option A is true for access but irrelevant when random access is
rarely needed. Option C is wrong—resizing only helps with append operations and does not avoid the O(n)
front-shift cost. Option D is wrong because front operations have fundamentally different complexities (O(1) vs
O(n)). Tradeoff: linked lists sacrifice O(1) index access and have higher per-node memory overhead (pointers).
Page 3 | WGU C949 Objective Assessment | 70 Questions
WGU C949 Data Structures & Algorithms I
OBJECTIVE ASSESSMENT
Latest Updated Edition | Version 2
Questions & Verified Answers | 100% Correct | Grade A
Course: WGU C949 Data Structures and Algorithms I | Total Questions: 70 | Format: Multiple Choice
Aligned with WGU C949 Course Competencies & Objective Assessment Blueprint (2026-2027)
Sections: Data Types (36%) • Data Structures (30%) • Algorithms (34%)
EXAM INSTRUCTIONS: This Objective Assessment consists of 70 multiple-choice questions divided into
three sections aligned with WGU C949 competencies: Data Types (Q1-Q25), Data Structures (Q26-Q45), and
Algorithms (Q46-Q70). Each question has four options (A, B, C, D) with only ONE correct answer. The
correct answer is identified by the green highlighted option followed by [CORRECT]. A detailed rationale
explaining the correct answer and why other options are incorrect accompanies each question. Cognitive
distribution: 30% recall, 45% application, 25% analysis. Question style: 70% scenario-based, 30% direct
recall/complexity identification. Language-agnostic interpretation (pseudocode samples are conceptual, not
language-specific).
Section 1: Data Types
Primitive Types, Abstract Data Types, Classes, & Type Systems (Q1-Q25)
Q1:
A programmer declares a variable as `float price = 19.99;`. Which characteristic distinguishes this
primitive data type from an Abstract Data Type (ADT) such as a Stack?
A. A float can hold only whole numbers, while an ADT can hold decimal values.
B. A primitive type is a built-in, single-value type defined by the language, while an ADT is
defined by its behavior (operations) rather than its underlying representation. [CORRECT]
C. A primitive type supports method calls, while an ADT does not.
D. A primitive type must always be stored on the heap, while an ADT is stored on the stack.
Correct Answer: B
Rationale:
Primitive types (int, float, boolean, char) are built-in single-value types defined by the language's type system.
An Abstract Data Type (ADT) such as a Stack, Queue, List, or Map is defined by its behavioral contract (the
operations it supports like push/pop) rather than its internal storage representation. The same ADT can be
implemented using an array or a linked list. Floats do store decimal values, but option A is wrong because ADTs
are not defined by what values they hold. Primitive types in most languages do not support method calls (option
C), and storage location depends on the language runtime, not the type classification (option D).
Page 1 | WGU C949 Objective Assessment | 70 Questions
,WGU C949 Data Structures & Algorithms I | Objective Assessment 2026-2027 Version 2 | 100% Verified Answers
Q2:
Which of the following is a key distinction between a primitive data type and an Abstract Data
Type (ADT)?
A. Primitive types are user-defined, while ADTs are language-defined.
B. ADTs encapsulate both data and the operations on that data, exposing behavior through an
interface, while primitive types expose only the value itself. [CORRECT]
C. ADTs use less memory than primitive types because they avoid built-in language overhead.
D. Primitive types can only be used in object-oriented languages, while ADTs work in any paradigm.
Correct Answer: B
Rationale:
An ADT bundles data with the operations that act on that data, exposing behavior through an interface while
hiding the internal representation (encapsulation). Primitive types are language-defined built-in types that expose
only the raw value (option A is backwards). ADTs typically require MORE memory than primitives because they
maintain metadata, pointers, or container overhead (option C is wrong). Both primitives and ADTs can be used
across paradigms (option D is incorrect). Examples of ADTs include List, Stack, Queue, Set, and Map, each
defined by their behavioral contract rather than implementation.
Q3:
A programmer is choosing between an `int` and a `boolean` to represent whether a user is logged
in. Which statement BEST justifies choosing `boolean`?
A. A boolean can represent more states than an int.
B. A boolean most accurately represents the two-state domain (logged in / not logged in),
improving semantic clarity and reducing invalid-state risk compared to a multi-valued int.
[CORRECT]
C. A boolean uses more memory, which improves performance.
D. A boolean can be safely used in arithmetic, while an int cannot.
Correct Answer: B
Rationale:
Choosing the most semantically accurate primitive type (boolean for true/false, int for counting, float for
measurements, char for single characters) improves readability and prevents invalid states. A boolean has only
two possible values (true/false), matching the domain exactly, while an int allows arbitrary integers (e.g., 5, -3)
that have no meaning in the context of login status. Option A is wrong because booleans have fewer states than
ints. Option C is wrong because booleans use less memory (typically 1 byte). Option D is wrong because booleans
cannot be used in arithmetic directly (most languages require explicit conversion).
Q4:
Which of the following is NOT a primitive data type in most mainstream programming languages
(Java, C, Python's core types)?
A. Integer
B. Float
C. String [CORRECT]
D. Boolean
Correct Answer: C
Page 2 | WGU C949 Objective Assessment | 70 Questions
, WGU C949 Data Structures & Algorithms I | Objective Assessment 2026-2027 Version 2 | 100% Verified Answers
Rationale:
In most mainstream languages, Integer, Float, and Boolean are primitive types. String is generally NOT a
primitive type; it is an ADT (often a class or array-backed structure) that bundles character data with operations
like concatenation, length, and substring. In Java, `String` is a class (reference type), not a primitive. In C, there
is no String type at all—only `char` arrays. In Python, `str` is an immutable object type, not a primitive. Treating
String as primitive is a common C949 exam pitfall. A character (`char`) is primitive, but a sequence of
characters is an ADT.
Q5:
A programmer creates a class `BankAccount` with fields `balance` (double) and `accountHolder`
(String), plus methods `deposit()` and `withdraw()`. This is an example of:
A. A primitive data type.
B. An Abstract Data Type (ADT) implemented as a class, encapsulating data and operations.
[CORRECT]
C. A type system error because classes cannot store primitive fields.
D. A function, not a type, because it has methods.
Correct Answer: B
Rationale:
A class that encapsulates both data (balance, accountHolder) and the operations on that data (deposit,
withdraw) is an implementation of an Abstract Data Type. ADTs are defined by behavior rather than
representation; the same ADT could be implemented differently. Option A is wrong because primitive types hold
a single value, not multiple fields with methods. Option C is wrong—classes routinely store primitive fields.
Option D is wrong because methods alone do not prevent a construct from being a type; classes define types. The
principle of encapsulation hides internal state and exposes only the operations through a public interface.
Q6:
A programmer is implementing a List ADT and must choose between an array-based and a
linked-list-based implementation. The application requires frequent insertions and deletions at
the FRONT of the list, but random access by index is rarely needed. Which implementation is the
BETTER choice and why?
A. Array-based, because contiguous memory enables O(1) access time.
B. Linked-list-based, because insertion and deletion at the front are O(1) without shifting
elements. [CORRECT]
C. Array-based, because resizing is amortized O(1) and faster than pointer manipulation.
D. Both perform identically for front-of-list operations.
Correct Answer: B
Rationale:
A linked list supports O(1) insertion and deletion at the front by simply adjusting the head pointer and one next
pointer—no element shifting is required. An array-based list requires shifting all elements one position to make
(or close) space at index 0, an O(n) operation. Option A is true for access but irrelevant when random access is
rarely needed. Option C is wrong—resizing only helps with append operations and does not avoid the O(n)
front-shift cost. Option D is wrong because front operations have fundamentally different complexities (O(1) vs
O(n)). Tradeoff: linked lists sacrifice O(1) index access and have higher per-node memory overhead (pointers).
Page 3 | WGU C949 Objective Assessment | 70 Questions
