before refactoring files

amejiarosario · amejiarosario · commit fee24f8d098d · 2019-03-08T17:40:22.000-05:00
diff --git a/book/book.adoc b/book/book.adoc
@@ -185,7 +185,6 @@ include::chapters/greedy-algorithms--knapsack-problem.adoc[]
 
 include::chapters/divide-and-conquer--intro.adoc[]
 
-
 :leveloffset: +1
 
 
diff --git a/book/chapters/algorithms-intro.adoc b/book/chapters/algorithms-intro.adoc
@@ -4,7 +4,7 @@ We are going to start with sorting and searching algorithms, then you are going
 IMPORTANT: There's not a single approach to solve all problems but knowing well-known techniques can help you build your own faster.
 
 .We are going to discuss the following approaches for solving algorithms problems:
-- <<Greedy Algorithms>>: makes choices at each step trying to find the optimal solution.
-- <<Dynamic Programming>>: use memoization for repated subproblems.
+- <<Greedy Algorithms>>: makes greedy choices using heuristics to find the best solution without looking back.
+- <<Dynamic Programming>>: technique for solving problems with *overlapping subproblems*. It uses *memoization* to avoid duplicated work.
+- <<Divide and conquer>>: *divide* problems into smaller pieces, *conquer* each subproblem and then *join* the results.
 - <<Backtracking>>: search all possible combinations until it finds the solution.
-- <<Divide and conquer>>: break problems into smaller pieces and then join the results.
diff --git a/book/chapters/backtracking.adoc b/book/chapters/backtracking.adoc
diff --git a/book/chapters/cheatsheet.adoc b/book/chapters/cheatsheet.adoc
@@ -106,7 +106,7 @@ This section covers Binary Search Tree (BST) time complexity (Big O).
 | Selection sort | O(n^2^)    | O(1)        | Yes    | Yes      | Yes    | Yes      |
 | Bubble sort    | O(n^2^)    | O(1)        | Yes    | Yes      | Yes    | Yes      |
 | Merge sort     | O(n log n) | O(n)        | Yes    | No       | No     | No       |
-| Quick sort     | O(n log n) | O(log n)    | Yes    | No       | No     | No       |
+| Quicksort     | O(n log n) | O(log n)    | Yes    | No       | No     | No       |
 // | Tim sort       | O(n log n) | O(log n)    | Yes    | No       | No     | Yes      | Hybrid of merge and insertion sort
 |===
 
diff --git a/book/chapters/divide-and-conquer--intro.adoc b/book/chapters/divide-and-conquer--intro.adoc
@@ -0,0 +1,15 @@
+Divide and conquer is another strategy for solving algorithmic problems.
+It splits the input into manageble parts recursively and finally join solved pieces to form the end result.
+
+.Examples of divide and conquer algorithms:
+- <<Merge Sort>>: *divides* the input into pairs, sort them and them *join* all the pieces in ascending order.
+- <<Quicksort>>: *splits* the data by a random number called "pivot", then move everything smaller than the pivot to the left and anything bigger to the right. Repeat the process on the left and right side. Note: since this works in place doesn't need a join part.
+- <<logarithmic-example, Binary Search>>: find a value in a sorted collection by *spliting* the data in half until it finds the value.
+- <<Getting all permutations of a word, Permutations>>: *Take out* the first element from the input and solve permutation for the reminder of the data recursively, then *join* results and append the elements that were take out.
+
+We can solve algorithms using D&C algorithms using the following steps.
+
+.Divide and conquer algorithms steps:
+1. *Divide* data into subproblems.
+2. *Conquer* each subproblem.
+3. *Combine* solutions.
diff --git a/book/chapters/divide-and-conquer.adoc b/book/chapters/divide-and-conquer.adoc
diff --git a/book/chapters/dynamic-programming--intro.adoc b/book/chapters/dynamic-programming--intro.adoc
@@ -1,4 +1,4 @@
-Dynamic programming (dp) is a way to solve algorithmic problems by finding the base case and building a solution from the ground-up. We also keep track of previous answers to avoid re-computing the same operations.
+Dynamic programming (dp) is a way to solve algorithmic problems with *overlapping subproblems*. Algorithms using dp find the base case and building a solution from the ground-up. They also _keep track_ of previous answers to avoid re-computing the same operations.
 
 // https://twitter.com/amejiarosario/status/1103050924933726208
 // https://www.quora.com/How-should-I-explain-dynamic-programming-to-a-4-year-old/answer/Jonathan-Paulson
