Algorithms and data structures can be intimidating. The goal of this post is to explain some approaches to solving hash table algorithm problems providing clear examples with detailed solution explanations. I’m hoping this will help anyone uninitiated alleviate fears and make bigger strides in conquering these challenging problems.

## Why Hash Tables?

While attending Fullstack Academy, I participated in an algorithms class taught by alumnus Clément Mihailescu, an employee of Google. I found the class to be enlightening and engaging. (I was also star-struck because he works at Google.) He founded AlgoExpert which is a top-notch platform for practicing interview problems. I highly recommend it for those who are serious about acing their interviews. I was inspired by the power of hash tables after the class and went on a journey to solve as many hash table problems as I could find.

## A Brief Introduction to Hash Tables

According to Wikipedia:

In computing, a hash table (hash map) is a data structure which implements an associative array abstract data type, a structure that can map keys to values. A hash table uses a hash function to compute an index into an array of buckets or slots, from which the desired value can be found.

Ideally, the hash function will assign each key to a unique bucket, but most hash table designs employ an imperfect hash function, which might cause hash collisions where the hash function generates the same index for more than one key. Such collisions must be accommodated in some way.

To the uninitiated, this explanation may seem high-falutin. Fortunately, if you’ve worked with objects in JavaScript, you’ve already worked with an associative array data type.

``````// association: a "key" maps to a "value"
// in this case, "b" is the key and "2" is the value:
const mapB = {b: 2}

// using .reduce() to count the occurrence of characters:
// association: character: number
const count = Array.from('aabbccddeee').reduce((accumulator, char) => {
if (char in accumulator) {
accumulator[char]++
} else {
accumulator[char] = 1
}
return accumulator
}, {})

// result:
// {a: 2, b: 2, c: 2, d: 2, e: 3}
``````

### Hashing Functions

JavaScript, being a high-level language, abstracts away some of the hash function details. The “unique buckets” referred to above are a contiguous array where each index (bucket) is a point of destination for data.

To point data to the right “bucket”, a hashing function is used. The function allows us to:

• calculate a unique (mostly) hash address from a given “key”
• use this hash address to put a “key” in the same “bucket” and access it from there every time we need to

In the case where collisions are minimized, searching a hash table is an O(1) operation. That’s amazing in terms of efficiency! See below for more on “Big-o” and in-depth hash table lessons.

### Coding Challenge Sites: Leetcode, Hackerrank, Codewars, and more

There are many great “code challenge” websites to practice at computer science problems. When I wanted to work more with hash tables, I discovered that LeetCode has a tagging system which links to 81 hash table problems!

Other great sites for coding challenges:

• HackerRank my general favorite. The “Data Structures” and “Algorithms” tracks are phenomenal. I also enjoyed “10 Days of JavaScript.”
• Codewars - has an excellent community and platform, as well as some very fun problems.

## Summary of Approaches

After solving around 6 problems of various difficulty on LeetCode, I observed some general principles and forms:

• Hash tables allow for very fast, O(1), lookups. If my solution to a problem was “timing out,” I was probably over-using array methods.
• Nested `for` loops (which have O(n^2) time efficiency) can often be alleviated with hash tables.
• It’s often necessary to make two passes through an array to gather the hash table data to allow for complete processing.
• It’s sometimes possible to make a single pass if by the end of the pass, you have all the data you need for processing.

Javascript objects (what I’ve used for hash tables) are extremely versatile. I was able to implement them with the following patterns:

• a “map” of one data type to another: `{a: 'dog'}`
• the “visited” pattern: `{1: true}`. You can also use a `Set` for this.
• the “count” or “accumulator” pattern: `{a: 2, b: 12}`. This can be implemented with `.reduce()` or a simple `for` loop.

## Word Pattern (tagged as ‘Easy’)

Link to problem & description: Word Pattern - LeetCode

Basic Gist: If a pattern (like ‘abba’) matches an input string (like ‘dog cat cat dog’) then it’s a match. (‘dog cat cat fish’ wouldn’t be a match.)

My Solution Stats: Status: Accepted. 33 / 33 test cases passed. Runtime: 48 ms

``````/**
* @param {string} pattern
* @param {string} str
* @return {boolean}
*/
var wordPattern = function(pattern, str) {
if (pattern === '' || str === '') return false;
const arrStr = str.split(' ');
if (arrStr.length !== pattern.length) return false;
let patternHash = {};
let wordHash = {};
for (let i = 0; i < arrStr.length; i++) {
if (!patternHash.hasOwnProperty(pattern[i]) && !wordHash[arrStr[i]]) {
// add the pattern letter to hash table, mapped to current word
patternHash[pattern[i]] = arrStr[i];
// make sure current word is accounted for
wordHash[arrStr[i]] = true;
} else {
// check if the word in the pattern hash matches the current word
if (patternHash[pattern[i]] !== arrStr[i]) {
return false;
}
}
}
return true;
};
``````

Explanation:

