Merge pull request #91 from amejiarosario/feat/hashmap

feat(book/hashmap): add code examples and patterns

book/D-interview-questions-solutions.asc

@@ -437,7 +437,8 @@ The complexity of any of the BFS methods or DFS is similar.
 :leveloffset: -1
 
 [#hashmap-q-two-sum]
-include::content/part03/hashmap.asc[tag=hashmap-q-two-sum]
+include::content/part02/hash-map.asc[tag=hashmap-q-two-sum]
+// include::content/part03/hashmap.asc[tag=hashmap-q-two-sum]
 
 This simple problem can have many solutions; let's explore some.
 
@@ -480,7 +481,8 @@ include::interview-questions/two-sum.js[tags=description;solution]
 
 
 [#hashmap-q-subarray-sum-equals-k]
-include::content/part03/hashmap.asc[tag=hashmap-q-subarray-sum-equals-k]
+include::content/part02/hash-map.asc[tag=hashmap-q-subarray-sum-equals-k]
+// include::content/part03/hashmap.asc[tag=hashmap-q-subarray-sum-equals-k]
 
 This problem has multiple ways to solve it. Let's explore some.
 

book/content/part02/array.asc

@@ -3,10 +3,11 @@ ifndef::imagesdir[]
 :codedir: ../../../src
 endif::[]
 
+(((Array))) (((Data Structures, Linear, Array)))
 [[array]]
-=== Array [[array-chap]]
-(((Array)))
-(((Data Structures, Linear, Array)))
+[[array-chap]]
+=== Array
+
 Arrays are one of the most used data structures. You probably have used it a lot already. But, are you aware of the runtimes of `push`, `splice`, `shift`, `indexOf`, and other operations? In this chapter, we are going deeper into the most common operations and their runtimes.
 
 ==== Array  Basics
@@ -300,9 +301,7 @@ To sum up, the time complexity of an array is:
 
 Many programming problems involve manipulating arrays. Here are some patterns that can help you improve your problem-solving skills.
 
-(((Patterns, Two Pointers)))
-
-===== Two Pointers Pattern
+===== Two Pointers Pattern (((Patterns, Two Pointers)))
 
 Usually, we use one pointer to navigate each element in an array. However, there are times when having two pointers (left/right, low/high) comes in handy. Let's do some examples.
 
@@ -371,9 +370,7 @@ These two pointers have a runtime of `O(n)`.
 
 WARNING: This technique only works for sorted arrays. If the array was not sorted, you would have to sort it first or choose another approach.
 
-(((Patterns, Sliding Window Pointers)))
-
-===== Sliding Window Pattern
+===== Sliding Window Pattern (((Patterns, Sliding Window))) [[sliding-window-array]]
 
 The sliding window pattern is similar to the two pointers. The difference is that the distance between the left and right pointer is always the same. Also, the numbers don't need to be sorted. Let's do an example!