Array Stride Access

Array stride access visits elements with a fixed step between consecutive indices. A stride of $1$ scans every element. Larger strides skip elements and may reduce cache locality.

You use it when data is sampled, stored in interleaved form, or traversed by columns in row-major storage.

Problem

Given an array $A$ of length $n$ and a stride $s$ , process indices:

0, s, 2s, 3s, \dots

while the index remains less than $n$ .

Algorithm

Scan with a fixed stride:

stride_scan(A, s):
    if s <= 0:
        error "stride must be positive"

    i = 0
    while i < length(A):
        process A[i]
        i += s

Example

Let

A = [8, 3, 5, 1, 9, 4, 2]

and

s = 2

The scan visits:

step	index	value
1	0	8
2	2	5
3	4	9
4	6	2

Visited sequence:

[8, 5, 9, 2]

Correctness

The algorithm starts at index $0$ and adds $s$ after each access. Since $s > 0$ , the index increases monotonically. The loop condition ensures that every accessed index satisfies $0 \le i < n$ .

Thus the algorithm processes exactly the positions of the form $ks$ that lie inside the array.

Complexity

The number of visited elements is:

\left\lceil \frac{n}{s} \right\rceil

operation	time
stride scan	$O(n / s)$
worst case, $s = 1$	$O(n)$

Space usage:

O(1)

When to Use

Stride access is appropriate when:

processing every kth element
reading interleaved data
sampling an array
traversing columns in flat matrix storage

It is less suitable when sequential locality matters and all elements must be processed. In that case, prefer contiguous traversal.

Implementation

def stride_scan(a, stride, process):
    if stride <= 0:
        raise ValueError("stride must be positive")

    i = 0
    while i < len(a):
        process(a[i])
        i += stride

func StrideScan[T any](a []T, stride int, process func(T)) bool {
    if stride <= 0 {
        return false
    }

    for i := 0; i < len(a); i += stride {
        process(a[i])
    }

    return true
}