• the first 3 lines are guards against invalid input and split the input `str` into an array which was separated by spaces.
• `patternHash` and `wordHash` will keep track of slightly different things. (I’ll explain as I go.)
``````// patternHash example: { a: 'dog', b: 'cat' }
// wordHash example: { dog: true, cat: true }
``````
• we use a `for` loop to iterate over the entire input string as array.
• the first `if` block checks 2 things have NOT happened yet:
1. if we’ve mapped a word to a letter in the pattern string.
2. if we’ve accounted for the current word - which is `arrStr[i]`.
• if neither has happened, we can safely initialize both hashes. (as described above).
• `else` block: now is the moment of truth. If `patternHash[pattern[i]]` doesn’t match up with `arrStr[i]`, we can definitively `return false`. We don’t have an exact match of pattern to words.
• finally, if the `for` loop has completed, we can safely `return true`. We have a match!

Reflection: This certainly works, but I can probably do this with only one hash table. `{dog: true}` doesn’t have extra meaningful data and between my two hashes, I store each word twice.

## Two Sum (tagged as ‘Easy’)

Link to problem & description: Two Sum - LeetCode

Basic Gist: Given an array of integers, return indices of the two numbers such that they add up to a specific target. (target could be 9, for example.)

My Solution Stats: 19 / 19 test cases passed. Status: Accepted. Runtime: 84 ms

``````/**
* @param {number[]} nums
* @param {number} target
* @return {number[]}
*/
var twoSum = function(nums, target) {
let hashed = {};
nums.forEach((n, i) => {
if (!hashed.hasOwnProperty(n)) {
hashed[n] = i;
} else {
hashed[n] = [hashed[n], i]
}
});
let hashedKeys = Object.keys(hashed);
let i = 0;
for (i; i < nums.length; i++) {
let subtractor = target - +hashedKeys[i];
if (subtractor in hashed) {
let check = hashed[hashedKeys[i]];
if (!Array.isArray(check)) {
return [check, hashed[subtractor]];
} else {
return check.slice(0,2);
}

}
}
};
``````

Explanation:

• I begin by initializing a hash object to store the numbers as unique keys. For the values, each number key initially maps to its index. If there are multiples of a number key, I store an array of the indices. Each value can only be used once, so this prepares for the solution format (which asks for an array of two indices).
• `hashedKeys` is the hash converted to an array of its keys.
• the `for` loop iterates over all the numbers in the array. Everything below runs inside the loop.
• the `subtractor` is the number we’re looking for to add with the current number to see if it adds up to the `target`. I saved it in a variable for easier readability going forward.
• Now for the main `if` block which checks if the `subtractor` is present in the hash.
• the `check` variable will be type checked.
• If we have a number, that means it’s unique and we can return in the array format requested.
• If it’s an array, that means the values are equivalent, and we can return what we initially stored. I do a slice to ensure that it’s the correct length.

Reflection: I worked on this problem 5 months before working on it recently. I unknowingly created an O(n^2) algorithm by using `indexOf` to check the entire array sliced at each index as I iterated over it. The runtime was 548 ms (more than 5 times slower than the hash solution.) I think I can improve my hash solution by implementing it without `Object.keys(hash)`. I can’t actually explain (at the moment) why I used that, and didn’t use `nums[i]`.

Note: I used the “Two Pass” solution. Read more about that and other solutions here: Two Sum - LeetCode Articles. It may be locked until you’ve solved it yourself.

## Single Number (tagged as ‘Easy’)

Link to problem & description: Single Number - LeetCode

Basic Gist: Given an array of integers, every element appears twice except for one. Find that single one.

My Solution Stats: 15 / 15 test cases passed. Status: Accepted. Runtime: 84 ms

``````/**
* @param {number[]} nums
* @return {number}
*/
var singleNumber = function(nums) {
let once = new Set();
nums.forEach(num => {
if (!once.has(num)) {
} else {
once.delete(num);
}
});
return Array.from(once);
};
``````

Explanation:

• I realized I could use a `Set` to handle storing unique numbers and for fast lookup.
• Using a `forEach` loop:
• The first time a number has been seen, I store it in the `once` set.
• If the number had been seen before, I delete it from the `once` set.
• Assuming our inputs are valid, we return the only element in the `once` set. We get to it by converting it to an array with `Array.from()` and getting the `` element.

Reflection: Initially, I created two hashes to make sure the algorithm was running correctly. I realized I could use a `Set` later and and simply delete the `num` entry in `once`, without storing it in `twice`. Oddly enough, my runtime went from 64ms to 84ms with the `Set` implementation. Maybe objects are optimized to run more quickly than sets (?)

Note: there is a very nice solution explanation here: Single Number - LeetCode Articles. It may be locked until you’ve solved it yourself.

## Set Mismatch (tagged as ‘Easy’)

Link to problem & description: Set Mismatch - LeetCode

Basic Gist: You have to find where “an error occurred.” Any given input will have a number missing and a number duplicated. Example: `[1,2,2,4]`

My Solution Stats: 49 / 49 test cases passed. Status: Accepted. Runtime: 84 ms

