Strings, Arrays & Hash Tables — Let’s Talk About the One You’re Probably Not Using Enough

[Lomanu4]

If you’ve been coding for a bit, chances are you're already comfortable working with strings and arrays.
You loop through them, slice them, search them, sort them — all good.

So let’s skip the warm-up and jump straight into the one structure that quietly powers a ton of efficient solutions but often doesn’t get the spotlight it deserves:

? Hash Tables (a.k.a. Hash Maps, Dictionaries)


Hash Tables are data structures that store key-value pairs, and they give you constant-time lookups on average — O(1) time complexity for accessing, inserting, and deleting items.

? Why They Matter


Hash Tables are your go-to when you need to:

• Count things (like frequencies of characters or items)
• Track what you’ve seen (e.g., duplicates)
• Map one thing to another (like IDs to objects)

They're elegant, fast, and can simplify problems that otherwise require nested loops.

? Real-World Analogy


Imagine a real-world dictionary:

• You want to look up the word “banana”
• You flip straight to the page and find the definition No scanning every word — just direct access.

That’s what a hash table gives you: instant access via a key.

? Example: Find the First Duplicate


Let’s say you’re given this array:


const nums = [2, 5, 1, 2, 3, 5, 1];

You want to return the first number that appears more than once.
In this case, the answer should be 2, because it's the first value that repeats.

? How would we normally solve it?


A naive way might be to use two loops to compare every element with every other one:


// O(n^2) brute force
for (let i = 0; i < nums.length; i++) {
for (let j = i + 1; j < nums.length; j++) {
if (nums === nums[j]) {
return nums;
}
}
}

But this is inefficient — it checks every possible pair and takes O(n²) time.

Now, let’s use a Hash Table (Set) for an efficient solution


We can use a Set to store the values we’ve already seen.
As we iterate through the array:

• If we haven’t seen the number before, we add it to the set.
• If we’ve already seen it, we return it immediately — that’s our duplicate.

function findFirstDuplicate(nums) {
const seen = new Set();

for (let num of nums) {
if (seen.has(num)) {
return num; // ? Found the first duplicate!
}
seen.add(num);
}

return -1; // No duplicates found
}

This solution is:

• O(n) time — we loop through the array once
• O(n) space — for the Set
• Much easier to understand and maintain

Why this works

• Set is like a quick-access notepad. You ask: “Have I seen this number before?”
• Because lookups in a set are constant time, it’s super fast even with big arrays.

This pattern — using a hash table to track what you've seen — shows up all the time in real-world problems.

TL;DR


You already know strings and arrays — but hash tables are where things start getting really efficient.

If you're learning data structures and algorithms, make sure hash tables are part of your everyday problem-solving toolkit.

They’re your cheat code for clean, scalable code.

That’s it for today!
Hope this helped you see hash tables in a new light.
Happy coding! ?

Пожалуйста Авторизируйтесь или Зарегистрируйтесь для просмотра скрытого текста.