diff --git a/book/chapters/greedy-algorithms.adoc b/book/chapters/greedy-algorithms.adoc
diff --git a/book/chapters/linear-data-structures-outro.adoc b/book/chapters/linear-data-structures-outro.adoc
@@ -16,11 +16,11 @@ To sum up,
 
 .Use a Queue when:
 * You need to access your data in a first-come, first served basis (FIFO).
-* You need to implement a <<Breadth First Search>>
+* You need to implement a <<Breadth-First Search for Binary Tree, Breadth-First Search>>
 
 .Use a Stack when:
 * You need to access your data as last-in, first-out (LIFO).
-* You need to implement a <<Depth First Search>>
+* You need to implement a <<Depth-First Search for Binary Tree, Depth-First Search>>
 
 .Time Complexity of Linear Data Structures (Array, LinkedList, Stack & Queues)
 |===
diff --git a/book/chapters/output.adoc b/book/chapters/output.adoc
@@ -42,7 +42,7 @@ The entire input must be iterated through, and this must occur O(log(n))
 times (the input can only be halved O(log(n)) times). n items iterated
 log(n) times gives O(n log(n)).
 
-== Quick Sort
+== Quicksort
 
 Body text
 
diff --git a/book/chapters/queue.adoc b/book/chapters/queue.adoc
@@ -88,11 +88,11 @@ To sum up,
 
 .Use a Queue when:
 * You need to access your data in a first-come, first served basis (FIFO).
-* You need to implement a <<Breadth First Search>>
+* You need to implement a <<Breadth-First Search for Binary Tree, Breadth-First Search>>
 
 .Use a Stack when:
 * You need to access your data as last-in, first-out (LIFO).
-* You need to implement a <<Depth First Search>>
+* You need to implement a <<Depth-First Search for Binary Tree, Depth-First Search>>
 
 .Time Complexity of Linear Data Structures (Array, LinkedList, Stack & Queues)
 |===
diff --git a/book/chapters/quick-sort.adoc b/book/chapters/quick-sort.adoc
@@ -1,23 +1,23 @@
-= Quick Sort
+= Quicksort
 
-Quick sort is an efficient recursive sorting algorithm that uses "divide and conquer" paradigm to sort faster. It can be implemented in-place so it doesn't require additonal memory.
+Quicksort is an efficient recursive sorting algorithm that uses "divide and conquer" paradigm to sort faster. It can be implemented in-place so it doesn't require additonal memory.
 
 In practice quicksort outperforms efficient sorting algorithms like <<Merge Sort>>. And, of course, It also outperforms simple sorting algorithms like <<Selection Sort>>, <<Insertion Sort>> and <<Bubble Sort>>.
 
-Quick sort basically picks a "pivot" element (preferably random) and move all the elements that are smaller than the pivot to the right and the ones that are bigger to the left. It does this recursively until all the array is sorted.
+Quicksort basically picks a "pivot" element (preferably random) and move all the elements that are smaller than the pivot to the right and the ones that are bigger to the left. It does this recursively until all the array is sorted.
 
-== Quick Sort Implementation
+== Quicksort Implementation
 
-Quick sort implementation uses the divide-and-conquer in the following way:
+Quicksort implementation uses the divide-and-conquer in the following way:
 
-.Quick Sort Algorithm
+.Quicksort Algorithm
 . Pick a "pivot" element (at random)
 . Move everything that is lower than the pivot to the left and everything that is bigger than the pivot to the right.
 . Recursively repeat step 1 and 2, the sub-arrays on the left and on the right WITHOUT including the pivot.
 
 Let's convert these words into code!
 
-.Quick Sort implementation in JavaScript (QuickSort)
+.Quicksort implementation in JavaScript (QuickSort)
 [source, javascript]
 ----
 include::{codedir}/algorithms/sorting/quick-sort.js[tag=quickSort, indent=0]
@@ -29,7 +29,7 @@ include::{codedir}/algorithms/sorting/quick-sort.js[tag=quickSort, indent=0]
 
 The real heavy-lifting is don in the partion function. Let's implement that:
 
-.Quick Sort implementation in JavaScript (partition)
+.Quicksort implementation in JavaScript (partition)
 [source, javascript]
 ----
 include::{codedir}/algorithms/sorting/Quick-sort.js[tag=partition, indent=0]
@@ -41,7 +41,7 @@ include::{codedir}/algorithms/sorting/Quick-sort.js[tag=partition, indent=0]
 
 Merge sort has a _O(n log n)_ running time. For more details about the how to extract the runtime go to <<Linearithmic>>.
 
