AutoCAD Quiz: Array Item Replacement
10 questions · exam conditions
0:00
Array Item ReplacementQuestion 1 of 10

In an associative rectangular array, each original item is a chair block whose insertion point is at the center of its seat. A replacement workstation block has its insertion point at a distant corner, but the workstation must be centered at the chair's current array position.

During Replace Item, what should the drafter do to obtain the required alignment without moving the completed array afterward?

Specify the workstation's intended center as the replacement base point before selecting the array item.
Specify the workstation's distant insertion point and then reset the replaced array item.
Change the array's overall base point to the workstation's intended center before replacement.
Specify the chair block's insertion point as the base point of the replacement geometry.
← Back to quizzes

AutoCAD Quiz

AutoCAD Quiz: Array Item Replacement

Practice Array Item Replacement in AutoCAD with focused quiz questions that help you check what you know, review explanations, and build confidence with test-style prompts.

What this quiz covers

This quiz focuses on Array Item Replacement, giving you a quick way to practice the rules, question types, and explanations that matter most for AutoCAD.

How to use this quiz

Try each quiz question before looking at the correct answer. Use the explanations to review missed ideas, then come back to similar questions until the pattern feels familiar.

All questions

Question 1

In an associative rectangular array, each original item is a chair block whose insertion point is at the center of its seat. A replacement workstation block has its insertion point at a distant corner, but the workstation must be centered at the chair's current array position.

During Replace Item, what should the drafter do to obtain the required alignment without moving the completed array afterward?

  1. Specify the workstation's intended center as the replacement base point before selecting the array item. (correct answer)
  2. Specify the workstation's distant insertion point and then reset the replaced array item.
  3. Change the array's overall base point to the workstation's intended center before replacement.
  4. Specify the chair block's insertion point as the base point of the replacement geometry.
Explanation: When using Replace Item in an associative array, AutoCAD aligns the replacement block to the original item's position using a base point you define during the replacement process. Think of this base point as the anchor — it's the point on the new block that AutoCAD will snap to the array item's insertion point. Your goal is to choose a base point on the replacement block that corresponds to where you want the replacement to land, not necessarily the block's own insertion point. In this scenario, the chair's insertion point sits at its seat center, and each array slot is positioned around that center. You want the workstation centered at that same location. The solution is to specify the workstation's intended center as the replacement base point (answer A). AutoCAD will then align that chosen point to the chair's array slot — achieving perfect centering automatically, with no post-placement adjustment needed. Answer B is wrong because using the workstation's distant insertion point as the base point would misalign it — the corner, not the center, would snap to the array position. Resetting the replaced item doesn't fix a flawed base point choice. Answer C is a misconception: changing the array's overall base point controls how the entire array moves or scales, not how individual replacement items align. Answer D is close but backwards — using the chair's insertion point as the replacement geometry's base point doesn't make sense here because you're setting the base point on the new block, not referencing the old one's coordinates. Study tip: On array replacement questions, always ask "which point on my new block should land on the array slot?" — that's your base point.

Question 2

A 20-item associative array represents ceiling fixtures. At two item positions, the drafter uses Replace Item and selects a three-object emergency-light assembly as the replacement geometry.

Which description of the resulting array is most accurate?

  1. The array now contains 24 item positions because each replacement contributes two additional objects.
  2. The two positions become detached geometry, while the remaining 18 positions stay in the array.
  3. The array retains 20 item positions, with two positions containing multi-object replacement overrides. (correct answer)
  4. All 20 positions change to the emergency-light assembly because the source item was redefined.
Explanation: When working with AutoCAD arrays, it helps to understand the difference between the array structure and the item content. An associative array maintains a fixed number of item positions regardless of what geometry occupies those positions — that structure is controlled separately from the objects assigned to each slot. The Replace Item tool lets you substitute custom geometry at specific positions while leaving the array's overall architecture intact. When a drafter replaces two items with a three-object emergency-light assembly, AutoCAD simply assigns that multi-object cluster as an override at those two positions. The array still tracks exactly 20 positions — it's the content at two of them that has changed, not the count or the association. This makes C the most accurate description: 20 item positions remain, with two carrying multi-object replacement overrides. Answer A is wrong because Replace Item never adds item positions to compensate for additional objects in replacement geometry. The array count is determined by the original creation settings, not by object quantity inside any item. Answer B confuses Replace Item with the Detach command. Detaching removes items from the array's associativity, but Replace Item keeps the position within the array — it just swaps what's there. Answer D describes what would happen if you edited the array's source object itself, which would propagate changes to all positions uniformly. Replace Item, by contrast, creates a localized override at specific positions only. A good rule of thumb: in AutoCAD arrays, position count and item content are independent concepts. Questions that mix them up are testing whether you understand that distinction — keep those two ideas separate and you'll navigate array questions confidently.

