AI & Engineering Academics›✏️ AI Sketch›Lessons›Arrays and Hash Maps

📦

AI Sketch • Intermediate⏱️ 15 min read

Arrays and Hash Maps

Why Data Storage Matters in AI

Every AI system needs to store and retrieve data - quickly. Whether it's a list of pixel values in an image, a vocabulary of 50,000 words, or millions of user preferences, the choice of data structure determines how fast your AI can think.

Two structures dominate: arrays and hash maps. Master these, and you've got the foundation for nearly every AI pipeline.

Arrays - Ordered Lists with Instant Access

An array is simply a numbered list of items stored side by side in memory. Each item has an index - its position in the list, starting from zero.

index:   0       1       2       3       4
value: ["cat", "dog", "bird", "fish", "frog"]

Because items sit next to each other, you can jump straight to any position. Want item 3? Done - no searching required. That's O(1) access, meaning it takes the same time whether the array holds 10 items or 10 million.

An array of five elements with indices 0 through 4, showing direct access to index 3 — Arrays let you jump directly to any position using its index.

When Arrays Shine

Feature vectors: An image might be represented as an array of 784 numbers (28×28 pixels), each holding a brightness value.
Embeddings: Language models store word meanings as arrays of hundreds of floating-point numbers.
Batch processing: Training data is loaded into arrays so the GPU can process thousands of examples simultaneously.

The Catch

Inserting or removing items in the middle is expensive. Every item after the change must shuffle along. That's O(n) - the more items, the longer it takes.

🤔

Think about it:

If you had a playlist of 10,000 songs and wanted to insert a new track at position 5, every song from position 5 onwards would need to shift. How might a streaming service handle this without slowing down?

Hash Maps - Instant Lookups by Name

A hash map (also called a dictionary or hash table) stores data as key-value pairs. Instead of accessing items by index number, you access them by a meaningful key.

word_counts = {
  "hello": 42,
  "world": 37,
  "AI": 156
}

Lesson 1 of 100% complete

←Back to program

Discussion

Suggest an edit to this lesson

Need the count for "AI"? The hash map uses a hash function to convert the key into an index behind the scenes. The result? O(1) average lookup time - just like arrays, but using names instead of numbers.

🤯

Python's dictionaries are hash maps. When ChatGPT counts word frequencies during training, it uses hash-map-like structures to track billions of word occurrences across the entire internet's text.

Real AI Uses for Hash Maps

Vocabulary mapping: Turning words like "brilliant" into token ID 8921 for a language model.
Frequency counting: How often does each word appear in a dataset? Hash maps answer this in one pass.
Caching results: If an AI has already computed a prediction for input X, store it so you never recompute.

Time Complexity Made Simple

| Operation | Array | Hash Map | |-----------|-------|----------| | Access by index | O(1) ⚡ | N/A | | Access by key | O(n) 🐢 | O(1) ⚡ | | Insert at end | O(1) ⚡ | O(1) ⚡ | | Insert in middle | O(n) 🐢 | N/A | | Search for value | O(n) 🐢 | O(1) ⚡ |

Think of O(1) as "instant, no matter the size" and O(n) as "slower the bigger the data."

🧠Quick Check

You have 100,000 user profiles and need to find a user by their username. Which structure is fastest?

Common Pattern: Frequency Counting

One of the most useful patterns in both interviews and AI is counting occurrences. Here's the idea in pseudocode:

counts = {}
for each word in text:
    if word in counts:
        counts[word] = counts[word] + 1
    else:
        counts[word] = 1

This single pass through the text gives you every word's frequency. Language models use exactly this approach (at massive scale) to understand which words matter most.

Common Pattern: The Two-Sum Problem

Given an array of numbers and a target, find two numbers that add up to the target. The naive approach checks every pair - O(n²). The clever approach uses a hash map:

seen = {}
for each number in array:
    complement = target - number
    if complement in seen:
        return [seen[complement], current_index]
    seen[number] = current_index

One pass, O(n) time. The hash map remembers what you've already seen.

🧠Quick Check

Why is the hash map approach to two-sum faster than checking every pair?

When to Choose Which

Use arrays when order matters, you access items by position, or you need to process everything sequentially (like pixels in an image).
Use hash maps when you need fast lookups by a key, want to count occurrences, or need to check if something exists quickly.

🤔

Think about it:

A recommendation engine needs to check whether a user has already watched a film before suggesting it. Would you store the user's watch history in an array or a hash map? What trade-offs come to mind?

🧠Quick Check

An AI model stores word embeddings as arrays of 300 numbers each. Why are arrays a good choice here?

Arrays give O(1) access by index and are the backbone of numerical AI (images, embeddings, tensors).
Hash maps give O(1) access by key and are essential for lookups, counting, and caching.
Choosing the right structure can turn an O(n²) algorithm into an O(n) one - a difference that matters when processing millions of data points.
In practice, most AI pipelines use both: arrays for numerical computation and hash maps for metadata lookups.

AI Foundations

AI Mastery

Career Ready

Lab

Arrays and Hash Maps

Why Data Storage Matters in AI

Arrays - Ordered Lists with Instant Access

When Arrays Shine

The Catch

Hash Maps - Instant Lookups by Name

Discussion

Real AI Uses for Hash Maps

Time Complexity Made Simple

Common Pattern: Frequency Counting

Common Pattern: The Two-Sum Problem

When to Choose Which

Key Takeaways