Base CS from zero
Data in memory: multiple-choice review
Crux Multiple-choice synthesis across the data-in-memory unit: contiguous layout, index arithmetic, named-field objects, and how references let a fixed-shape container hold variable-shape data.
Your altitude — climbing toward senior
ZeroJuniorMiddleSenior
You are at middle altitude — in the skySix questions that cut across the whole unit. None of them asks you to recite a definition — each asks you to reason about how data actually sits in memory and why the layout behaves the way it does.
Goal
Confirm you can connect the four ideas the unit built: equal-size contiguous cells, the index-to-address formula, named-field objects, and references that let a fixed grid hold variable-size things.
Quiz
Completed
An array of 8 numbers occupies one contiguous block of 32 bytes. Which statement about its layout is correct?
Heads-up An array is contiguous: the elements occupy one continuous block of consecutive addresses, not scattered locations. The array name refers to the single block, specifically where it begins.
Heads-up Every element of a plain array shares one type, so every cell is the same size. The equal-size grid is what defines an array; mixed-size cells would break the regular layout.
Heads-up There are no gaps. Contiguous means the cells sit directly back-to-back; the regularity of a gapless grid is exactly what makes index arithmetic land on the right cell.
Quiz
Completed
Reaching arr[3000] takes the same time as reaching arr[3]. Why is array access constant time?
Heads-up Array access never scans. Scanning would make a large index slower than a small one. The address is computed in one arithmetic step, the same fixed work for every index.
Heads-up No per-element table is stored. The contiguous, equal-size layout lets the address be computed by arithmetic from the base and the index — no table needed.
Heads-up The length is irrelevant: the formula base + i x element_size does not use the length or touch the other elements, so access stays constant time even for ten million elements.
Quiz
Completed
Why is the first element of an array at index 0 rather than index 1?
Heads-up It is forced by the arithmetic, not arbitrary. The formula base + index x element_size makes the first cell's index exactly the one that yields a zero offset, which is 0.
Heads-up Index 0 holds the first real element, not metadata. Its offset is zero, placing it right at the base address; that is precisely why it is the first element.
Heads-up Counting from 0 changes no sizes. It reflects that the index is an element-offset from the start: the first element is zero elements past the base.
Quiz
Completed
An array reaches a value by arr[2]; an object reaches a value by user.age. What is the core difference, and what follows from it?
Heads-up An object's fields are reached by their key, a name, not by a numeric index. Name-based access is the whole point of an object; positional access is the array's property.
Heads-up Object fields have no meaningful order. You reach a field by its key, never by which one comes first. Ordered access is an array property; if order matters, you want an array.
Heads-up They group values differently: an array by position, an object by name. That choice decides whether order carries meaning and whether you index or name to read a value.
Quiz
Completed
You have an array of 100 user objects, each a different size. How does it sit in memory while keeping the array's equal-size contiguous grid?
Heads-up Objects vary in size and can grow, so they cannot fill an equal-size grid. The cells hold references; the objects themselves live separately, wherever memory had room.
Heads-up Cells in an array are uniform in size — that is what makes base + i x element_size valid. The cells hold equal-size references; only the referenced objects vary in size.
Heads-up An array can hold objects by holding references to them. Each cell stores an object's address, and the array stays a normal contiguous array of equal-size cells.
Quiz
Completed
Reading users[1].name in an array of objects takes two hops. What are they, and why two?
Heads-up The array cell holds a reference, not the object. You must follow the address out to the object before you can read a field, which is the second hop.
Heads-up Neither step is a scan. The first hop is one arithmetic computation into the contiguous array; the second is a single reference follow to the object. Both are direct.
Heads-up A field is reached by its key, not by counting positions. It is two hops: arithmetic into the array, then one reference follow to the object where the key locates the field.
Recap
The through-line of the unit is one layered picture. An array is a contiguous run of equal-size cells, so any element’s address is one multiply and one add (base + i x element_size) — constant time, with index 0 forced by a zero offset. An object groups values by name instead of position, so its field order carries no meaning. And because a fixed-size cell cannot hold a variable-size object, cells hold references — equal-size addresses — letting a uniform grid point at variable-shape data elsewhere. Carried all the way, nested data is a graph of cells: some holding values, some holding addresses, wired together.