Question 3

A source door symbol is used throughout an associative array. One array position was replaced with a window symbol. Later, the drafter edits the array's original source door by adding a clearance line and saves the source-editing changes.

Which outcome is expected after the source edit is saved?

  1. Every position, including the replaced window, becomes the modified door source.
  2. Only the replaced window receives the clearance line because it is the active override.
  3. The standard door items update, while the window remains as a replacement override. (correct answer)
  4. No array item updates until the replacement override is reset manually.
Explanation: When working with associative arrays in AutoCAD, you need to understand how source edits and item overrides interact — they follow separate rules and don't cancel each other out. In an associative array, editing the source object propagates changes to all array items that still follow the source. However, when you manually replace an array item — like swapping a door symbol for a window — that position becomes an override. Overrides are intentional departures from the source, and AutoCAD treats them as independent. This is exactly what makes C correct: after saving the source edit (adding the clearance line), every standard door position updates to reflect the modified door, but the window replacement remains untouched because it has already been detached from the source's control through its override status. Answer A is wrong because it assumes the source edit "resets" all positions back to the door — it doesn't. The window override survives the source propagation. Answer B reverses the logic entirely, suggesting the override position receives the update while others don't — the opposite of how propagation works. Answer D incorrectly implies that the presence of any override freezes the entire array from updating, which is not true; non-overridden items update normally regardless of what other positions are doing. A good tip to remember: in AutoCAD's associative arrays, think of overrides as locked exceptions — source edits flow around them, not through them. On exam questions, if you see a mix of standard items and replacements, ask yourself which items are still "listening" to the source.

Question 4

In a six-column associative rectangular array, the item in column 3 is replaced by a special terminal unit. The drafter then increases the array to eight columns without resetting any overrides.

Assuming the parameter change does not eliminate the replaced position, which outcome is most likely?

  1. The terminal override remains in its position, and the new columns use the standard source item. (correct answer)
  2. The terminal becomes the source for both new columns because it was the last edited array item.
  3. The replacement is removed automatically because changing a count clears all item overrides.
  4. The array becomes non-associative because item replacement prevents later count changes.
Explanation: When working with associative arrays in AutoCAD, the key concept to understand is how item overrides interact with structural parameter changes. An associative array tracks each item's position independently, and overrides — such as replacing one item with a different block — are stored per-position, not globally. In this scenario, column 3 has been manually replaced with a terminal unit. That replacement is an item-level override tied specifically to that grid position. When you increase the column count from six to eight, AutoCAD adds new columns using the original source object — the array's base item — not any overridden variant. The override at column 3 simply persists untouched because the new columns don't interact with it. This makes A the correct outcome: the terminal stays where it was, and the two new columns populate normally from the source item. B is incorrect because AutoCAD does not designate the "last edited" item as a new source. Overrides affect individual positions only — they don't propagate to new positions. C reflects a common misconception: changing a count parameter does not clear item overrides. Overrides survive count changes as long as their positions still exist in the new configuration. D is also wrong — replacing an individual item does not break associativity. The array remains associative, and structural parameters like column count remain editable regardless of item-level overrides. A useful rule of thumb: in AutoCAD, item overrides are position-bound and parameter-change-resistant. Unless you explicitly reset the override or the position is eliminated by the new configuration, the override survives.

Question 5

An associative array consists of references to block definition SEAT-A. One position must display a reference to block definition SEAT-ACCESSIBLE, while all non-array references to SEAT-A elsewhere in the drawing must remain unchanged.

Which method best satisfies the requirement?

  1. Redefine SEAT-A using the geometry from SEAT-ACCESSIBLE, then regenerate the array.
  2. Explode the array, swap one block reference, then regroup all resulting seat objects.
  3. Use Replace Item on the required position and select a SEAT-ACCESSIBLE block reference. (correct answer)
  4. Insert SEAT-ACCESSIBLE directly on top of the target item and erase the underlying SEAT-A reference.
