finish part 4

Author: amejiarosario

book/chapters/algorithmic-toolbox.adoc

@@ -0,0 +1,31 @@
+= Algorithmic Toolbox
+
+Have you ever given a programming problem and freeze without knowing where to start?
+Well, in this section we are going to give some tips, so you don't get stuck while coding.
+
+TIP: Don't start coding right away. First, solve the problem, then write the code.
+
+.Steps to solve algorithmic problems
+. *Understand* the requirements. Reframe it in your own words.
+. Draw a *simple example* (no edge cases yet)
+. Brainstorm
+.. How would you solve this problem *manually*? (without a computer) Is there any formula or theorem you can use?
+.. Is there any heuristics (largest, smallest, best ratio) or can you spot a pattern to solve this problem using a <>?
+.. Can you address the simple base case and generalize for other cases using a *recursive solution*?
+.. Do you have to generate multiple solutions or try different paths? Try <>.
+.. If anything else fails, how would you solve it the dumbest way possible (brute force). We can optimize it later.
+. Optimize the solution.
+.. Re-read requirements and see if you can take advantage of anything. E.g. is the array sorted?
+.. Do you have a bunch of overlapping problems? Try <>.
+.. Can you trade-off space for speed? Use a <> to speed up results
+. Test your algorithm with multiple examples
+. *Code*, yes, now you can code.
+.. Modularize your code with functions (don't do it all in one giant function please 🙏)
+. Test your code.
+.. Choose a typical input and test against your code.
+.. Brainstorm about edge cases (empty, null values, overflows,
+.. How would scale your code?
+
+These steps should get you going even with the toughest algorithmic problems.
+
+Stay effective!

book/chapters/algorithms-analysis.adoc

@@ -59,7 +59,7 @@ To give you a clearer picture of how different algorithms perform as the input s
 |Find all permutations of a string |4 sec. |> vigintillion years |> centillion years |∞ |∞
 |=============================================================================================
 
-indexterm:[Permutation]
+indexterm:(((Permutations)))
 However, if you keep the input size constant, you can notice the difference between an efficient algorithm and a slow one. An excellent sorting algorithm is `mergesort` for instance, and inefficient algorithm for large inputs is `bubble sort` .
 Organizing 1 million elements with merge sort takes 20 seconds while bubble sort takes 12 days, ouch!
 The amazing thing is that both programs are measured on the same hardware with the same data!

book/chapters/backtracking.adoc

@@ -1,11 +1,11 @@
 = Backtracking
 (((Backtracking)))
 (((Algorithmic Techniques, Backtracking)))
-Backtracking algorithms are used to find *all (or some)* solutions that satisfy a contraint.
+Backtracking algorithms are used to find *all (or some)* solutions that satisfy a constraint.
 
-Bracktracking builds a solution step by step using recursion.
+Backtracking builds a solution step by step using recursion.
 If during the process it realizes a given path is not going to lead to a solution,
-it stops and step back (backtracking) to try a different alternative.
+it stops and steps back (backtracks) to try another alternative.
 
 Some examples that use backtracking is a solving Sudoku/crosswords puzzle, and graph operations.
 
@@ -14,37 +14,37 @@ image:Sudoku_solved_by_bactracking.gif[]
 endif::backend-pdf[]
 
 Listing all possible solutions might sound like a brute force.
-However, is not the same.
+However, it is not the same.
 Backtracking algorithms are faster than brute force one.
 
-.Brute Force vs Backtracking Algorithms
+.Brute Force vs. Backtracking Algorithms
 ****
-*Brute force* evaluates every possiblity.
-*Bracktracking* is an optimized brute force.
+*Brute force* evaluates every possibility.
+*Backtracking* is an optimized brute force.
 It stops evaluating a path as soon as some of the conditions are broken and move on to the next.
-However, it an only be applied if a quick test can be run to tell if a candidate will contribute to a valid solution.
+However, it can only be applied if a quick test can be run to tell if a candidate will contribute to a valid solution.
 ****
 
 == How to develop backtracking algorithms?
 
-Backtracking algorithms can be tricky to get right or reason about but we are going to follow this recipe to make it easier.
+Backtracking algorithms can be tricky to get right or reason about, but we are going to follow this recipe to make it easier.
 
 .Steps to create backtracking algorithms
-. Iterate through all the elements in the input
+. Iterate through the given input
 . Make a change
-. Recursive function moving to the next element
-. Test if the current change is a solution
-. Revert back the change (backtracking)
+. Recursively move to the next element
+. Test if the current change is a possible solution
+. Revert the change (backtracking) and try with the next item
 
 Let's do an exercise to explain better how backtracking works.
 
 // https://leetcode.com/problems/combination-sum/description/
 
 == Permutations
+(((Permutations)))
+(((Words permutations)))
+> Return all the permutations (without repetitions) of a word.
 
-> Return all the permutations (without repetitions) of a given word.
-
-indexterm:[Permutation]
 For instace, if you are given the word `art` these are the possible permutations:
 
 ----
@@ -58,23 +58,22 @@ For instace, if you are given the word `art` these are the possible permutations
 
 Now, let's implement the program to generate all permutations of a word.
 
-
 NOTE: We already solved this problem using an <>, now let's do it using backtracking.
 
 .Word permutations using backtracking
 [source, javascript]
 ----
 include::{codedir}/algorithms/permutations-backtracking.js[tag=snippet,indent=0]
 ----
-<1> Iterate through all the elements in the input
+<1> Iterate through all the elements
 <2> Make a change: swap letters
 <3> Recursive function moving to the next element
 <4> Test if the current change is a solution: reached the end of the string.
 <5> Revert back the change (backtracking): Undo swap from step 2
 
-As you can see, we iterate through each letter and swap with the following letters until we reach the end of the string. Then, we rollback the change and try another path.
+As you can see, we iterate through each element and swap with the following letters until we reach the end of the string. Then, we roll back the change and try another path.
 
-In the following tree, you can visualize how the backtracking algorithm is swaping the letters.
+In the following tree, you can visualize how the backtracking algorithm is swapping the letters. We are taking the `art` as an example.
 
 [graphviz, Words Permutations, svg]
 ....
@@ -116,12 +115,12 @@ digraph g {
 ....
 
 .Legend:
-- The [red]#red# words are the iterations added to the solution array.
+- The asterisk (`*`) indicates `start` index.
 - *Black* arrows indicate the `swap` operations.
 - *Grey* arrows indicate the _backtracking_ operation (undo swap).
-- The asterisk (`*`) indicates `start` index.
+- The [red]#red# words are the iterations added to the solution array.
 
-Most of backtracking algorihtms do something similar. What changes is the test function to determine if a current iteration is a solution or not.
+Most of the backtracking algorithms do something similar. What changes is the test function or base case to determine if a current iteration is a solution or not.
 
 
 

book/chapters/big-o-examples.adoc

@@ -219,9 +219,9 @@ A factorial is the multiplication of all the numbers less than itself down to 1.
 
 [#factorial-example]
 === Getting all permutations of a word
-
+(((Permutations)))
+(((Words permutations)))
 One classic example of an _O(n!)_ algorithm is finding all the different words that can be formed with a given set of letters.
-indexterm:[Permutation]
 
 .Word's permutations
 // image:image15.png[image,width=528,height=377]

book/chapters/chapter4.adoc

@@ -51,6 +51,9 @@ include::greedy-algorithms.adoc[]
 <<<
 include::backtracking.adoc[]
 
+<<<
+include::algorithmic-toolbox.adoc[]
+
 // --- end algorithms ---
 
 :leveloffset: -1

book/chapters/epigraph.adoc

@@ -1,4 +1,4 @@
 [epigraph]
 = Epigraph
 
-Thanks for reading this book!
+Thanks for reading this book. Stay effective!

book/chapters/greedy-algorithms--knapsack-problem.adoc

@@ -19,7 +19,7 @@ const items = [
 const maxWeight = 7;
 ----
 
-So, we have four items that we can choose from. We can't take them all because the total weight is `13` and the maximum we can carry is `7`. We can't just take the first one because with value `1` because is not the best profit.
+So, we have four items that we can choose from. We can't take them all because the total weight is `13` and the maximum we can carry is `7`. We can't just take the first one because with value `1` because it is not the best profit.
 
 How would you solve this problem?