Why Do Programming Languages Start Counting at 0?

One of the first surprises for new programmers is that the first item in many arrays has an index of 0 instead of 1.

For example, an array containing three values might look like this: ['A', 'B', 'C']. The indexes are commonly 0, 1, and 2.

At first, this can seem strange because people normally count objects starting from 1. But zero-based indexing has several practical advantages, especially when working with memory, ranges, and mathematical operations.

What Is Array Indexing?

An index is a number used to identify the position of an element inside a collection such as an array.

Consider an array containing four values: ['Red', 'Green', 'Blue', 'Yellow'].

With zero-based indexing, the elements are located at indexes 0, 1, 2, and 3.

The index tells the program how far the element is from the beginning of the array. The first element is at an offset of zero from the starting position.

Why Is the First Index 0?

The key idea is that an array index is often treated as an offset rather than a human-style position.

If the first element starts at a particular memory address, its offset from that starting address is 0. The second element is one element away, so its offset is 1. The third element has an offset of 2.

The Connection to Memory

The historical and technical reasons for zero-based indexing are closely connected to how arrays can be represented in memory.

Suppose an array begins at memory address 1000, and each element occupies 4 bytes.

First Element

Index 0 corresponds to an offset of 0 bytes, so the element starts at address 1000.

Second Element

Index 1 corresponds to an offset of 4 bytes, so the element starts at address 1004.

Third Element

Index 2 corresponds to an offset of 8 bytes, so the element starts at address 1008.

The general calculation can be represented as: address = base address + index × element size.

Starting the index at zero makes this formula direct because the first element requires no offset from the base address.

Zero-Based Indexing Represents Offsets

This is one of the most useful ways to think about zero-based indexes.

An index of 0 means no offset. An index of 1 means one element away from the beginning. An index of 2 means two elements away.

The index is therefore not necessarily saying 'this is the first item.' It can be understood as 'this item is this many positions from the beginning.'

Why Does This Matter for Ranges?

Zero-based indexing works particularly well with half-open ranges, where the starting position is included and the ending position is excluded.

For example, a range from 0 to 5 can represent five elements: 0, 1, 2, 3, and 4.

The number of elements is simply 5 - 0 = 5.

The Power of Half-Open Ranges

Suppose an array contains 10 elements. Its valid indexes are 0 through 9.

A range written as [0, 10) describes exactly those 10 elements. The length is calculated as 10 - 0 = 10.

This makes it convenient to split collections into smaller ranges without constantly adding or subtracting one.

Why Does a 10-Element Array End at Index 9?

This often confuses beginners. If an array has 10 elements and indexing starts at zero, the indexes are 0 through 9.

There are still exactly 10 positions because counting the indexes gives ten values.

The highest index is always one less than the number of elements.

For an array with n elements, the valid indexes are generally from 0 through n - 1.

Why Not Start at 1?

One-based indexing is completely reasonable from a human perspective. The first item is 1, the second is 2, and so on.

However, one-based indexing can require additional adjustments when converting between positions, offsets, ranges, and memory addresses.

If the first element has position 1, its zero-byte offset would be position - 1. That introduces an extra subtraction into common calculations.

Zero-Based vs One-Based Indexing

Zero-Based Indexing

The first element is at index 0. This works naturally with offsets and many mathematical range operations.

One-Based Indexing

The first element is at index 1. This can feel more natural when indexes represent human-facing positions.

Which Languages Use Zero-Based Indexing?

Many widely used programming languages use zero-based indexing for arrays or similar sequence types.

Examples include C, C++, Java, JavaScript, Python, Go, Rust, and C#.

The exact indexing behavior can vary for different data structures and language features, so developers should always check the rules of the specific language or collection.

Are There Languages That Start at 1?

Yes. Zero-based indexing is common, but it is not universal.

Some languages and environments use one-based indexing for certain or all array-like structures. For example, Lua commonly uses one-based indexing by convention, while MATLAB and R also use one-based indexing for their standard array indexing.

Why Does C Use Zero-Based Array Indexing?

C is particularly important when discussing zero-based indexing because array indexing is closely related to pointer arithmetic.

An expression such as array[i] can be understood in terms of the address of the first element plus an offset based on i and the element size.

For i = 0, there is no additional element offset. This makes the relationship between array indexing and memory addresses straightforward.

Was Zero-Based Indexing Invented Because of C?

No. Zero-based indexing predates C.

Earlier programming systems and mathematical traditions used zero-based counting or offset-based representations. C helped make zero-based array indexing especially influential because of its close relationship with pointers and memory.

The Mathematical Advantage

Zero-based indexing also fits naturally with mathematical structures such as offsets, sequences, and half-open intervals.