Explanation: When working with associative arrays in AutoCAD, the key distinction to understand is that an associative array treats all its items as a unified, intelligent object — not a collection of independent block references. This means you can't simply edit one item the way you would a standalone block without understanding the tools built specifically for array manipulation. The Replace Item grip tool (or the ARRAYREPLACEITEM command) is designed exactly for this scenario: it lets you substitute a single array item with a different block reference while keeping the rest of the array intact and associative. In this case, selecting the required position and pointing to a SEAT-ACCESSIBLE block reference swaps only that one item, leaving all other SEAT-A references — both inside and outside the array — completely untouched. That makes C the correct answer. A is a destructive choice. Redefining SEAT-A would update every instance of that block in the entire drawing, which directly violates the requirement to leave non-array references unchanged. B exploding the array destroys its associativity permanently. You'd lose all array intelligence, and "regrouping" objects into a Group is not the same as restoring an associative array — this approach is both irreversible and incorrect. D layering SEAT-ACCESSIBLE on top of a SEAT-A reference is a sloppy workaround that leaves a hidden, redundant object in the drawing. It's not a proper substitution and creates data integrity problems. Study tip: Any time an exam question involves changing one item in an associative array without affecting the rest, think Replace Item — it's AutoCAD's purpose-built solution for selective array substitution.

Question 6

To simulate a replacement, a technician copies a valve symbol onto one position of an associative array and leaves the original array item underneath it. The array is then edited to increase its spacing.

Why is this workflow less reliable than using Replace Item?

  1. The copied valve is not an item override, so it may not follow the array while the original item remains present. (correct answer)
  2. The copied valve becomes the new array source, so every item may change when spacing is edited.
  3. The copied valve automatically explodes the array, so spacing can no longer be modified associatively.
  4. The copied valve is an erased-item override, so changing spacing restores the original source automatically.
Explanation: When working with associative arrays in AutoCAD, the key concept to keep in mind is the difference between a true item override and simply placing an object on top of an existing array item. An associative array tracks its items internally — only objects that are recognized as part of the array (or as overrides to specific positions) will respond predictably when the array is edited. When a technician copies a valve symbol and manually positions it over an array item, that copied object is just a free-floating entity in the drawing. It has no relationship to the array whatsoever. Meanwhile, the original array item still exists underneath it. When the array spacing is edited, the original item moves with the array as expected — but the copied valve stays exactly where it was placed, since the array has no knowledge of it. This is precisely what A describes, making it the correct answer: the copy is not an item override, so it won't follow the array, and the original item remains present and active. B is wrong because copying an object near an array item does nothing to the array's source object — the source can only be changed through specific array editing commands. C is incorrect because simply placing a copied object nearby does not explode or disassociate the array. D is fabricated — there is no "erased-item override" behavior that automatically restores source items when spacing changes. As a study tip, remember that in AutoCAD, association requires intent — only actions performed through the array's own editing tools (like Replace Item) create true overrides. Anything placed manually outside those tools is invisible to the array's logic.

Question 7

Several supports in an associative path array were replaced by heavier support symbols. The path curve is later reshaped, but the array remains associated with that path.

What should happen to the heavier support replacements when the path array updates?

  1. They remain at their old coordinates because replacement items are detached from path updates.
  2. They follow their associated item positions along the revised path while retaining replacement geometry. (correct answer)
  3. They convert to standard supports because editing the path resets all item-level replacements.
  4. They redefine the path array's source, causing all supports to become the heavier type.
Explanation: When working with AutoCAD path arrays, you need to understand two separate but cooperative systems: array association (the path controls item positions) and item-level replacement (individual items can be swapped for different geometry). Questions like this test whether you know these two systems operate independently without canceling each other out. In an associative path array, each item maintains a position index tied to a location along the path curve. When you reshape the path, AutoCAD recalculates those indexed positions along the new geometry. Crucially, item replacements are stored as overrides at the item level, not at the path level — so the replacement geometry travels with its associated position index. This is exactly why B is correct: the heavier support symbols keep their replacement geometry while their positions recalculate along the revised path. A is wrong because replacement items are not detached from path updates — their positions still belong to the associative array and move with it. Only the geometry has been overridden, not the positional relationship. C describes behavior that doesn't exist in AutoCAD; reshaping a path does not trigger a reset of item-level overrides — those are independent properties. D confuses item replacement with redefining the array's source block. Replacing individual items is a localized override and has no effect on the array's base source object. A useful mental model: think of each array item as having two properties — where it sits (controlled by the path) and what it looks like (controlled by item overrides). Editing the path only changes "where," never "what." Keep this separation in mind for any question involving associative arrays with custom replacements.

Question 8

A designer selects what appears to be a rectangular array of equipment symbols. The objects can be selected and edited individually, but selecting one does not display an Array contextual ribbon tab. The designer must replace one symbol without changing the others.

Which action best preserves the ability to perform array-item replacement and make later array-wide parameter changes?

  1. Group the existing objects, then replace the required member while editing the group.
  2. Recreate the layout as an associative array from the source geometry, then use Replace Item on the required position. (correct answer)
  3. Convert the existing objects into a single block, then redefine only the required block reference.
  4. Set ARRAYASSOCIATIVITY to 1, then replace one of the existing individual objects directly.
