--wip-- [skip ci]

Author: amejiarosario

book/content/part01/algorithms-analysis.asc

@@ -28,15 +28,14 @@ Before going deeper into space and time complexity, let's cover the basics real
 
 Algorithms (as you might know) are steps of how to do some tasks. When you cook, you follow a recipe (or an algorithm) to prepare a dish. Let's say you want to make a pizza.
 
-.Example of an algorithm
+.Example of an algorithm to make pizza
 [source, javascript]
 ----
-import { punchDown, rollOut, applyToppings, Oven } from '../pizza-utils';
+import { rollOut, applyToppings, Oven } from '../pizza-utils';
 
 function makePizza(dough, toppings = ['cheese']) {
     const oven = new Oven(450);
-    const punchedDough = punchDown(dough);
-    const rolledDough = rollOut(punchedDough);
+    const rolledDough = rollOut(dough);
     const rawPizza = applyToppings(rolledDough, toppings);
     const pizzaPromise = oven.bake(rawPizza, { minutes: 20 });
     return pizzaPromise;

book/content/part01/how-to-big-o.asc

@@ -111,6 +111,7 @@ T(n) = n * [t(statement 1) + m * t(statement 2...3)]
 Assuming the statements from 1 to 3 are `O(1)`, we would have a runtime of `O(n * m)`.
 If instead of `m`, you had to iterate on `n` again, then it would be `O(n^2)`. Another typical case is having a function inside a loop. Let's see how to deal with that next.
 
+[[big-o-function-statement]]
 *Function call statements*
 
 When you calculate your programs' time complexity and invoke a function, you need to be aware of its runtime. If you created the function, that might be a simple inspection of the implementation. However, if you are using a library function, you might infer it from the language/library documentation.

book/images/big-o-recursive-example.png

@@ -3,7 +3,8 @@
 
 Data Structures comes in many flavors. There’s no one to rule them all. You have to know the tradeoffs so you can choose the right one for the job.
 
-Even though in your day-to-day, you might not need to re-implementing them, knowing how they work internally would help you know when to use one over the other or even tweak them to create a new one. We are going to explore the most common data structures' time and space complexity.
+Even though in your day-to-day, you might not need to re-implementing them, knowing how they work internally would help you to calculate the time complexity of your code (Remember the chapter <<big-o-function-statement, How to determine Big-O from code?>>).
+Also, when you are aware of the data structures implementations, you spot when to use one over the another or even extend them to create a new one. We are going to explore the most common data structures' time and space complexity.
 
 .In this part we are going to learn about the following linear data structures:
 - <<array-chap>>
@@ -22,6 +23,7 @@ If you want to have a general overview of each one, take a look at the following
 +++
 endif::[]
 
+<<<
 include::content/part02/array.asc[]
 
 <<<
@@ -35,5 +37,3 @@ include::content/part02/queue.asc[]
 
 <<<
 include::content/part02/array-vs-list-vs-queue-vs-stack.asc[]
-
-