``````/**
* @param {number[]} nums
* @return {number[]}
*/
var findErrorNums = function(nums) {
let visited = {};
let result = [null, null];
let max = 0;
for (let i = 0; i < nums.length; i++) {
let current = nums[i];
if (!visited[current]) {
visited[current] = true;
} else {
// current is the duplicated number
result = current;
}
if (current > max) {
max = current;
}
}

current = max;
while (current > 1) {
let oneBefore = current - 1;
if (!visited[oneBefore]) {
// oneBefore is the skipped number
result = oneBefore;
return result;
}
current--;
}
if (!result) {
result = max + 1;
return result;
}
return result;
};
``````

Explanation:

• This problem was difficult to optimize because the input numbers were not necessarily sorted. There were a few short cases that needed to be accounted for. Note: `result` is the duplicated number and `result` is the missing number.
• input `[2,2]` expected `[2,1]` output.
• input `[1,1]` expected `[1,2]` output.
• I’ll describe further down how I accounted for this.
• `visited` is our initialized hash. We’ll set a given number as a key and ‘true’ as the value to keep track of us visiting the number.
• `result` is an array initialized with 2 `null` values. This way, I was forcing myself to update it without having an accidental solution.
• `max` is the highest number in the array. I wanted to avoid sorting, so the highest number in the array would be where I search from to find the missing number. More below.
• the `for` loop iterates over all the numbers.
• If the number isn’t in `visited`, add it to it.
• If the number is in `visited`, it’s the duplicated number. We save it as `result`.
• I check all numbers and store it in `max` if it’s the highest so far.
• The `while` loop begins at `max` and traverses downward.
• `oneBefore` is our search, it’s simply the current number - 1.
• If we don’t see `oneBefore` in `visited`, it’s the missing number! We can assign it to our result and return it.
• If we do see it, we simply go down and try `current--`.
• After this `while` loop, we now account for the case where both numbers are 1. We know that `result` should be one number higher than max.

Reflection: I feel like the efficiency of the algorithm is quite good. I only store what’s necessary. Keeping track of the edge cases was a bit cumbersome for me. I’m sure there’s a graceful way to do it without the final check that I do.

Official Solution: Set Mismatch - LeetCode Articles

• Note: It may be locked until you try to solve it!

## Longest Harmonious Subsequence (tagged as ‘Easy’)

Link to problem & description: Longest Harmonious Subsequence - LeetCode

Basic Gist: Return the length of the longest sequence of 2 unique numbers which are consecutive. Example subsequences: `[3,2,2,2,3]`, `[3,2,3,2,3]`, `[3,3,3,2,2,2]`. (Other numbers in between aren’t counted.) (This one’s a bit difficult to summarize, so check out the problem description.)

My Solution Stats: 201 / 201 test cases passed. Status: Accepted. Runtime: 108 ms

``````/**
* @param {number[]} nums
* @return {number}
*/
var findLHS = function(nums) {
let hash = {};
let current;
let i;
let max = 0;
let maxCheck1 = 0;
let maxCheck2 = 0;
for (i = 0; i < nums.length; i++) {
current = nums[i];
if (current in hash) {
hash[current]++;
} else {
hash[current] = 1;
}
if (hash[current + 1]) {
maxCheck1 = hash[current] + hash[current + 1];
}
if (hash[current - 1]) {
maxCheck2 = hash[current] + hash[current - 1];
}
max = Math.max(max, maxCheck1, maxCheck2);
}

return max;
};
``````

Explanation:

• The `hash` in this problem stores a number as unique key and the number of times it occurs as the value.
• I initialized all the variables outside of the loop. It isn’t necessary to do it this way, I just felt like it.
• The `for` loop is the main scene of this algorithm. I iterate over all of the numbers in the input array.
• The current number is stored in the `current` variable.
• The first `if` block checks if the current number is in the hash table. If so, we increase it’s value by 1. If not, we initialize it to be 1.
• The second `if` block checks if the current number plus 1 is in the hash table. If so, we store the total number of occurrences of `current` and `current + 1` in the `maxCheck1` variable. (This will be used soon below.)
• The third and final `if` block checks if the current number minus 1 is in the hash table. If so, we store the total number of occurrences of `current` and `current - 1` in the `maxCheck2` variable. (This will be used soon below.)
• `max` is the maximum of `max`, `maxCheck1`, and `maxCheck2`. `max` represents the length of the longest sequence.

Reflection: I first implemented this solution in 2 passes. After seeing the official solution, I decided to wrangle mine into the single pass version. There’s even more I could do to clean it up, but I’m pretty happy with it.

Official Solution: Longest Harmonious Subsequence - LeetCode

• Note: It may be locked until you try to solve it!

## Parting Notes

I’m no expert at algorithms in general, but I’m definitely enjoying learning about them. The more I learn, the more I’m able to visualize different approaches to problems and begin to optimize my solutions. Please contact me below if you have comments about this article and/or suggestions for improvement.

This “enrichment piece” was written as a student at Fullstack Academy.