Explanation: When you encounter a question about editing arrays in AutoCAD, the first thing to ask yourself is: does this array have associativity? An associative array behaves as a single intelligent object — it remembers its source geometry, item count, spacing, and lets you swap individual items using the Array contextual ribbon. A non-associative array is simply a collection of independent copies with no memory of their origin. The passage is describing a non-associative layout — objects that look like an array but lack the contextual ribbon tab. The only way to regain full array intelligence (item replacement via Replace Item and parameter editing like row/column count and spacing) is to recreate the layout as a proper associative array. That's exactly what B prescribes: rebuild from source geometry, then use Replace Item to swap only the target position. This preserves all future editability through the Array ribbon. A is tempting but misses the point — grouping objects organizes selection but adds zero array intelligence. You cannot change row spacing or replace items array-wide through a group. C converting everything to a block is also a dead end; redefining a block reference changes all instances of that block, not just one position, and still provides no array-parameter control. D is the most dangerous trap: ARRAYASSOCIATIVITY only affects newly created arrays going forward — it cannot retroactively convert existing independent objects into an associative array. As a study tip, remember: associativity must exist at creation time. If the Array contextual tab is missing, the associativity is already gone, and no system variable or grouping trick restores it — you must rebuild.

Question 9

An associative array has three custom changes: one item was erased, one item was moved with an item-level override, and one item was replaced by different geometry. The drafter then applies Reset to the array.

What result should the drafter expect?

  1. Only the erased item returns; the moved and replaced items retain their overrides.
  2. The erased item returns, and the moved and replaced items revert to standard array items. (correct answer)
  3. The entire array is deleted and regenerated using the current replacement geometry as its source.
  4. The moved item returns to position, but the erased and replaced items remain unchanged.
Explanation: When working with associative arrays in AutoCAD, it helps to understand what "associative" really means: the array maintains a live relationship between its items and the source object, governed by array parameters. Item-level overrides — like moving, erasing, or replacing individual items — are tracked as exceptions layered on top of that underlying structure. The Reset command's job is to strip those exceptions away and restore every item to its default position and appearance within the array. That's exactly why B is correct. Reset removes all item-level overrides across the board: the erased item is restored because its deletion was an override, the moved item snaps back to its array-defined position, and the replaced item reverts to the original source geometry because the replacement was itself an override. None of the three changes survive a Reset. A is wrong because it implies Reset is selective — restoring only erasures while leaving positional and replacement overrides intact. Reset doesn't cherry-pick; it clears all item-level overrides simultaneously. C describes behavior that doesn't exist in AutoCAD. Reset does not delete and regenerate the array using replacement geometry as a new source. The source object is unchanged by Reset; only the item overrides are cleared. D gets it backwards — it suggests the moved item is restored while erased and replaced items are left alone. In reality, all three override types are treated equally by Reset. A useful study cue: think of Reset as an "undo overrides" command. Any change made at the item level — erase, move, or replace — is undone. Changes to the array's source object or global parameters are unaffected.

Question 10

A drafter replaces two members of an associative path array with inspection markers. To deliver individual objects, the drafter then explodes the array. A later revision requires returning one marker position to the original source item.

Which statement best describes the available workflow after the explosion?

  1. Use Reset on the marker object, because replacement override history remains attached to exploded items.
  2. Use Replace Item with the original source geometry, because exploded objects retain their array item indices.
  3. Edit the associated path curve first, which will automatically reactivate associativity for all exploded members.
  4. Edit or replace the geometry manually, or recreate an associative array to regain item-level controls. (correct answer)
Explanation: Whenever you see a question about AutoCAD arrays, the critical concept to keep in mind is the difference between associative and non-associative (exploded) arrays — because explosion is a one-way door that strips away all array intelligence. An associative path array stores its items as a single smart object with editable properties: you can replace individual items, reset overrides, and modify the path. However, once you explode the array, AutoCAD dissolves that unified structure into independent, ordinary objects. Those objects carry no memory of their former array roles — no item indices, no override history, no connection to the source geometry or path curve. The only way forward is to manually edit or replace the geometry at that position, or to rebuild a new associative array from scratch if you need those controls again. That makes D the correct answer. A is wrong because Reset and other array-level commands require an active associative array object. Exploded geometry is just standalone objects — Reset has nothing to attach to. B is wrong because item indices are a property of the array object itself, not of the individual pieces after explosion. Once exploded, those objects have no index awareness whatsoever. C is wrong because editing the path curve only affects an existing associative array. After explosion, there is no associativity to reactivate — the path curve becomes just another unlinked drawing element. A good rule of thumb: treat exploding an array as a permanent commitment. Before exploding, ask yourself whether you might need item-level edits later — if so, keep the array associative.