What is a list (array)?

A collection of values stored together under one name, each reachable by its position

A single number with many digits

Why use one list instead of many separate variables (score1, score2, score3…)?

A list can be processed with a loop, and can grow without inventing new variable names

Separate variables are not allowed in real programs

What usually happens if a program asks for an index past the end of a list?

An error — often crashing the program

The list grows automatically to fit

The first item is returned instead

What is the standard way to process every item in a list?

A loop that visits each index in turn

Writing one line of code per item

Printing the list and reading it aloud

Select ALL tasks where a list is the natural choice.

Storing the names of everyone in a class

Keeping the daily temperatures for a month

Holding the moves made so far in a game

Lists and Arrays

⏱ 8 min✏️ Quiz at the end

Thirty Variables Is Twenty-Nine Too Many

A variable holds one value. Now store the test scores of a class of thirty. Thirty variables — score1, score2, … score30? Then adding them up takes a thirty-line sum, finding the highest takes a thirty-way comparison, and student thirty-one breaks everything.

The fix is a container built for the job. A list (called an array in many languages) stores many values in order, under one name:

scores ← [12, 7, 19, 3, 15]

One name, five values — or five million. The values keep their order, and each has a numbered position.

Indexing: Finding Item Number i

Each position in a list has an index, and here is the famous quirk: in most programming languages, counting starts at zero.

index:    0    1    2    3    4
scores: [12,   7,  19,   3,  15]

So scores[0] is 12 — the first item — and scores[2] is 19, the third. Zero-based counting feels odd for a week and then becomes second nature. You can read and overwrite by index:

OUTPUT scores[4]      ← prints 15
scores[1] ← 8         ← the 7 becomes an 8

One boundary demands respect: a list of five items has indices 0 to 4. Ask for scores[5] and you are reaching past the end — an out-of-bounds error, and in most languages a crash. Note the pattern: last index = length − 1. Forgetting that "− 1" is the same off-by-one error that haunts loops — the two bugs are cousins.

Lists and Loops: A Perfect Partnership

The real power switches on when lists meet loops. To total the scores, whether five or five million:

total ← 0
FOR i ← 0 TO length(scores) − 1
    total ← total + scores[i]
NEXT
OUTPUT total

The loop counter doubles as the index, visiting every item in turn. Compare the doomed thirty-variable version: this code does not change when the class grows. That is the deep reason lists exist — they let one piece of logic scale to any amount of data.

Every list-processing task you will ever meet is a variation on this loop pattern:

Sum or average — accumulate as you visit
Find the largest — keep a biggest variable, challenge it with each item
Count matches — add 1 whenever the condition holds
Search — stop when you find the target (that is exactly linear search)

And of course sorting algorithms — bubble sort's neighbour-swapping is nothing but index work: comparing scores[i] with scores[i+1].

Lists Hold Anything

Numbers, text, Booleans — anything a variable can hold, a list can hold many of:

names ← ["Aisha", "Ben", "Carlos"]
answers ← [true, false, true, true]

Two related lists can even work as a team: names[i] scored scores[i] — the same index links them. (Real languages offer fancier structures for that job — tables of records — but paired lists are the honest beginning.)

Try It Yourself

In pseudocode, given temps ← [18, 21, 16, 24, 19]:

Output the temperature at index 3 (predict it first!)
Write a loop that finds the hottest value
Write a loop that counts days above 18
Trace your hottest-day loop — does it still work if the list has just one item? None?

Worked Example — Finding the Highest Score, Step by Step

"Find the largest value" is one of the most common list tasks, and it is worth tracing carefully once so the pattern becomes automatic. Given scores ← [12, 7, 19, 3, 15]:

biggest ← scores[0]
FOR i ← 1 TO length(scores) − 1
    IF scores[i] > biggest THEN
        biggest ← scores[i]
    ENDIF
NEXT
OUTPUT biggest

i	scores[i]	scores[i] > biggest?	biggest
(start)			12
1	7	7 > 12? No	12
2	19	19 > 12? Yes	19
3	3	3 > 19? No	19
4	15	15 > 19? No	19

The output is 19. Notice the design decision at the very top: biggest starts as scores[0], not 0. Starting at 0 would silently break the algorithm the moment every score was negative — exactly the boundary-case trap explored in testing programs and trace tables. Starting from the list's own first item, rather than an assumed value, is the safer habit.

Two-Dimensional Lists: A Grid of Lists

Sometimes data naturally forms a grid rather than a single row — a game board, a spreadsheet, an image's pixels. The natural extension is a list of lists: each item of the outer list is itself a list.

grid ← [[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]]

OUTPUT grid[1][2]     ← the row at index 1 is [4, 5, 6]; item at index 2 of THAT row is 6

Visiting every cell of a grid needs a loop inside a loop — one loop for rows, one for columns within each row — which is exactly why lists and nested loops are introduced side by side in this course: one is the data, the other is how you walk across it.

Key Words

List / array — an ordered collection of values under one name
Index — an item's numbered position, usually counted from 0
Out-of-bounds — using an index past the end of the list; a classic crash
length — the number of items; the last index is length − 1
Traversal — visiting every item with a loop