For a sequence of length n, indexes from 0 to n - 1 contain exactly n values. This makes many formulas simpler.

Zero-Based Indexing and String Positions

Strings are often indexed in the same way as arrays.

For the string CODE, the characters can be represented as index 0 = C, index 1 = O, index 2 = D, and index 3 = E.

The length is 4, while the last valid index is 3.

What Is an Off-by-One Error?

An off-by-one error occurs when a program processes one element too many or one element too few because a boundary condition is incorrect.

These errors are common when programmers are learning zero-based indexing because the human concept of 'first' naturally maps to 1, while the programming index maps to 0.

A Common Loop Mistake

Suppose an array has a length of 5. Its valid indexes are 0, 1, 2, 3, and 4.

A loop that continues while the index is less than 5 processes exactly those five indexes. A loop that allows the index to reach 5 attempts to access an element outside the valid range.

Why Zero-Based Indexing Helps With Array Length

The relationship between length and the highest valid index is simple: last index = length - 1.

This relationship is useful because the number of elements and the exclusive upper boundary can use the same value.

The Difference Between Index and Position

A useful mental model is to distinguish between an index and a human-facing position.

The first item has a human position of 1, but its zero-based index is 0.

The second item has a human position of 2, but its zero-based index is 1.

Therefore: index = position - 1.

Does Zero-Based Indexing Make Programming Harder?

It can create a learning curve for beginners, but programmers generally become comfortable with it quickly.

The benefits become clearer when working with loops, memory, ranges, slices, strings, and algorithms.

Zero-Based Indexing in Algorithms

Many algorithms use zero-based indexes because they naturally describe offsets within a data structure.

Sorting, searching, slicing, recursion, and array traversal can all take advantage of the relationship between an index and an element's offset.

Zero-Based Indexing and Slicing

Many languages use a start-inclusive, end-exclusive model for slicing sequences.

For example, a slice from index 2 to index 5 contains indexes 2, 3, and 4. Its length is 5 - 2 = 3.

This makes adjacent ranges easy to reason about because one range can end exactly where the next range begins.

Why Does This Reduce Boundary Problems?

Consider splitting a sequence into two ranges. With half-open ranges, the first range can end at k and the second can begin at k without overlapping.

This gives a clean rule for boundaries and can reduce certain types of off-by-one mistakes.

Is Zero-Based Indexing Always Better?

No. Zero-based and one-based indexing each have contexts where they can feel more natural.

For low-level programming, offsets and memory layouts, zero-based indexing is particularly convenient. For mathematical notation or user-facing positions, one-based indexing can sometimes be more intuitive.

Why Do Humans Usually Count From 1?

Human counting is generally based on ordinal positions. We describe the first object as first, the second as second, and so on.

Programming indexes often serve a different purpose: identifying an offset from the beginning of a collection.

A Simple Mental Model

Think of an array as a row of boxes.

The first box is at offset 0. The second box is one step away, so its offset is 1. The third box is two steps away, so its offset is 2.

This mental model makes zero-based indexing much easier to understand than simply memorizing that 'arrays start at zero.'

Common Beginner Mistakes

1. Assuming the Last Index Equals the Length

If an array has length 10, its last valid index is 9, not 10.

2. Starting Loops at 1

A loop intended to process every element of a zero-indexed array usually needs to begin at index 0.

3. Using the Wrong Upper Boundary

When traversing an array, the index should generally remain below the array's length rather than reaching the length itself.

4. Confusing Position With Index

A user may ask for the first item while the program expects index 0. Keeping positions and indexes conceptually separate helps prevent mistakes.

The Bigger Lesson

Zero-based indexing is not an arbitrary rule created to confuse programmers. It reflects the idea of an index as an offset from the beginning of a data structure.

It also works naturally with memory addressing, mathematical ranges, array lengths, and half-open intervals.

Understanding this idea is more useful than simply memorizing that programming languages start counting at zero.

The Future of Programming Indexing

Zero-based indexing is likely to remain common because it fits naturally with the way many programming languages represent arrays, memory offsets, ranges, and sequence operations.

At the same time, programming languages can choose different indexing conventions depending on their design goals. The important skill for developers is understanding the indexing model of the language and data structure they are using.

Programming languages often start array indexes at 0 because an index can represent an offset from the beginning of a collection. The first element has an offset of zero, the second has an offset of one, and so on.

The simplest way to understand zero-based indexing is to think of indexes as offsets rather than human counting positions. Index 0 means 'zero elements away from the beginning,' while index 1 means 'one element away.'

This convention makes many memory calculations, ranges, loops, and array operations convenient. Once you understand the difference between an index and a position, zero-based indexing becomes much easier to reason about.