FC0-U71 Software Development Concepts Practice Question
A junior developer is learning about data structures. The developer needs to choose a data structure for the following scenarios: - Storing a list of items where order matters and items can be accessed by index. - Storing key-value pairs for fast lookups. Which TWO data structures should the developer consider?
⚠ Common exam trap
FC0-U71 often tests basic data structure properties; candidates might incorrectly select a tree for key-value lookups due to its efficiency, but trees are not the primary structure for that purpose unless balanced and ordered.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Dictionary
Option C (Array) is correct because an array stores elements in a defined, ordered sequence and allows direct access to each item by its numeric index, which exactly matches the requirement of a list where order matters and items are retrieved by position. Option A (Dictionary) is correct because a dictionary stores data as key-value pairs and provides fast lookups by key, typically with average O(1) access time in hash-based implementations, matching the key-value lookup scenario. Option B (Tree) is not the best fit here because, although trees can support ordered data and key-based search, they are hierarchical structures used for scenarios like sorted data, ranges, or balanced search rather than simple indexed lists or direct key-value lookup. Option D (Stack) does not belong because it is a LIFO structure that only allows access to the most recently added item, not indexed access or key-based lookup. Option E (Queue) is also incorrect because it is a FIFO structure that only allows removal of the oldest item, so it does not support index access or fast key-value retrieval.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✓
Dictionary
Why this is correct
A dictionary stores key-value pairs and provides fast lookups by key, satisfying the second scenario's requirement. Unlike index-based structures, it maps unique keys directly to values, giving average constant-time retrieval. This makes it the appropriate choice for the key-value lookup requirement, while a list handles the ordered, index-accessed scenario.
- ✗
Tree
Why it's wrong here
A tree stores hierarchical relationships and offers no positional indexing, so it cannot serve the ordered, index-accessed list requirement. It is tempting because balanced trees underpin ordered key-value lookups, and would be correct when the requirement is sorted traversal or range queries rather than direct index access.
- ✓
Array
Why this is correct
An array stores elements in contiguous memory with integer indices, giving O(1) positional access, which directly satisfies the requirement that order matters and items are retrievable by index. Its fixed ordering preserves insertion sequence, unlike hash-based structures that sacrifice positional ordering for key lookup speed.
- ✗
Stack
Why it's wrong here
A stack permits last-in-first-out access at the top only, so it provides neither index-based retrieval nor key-value lookup. It is tempting because stacks preserve a form of order, and would be correct when the requirement is reversing sequences, undo operations or depth-first traversal rather than accessing items by index.
- ✗
Queue
Why it's wrong here
A queue enforces first-in-first-out access at its ends only, exposing no index-based retrieval and no key-value mapping. It is tempting because queues preserve insertion order, and would be correct when the requirement is ordered processing such as task scheduling or breadth-first traversal rather than random access by position.
Go deeper
Related to this question
About these practice questions
This FC0-U71 question is part of Courseiva's 988-question bank — original exam-style content with full explanations and wrong-answer analysis, never real exam questions or exam dumps. Learn why practice questions differ from exam dumps →
JA
Written and reviewed by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
Last reviewed September 2026 · checked against the official CompTIA exam blueprint
This FC0-U71 practice question is part of Courseiva's free CompTIA certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the FC0-U71 exam.