Arrays e 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.

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.

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
}

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.

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."

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.

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.

Key Takeaways

• 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.