-== Quick Sort Properties
+== Quicksort Properties
 
 - Time Complexity: [big]#✅# <<Linearithmic>> _O(n log n)_
 - Space Complexity: [big]#⚠️# <<Linear>> _O(n)_
diff --git a/book/chapters/stack.adoc b/book/chapters/stack.adoc
@@ -72,4 +72,4 @@ Implementing the stack with an array and linked list would lead to the same time
 | Stack ^|- ^|- ^|- ^|- ^|O(1) ^|- ^|- ^|O(1) ^|O(n)
 |===
 
-It's not very common to search for values on a stack (other Data Structures are better suited for this). Stacks especially useful for implementing <<Depth First Search>>.
+It's not very common to search for values on a stack (other Data Structures are better suited for this). Stacks especially useful for implementing <<Depth-First Search for Binary Tree, Depth-First Search>>.
diff --git a/book/chapters/tree--search.adoc b/book/chapters/tree--search.adoc
@@ -27,6 +27,7 @@ Why do we care? Well, there are certain problems that you solve more optimally u
 
 Let's cover Breadth-first search (BFS) and Depth-first search (DFS).
 
+[Breadth First Search]
 == Breadth-First Search for Binary Tree
 
 Breadth-first search goeas wide (breadth) before going deep. Hence, the name. In other words, it goes level by level. It visits all the inmediate nodes or children and then move on to the children's children.
@@ -76,6 +77,7 @@ console.log(Array.from(dummyIdMaker())); // [0, 1, 2]
 
 ****
 
+
 == Depth-First Search for Binary Tree
 
 Depth-First search goes deep before going wide. It means, that starting for the root it goes as deep as it can until it found a leaf node (node without children), then it visits all the remaing nodes that were in the path.
diff --git a/book/sample.adoc b/book/sample.adoc
@@ -0,0 +1,41 @@
+include::_conf/variables.adoc[]
+
+= {doctitle}
+
+// remove numbering from titles, and sub-titles e.g. 1.1
+:sectnums!:
+
+// Copyright © 2018 Adrian Mejia (g)
+include::chapters/colophon.adoc[]
+
+// Abstract and Dedication MUST have a level-0 heading in EPUB and Kindle
+// but level-1 in PDF and HTML
+ifndef::backend-epub3[:leveloffset: +1]
+include::chapters/dedication.adoc[]
+ifndef::backend-epub3[:leveloffset: -1]
+
+// (g)
+include::chapters/preface.adoc[]
+
+// add sections to chapters
+:sectnums:
+
+
+//-----------------------------------
+// TODO: commment out sample on final
+//-----------------------------------
+
+include::chapters/sample.adoc[]
+
+//-----------------------------------
+// TODO: end remove ------
+//-----------------------------------
+
+
+// --- end algorithms ---
+
+
+//
+// end chapters
+//
+include::chapters/epigraph.adoc[]

Original file line number	Diff line number	Diff line change
`@@ -185,7 +185,6 @@ include::chapters/greedy-algorithms--knapsack-problem.adoc[]`
`185`	`185`
`186`	`186`	`include::chapters/divide-and-conquer--intro.adoc[]`
`187`	`187`
`188`		`-`
`189`	`188`	`:leveloffset: +1`
`190`	`189`
`191`	`190`
-Original file line number
+Diff line change
 IMPORTANT: There's not a single approach to solve all problems but knowing well-known techniques can help you build your own faster.
 .We are going to discuss the following approaches for solving algorithms problems:
 -- <>: makes choices at each step trying to find the optimal solution.
 -- <>: use memoization for repated subproblems.
 +- <>: makes greedy choices using heuristics to find the best solution without looking back.
 +- <>: technique for solving problems with *overlapping subproblems*. It uses *memoization* to avoid duplicated work.
 +- <>: *divide* problems into smaller pieces, *conquer* each subproblem and then *join* the results.
 - <>: search all possible combinations until it finds the solution.
 -- <>: break problems into smaller pieces and then join the results.
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-Dynamic programming (dp) is a way to solve algorithmic problems by finding the base case and building a solution from the ground-up. We also keep track of previous answers to avoid re-computing the same operations.`
	`1`	`+Dynamic programming (dp) is a way to solve algorithmic problems with overlapping subproblems. Algorithms using dp find the base case and building a solution from the ground-up. They also _keep track_ of previous answers to avoid re-computing the same operations.`
`2`	`2`
`3`	`3`	`// https://twitter.com/amejiarosario/status/1103050924933726208`
`4`	`4`	`// https://www.quora.com/How-should-I-explain-dynamic-programming-to-a-4-year-old/answer/Jonathan-Paulson`