Merge pull request #59 from 0xadb/typos

Removed typos and duplicates

Author: justinmeiners

01_data_structures.md

@@ -135,7 +135,7 @@ Whomever really wants to learn, will learn, and that is a challenge because it i
 a room of programmers know it's going to be an empty set. 
 That doesn't mean that you as an individual person doesn't know things, but intersection is going to be relatively small.
 
-Unfortunatly we've got to a point where nobody teaches programming.
+Unfortunately we've got to a point where nobody teaches programming.
 Because there's no professor of computer science who has any idea how to program[^teaching-programming].
 Part of what I am trying to do here is to start discussing
 little things like, how do we name variables?
@@ -159,7 +159,7 @@ C++ treats `main` as a special function; meaning when the control goes
 through the last brace, zero is returned.
 Because the standard UNIX convention, which became Universal
 convention, that on success you return zero. 
-The language actually allows you to do things things like that.
+The language actually allows you to do things like that.
 
 One warning, [`cout`][cout] stuff works pretty much like how you think it works.
 However a friend of mine wrote something like:
@@ -209,7 +209,7 @@ When we narrowed things down we always found something
 pertaining to incorrect use of STL[^about-stl].
 It's usually a one liner and the most egregious.
 
-The most most amazing thing is the following one liner which I will start in the
+The most amazing thing is the following one liner which I will start in the
 beginning of the course, because it was just so important.
 We could weave the whole fabric of the course around this one little example.
 There was a range of integers. For example:
@@ -251,7 +251,7 @@ Equality gives us linear search while sorting gives us binary search so we can f
 One of the amazing things which we will discover is that ordering is very important.
 Things which we could do with ordering cannot be effectively done just with equality[^cl-mistake].
 
-If we are going by the book we we will say sorting is good as long it does approximately `O(n log(n))` operations.
+If we are going by the book we will say sorting is good as long it does approximately `O(n log(n))` operations.
 This is good for the books.
 It's actually not good for our code, because Big O
 could have an arbitrary coefficient.
@@ -464,7 +464,7 @@ specific type.
 This is very good, we have to have that.
 But then we also need to have times for specific commonly used types.
 So these are two things which we need to do.
-Our goal is to to be able to measure this problem with `set` and with sort.
+Our goal is to be able to measure this problem with `set` and with sort.
 But, first we need to learn more about C++.
 
 [red-black]: https://en.wikipedia.org/wiki/Red%E2%80%93black_tree

02_regular_types.md

@@ -26,7 +26,7 @@ So, I'm not even going to mention Yahoo (joke).
 I did interview at Facebook and let me tell you what I saw of that place... 
 That was five years ago.
 Maybe they improved but I don't think so.
-Places tend to to decline.
+Places tend to decline.
 
 You might say: "Who are you to tell us?"
 I am as guilty as any of you. 
@@ -261,7 +261,7 @@ to `TotallyOrdered`.
 
 **Axiom 3:** Anti-symmetric: If `a < b` then `!(b < a)`.
 
-**Axiom 4:** If `a != b` then `a < b` or ` b > a`.
+**Axiom 4:** If `a != b` then `a < b` or `b > a`.
 
 In the same way that the semantics of `==` is related to `!=`,
 we can see the semantics of `<` must be totally bound to the semantics of equality.

03_singleton.md

@@ -264,7 +264,7 @@ people think invented C++ are idealized in books like "Effective C++",
 He tells you always declare destructor as virtual[^scott-virtual].
 OK, he's wrong. Simple as that.
 
-What we do we want to create? Take type `T`, put it in a struct. Will the size of the thing increase?
+What do we want to create? Take type `T`, put it in a struct. Will the size of the thing increase?
 No. It has no overhead. 
 Singleton is the same size as `T`.
 It's the wonderful thing about singleton, and lets you pack them in arrays.
@@ -395,7 +395,7 @@ They were not copyable and you couldn't pass them as arguments.
 Then they fixed it. 
 They said, "we'll just copy the bits" and things would work.
 
-Equality is defined for all built-in types; `int`, `double`, `short`, `char`, pointers, etc.
+Equality is defined for all built-in types: `int`, `double`, `short`, `char`, pointers, etc.
 So, if you have a struct, why can't you generate an equality that uses those?
 Two things are equal if all their members are equal.
 It's a sensible rule a compiler could do. 

04_instrumented.md

@@ -324,7 +324,7 @@ Everything has its place, Dijkstra's strictures not withstanding[^goto].
 
 
 [^goto]: Goto used to be the primary way to do control flow in programs,
-    because it closely resembles how how machines and their languages work.
+    because it closely resembles  how machines and their languages work.
 
     For example, to implement a `while` loop, you might write:
 

05_swap.md

@@ -120,7 +120,7 @@ programs are:
 
 1. `swap`: takes two things and swaps them.
 2. `min`: takes two things and figure out which one is smaller.
-2. `linear search`: goes through a bunch of stuff and finds the one you want.
+3. `linear search`: goes through a bunch of stuff and finds the one you want.
 
 Aren't these too simple?
 If we cannot do simple things, it is very unlikely we will be able to do hard things.
@@ -133,7 +133,7 @@ I claim exciting things tend to be very simple and basic.
 So you say, "Alex, why don't we use a new language?"
 Go try implementing these three program in your favorite language.
 Do them in a general way.
-If they're at least relatively efficient, that is, they are not slower than specific things  written in the language, then let us talk.
+If they're at least relatively efficient, that is, they are not slower than specific things written in the language, then let us talk.
 If you cannot do it, let us stick with C++.
 I'm just explaining the reasoning behind my choice of C++.
 
@@ -182,7 +182,7 @@ You deny the utility of swap.
     A **group** is a set `G` with a binary operation `* : G x G -> G` such that:
 
     1. `G` contains an identity element `e` in `G` such that `e * x = x * e = x` for all `x` in `G`.
-    2. The operation `*` is associative. So `((x * y) * z)  = (x * (y * z))` for all `x, y, z` in `G`.
+    2. The operation `*` is associative. So `((x * y) * z) = (x * (y * z))` for all `x, y, z` in `G`.
     3. Every element `x` in `G` has an inverse element `y` such that x * y = y * x = e.
 
     For example integers are a group with the operation of addition and the identity element 0.

06_min_max.md

@@ -48,7 +48,7 @@ It's guaranteed.
 
 **Axiom 3:** Anti-symmetric: If `a < b` then `!(b < a)`.
 
-**Axiom 4:** If `a != b` then `a < b` or ` b > a`.
+**Axiom 4:** If `a != b` then `a < b` or `b > a`.
 
 This is also called the trichotomy law,
 because for all elements, exactly one of three things must be true[^eop-ordering]:
@@ -97,7 +97,7 @@ Because for `TotallyOrdered` we need to be able to know
 
 The `==` is equality, not another equivalence relation.
 We can't conclude that with a weak ordering.
-We must overloaded symbols for what they commonly mean.
+We must overload symbols for what they commonly mean.
 
 [^eop-ordering]: Alex recommends chapter 4 of "Elements of Programming"
     to learn more about this subject.
@@ -344,7 +344,7 @@ Every time I talk to one member of the standard
 committee he always says, "Alex you are too theoretical".
 I guess I am because I pay attention to
 these little details.
-But I claim to be able to to show you that
+But I claim to be able to show you that
 things like that will matter. 
 
 Later we will generalize it on a bunch of things.

07_min_range.md

@@ -186,7 +186,7 @@ So it must be a `ForwardIterator`.
 
 ## Finding min and max together
 
-How many comparisons do we need to to find the min of five elements?
+How many comparisons do we need to find the min of five elements?
 Four.
 In general why do we need `n - 1` comparisons.
 Why no more? We don't need to compare an element with itself.

10_binary_counter.md

@@ -230,7 +230,7 @@ we're just rebalancing parentheses[^min-not-commutative].
     We distinguish between the left and right argument.
 
 [^associativity]: A binary function `f` is [associative](https://en.wikipedia.org/wiki/Associative_property)
-    if the the following holds for all `a, b, c` in its domain:
+    if the following holds for all `a, b, c` in its domain:
 
         f(f(a, b), c)) = f(a, f(b, c))
 
@@ -265,7 +265,7 @@ we're just rebalancing parentheses[^min-not-commutative].
         * * * * *     * * *
                       * * *
 
-    Or as [Dirchlet][dirichlet] put it: "Whether you arrange soldiers in rows or columns, you still have the same number of soldiers".
+    Or as [Dirichlet][dirichlet] put it: "Whether you arrange soldiers in rows or columns, you still have the same number of soldiers".
 
     An example of an operation which is not commutative is string concatenation. 
 
@@ -281,7 +281,7 @@ They should have taught it in high school.
 But, they want to publish papers themselves and not tell you the general mechanism.
 
 Let us assume we have elements of type `T` that need to be paired or combined in some way,
-whether with `min`, `+`, `merge`, or any other assocative operation on `T`.
+whether with `min`, `+`, `merge`, or any other associative operation on `T`.
 What we can do is create an array called a "counter".
 
        index: 0  1  ...   31
@@ -323,12 +323,12 @@ Otherwise `x` wins:
 
 What if the index `1` slot was non-zero, after comparing `x` and `y`?
 Then the guy there already won one game.
-So, we must **carry propogate**[^adder-circuit].
+So, we must **carry propagate**[^adder-circuit].
 Repeat the same process all the way up the counter, until we find a slot which is zero.
 What if the counter is full, and has no zero slots?
 That's called an **overflow**.
 
-We borrow terminology from binary integer arithemtic because
+We borrow terminology from binary integer arithmetic because
 our counter works just like a binary integer counting up:
 
     0 0 0
@@ -340,7 +340,7 @@ our counter works just like a binary integer counting up:
     0 1 1
     1 1 1
 
-But instead of 0 and 1 in each slot or "bit" we have arbitary elements that are combined with an associative operation.
+But instead of 0 and 1 in each slot or "bit" we have arbitrary elements that are combined with an associative operation.
 
 ### Handling overflow
 
@@ -363,7 +363,7 @@ on type `T` and what we discovered is if we have associativity,
 we can make this counter and it will work for us.
 
 [^adder-circuit]: The terms **carry** and **overflow**
-    are closely associated the implementation of binary counting
+    are closely associated with the implementation of binary counting
     or addition as an electrical circuit, called an [adder][adder].
 
     A single bit adder has two inputs `a` and `b` for
@@ -383,7 +383,7 @@ we can make this counter and it will work for us.
         1  1 | 1  0
 
     This adds a single digit, but we want to add entire numbers.
-    To, do so we add an additional input `l` for carried digits
+    To do so we add an additional input `l` for carried digits
     from lower place values.
 
         a  b  l    c  s
@@ -405,7 +405,7 @@ we can make this counter and it will work for us.
 
     An **overflow** is when the last adder has a non-zero carry.
 
-[^errors]: Floating point arithemetic can involve many tricky details,
+[^errors]: Floating point arithmetic can involve many tricky details,
     but the basic issue Alex is referring to is straightforward.
     We often use scientific notation to write larger numbers as a decimal to a power,
     when they would otherwise be very long to write out.
@@ -573,8 +573,8 @@ We could compete with Steve Jobs for elegance of our design[^alex-apple-joke].
 
 **Exercise:** Rewrite `min_element` using this code (just `min_element`, don't worry about second best).
 
-**Exercise:**  If you want to implement [merge sort][merge-sort] you can use exactly the same device, since merge is associative. The idea with merge sort, is you only want to merge lists if they are roughly the same length and this helps you do it (see Chapter 12).
-    Write the associtative binary operation `merge` which can combine two sorted arrays into a sorted array.
+**Exercise:** If you want to implement [merge sort][merge-sort] you can use exactly the same device, since merge is associative. The idea with merge sort, is you only want to merge lists if they are roughly the same length and this helps you do it (see Chapter 12).
+    Write the associative binary operation `merge` which can combine two sorted arrays into a sorted array.
 
 **Exercise:** When we become grownups we learn about advanced data structures, such as [binomial forest][binomial]. They use the same idea. Learn about this data structure and try to figure out where
     the counter could be used. 

11_min_1_2.md

@@ -31,20 +31,20 @@ for your future work.
 I pick this algorithm because it allows us to learn how to do decomposition
 and learn these components like `list_pool` and `binary_counter` along the way.
 
-Let me sketch the grand plan of the whole alogorithm.
+Let me sketch the grand plan of the whole algorithm.
 
-1. We already showed that we want to arrange our comparisons like a tennis tournmant,
+1. We already showed that we want to arrange our comparisons like a tennis tournament,
 and `binary_counter` helps us do this.
 Instead of comparing by left reduction, we compare by balanced reduction.
 
 2. We also want to keep a history for each element of all
    the other elements which they have beat.
    This history will be used to determine the second-place guy.
 
-    We will store this history in a list (using `list_pool`)
-    along with each element in the binary counter.
-    Note that the counter works on generic elements, so it doesn't
-    need to be modified to know about this history tracking.
+   We will store this history in a list (using `list_pool`)
+   along with each element in the binary counter.
+   Note that the counter works on generic elements, so it doesn't
+   need to be modified to know about this history tracking.
 
 From where we are now, it should only take 4-5 lines of code
 to write `min_element_1_2` along with type scaffolding.
@@ -100,7 +100,7 @@ Now define the pool. We do know its type:
 Notice that we use `std::min_element` on our list pool.
 Will that work?
 Yes, because we added iterators to our list pool.
-Define our `iterator` type;
+Define our `iterator` type:
 
     typedef typename list_pool<I, std::size_t>::iterator iterator;
 
@@ -201,7 +201,7 @@ we can define the final missing types and the signature:
 
       typedef op_min1_2<I, size_t, compare_type> op_type;
       typedef binary_counter<op_type> counter_type;
-      typedef typename op_type::argument_type  result_type;
+      typedef typename op_type::argument_type result_type;
 
       // ...
     }
@@ -238,7 +238,7 @@ brought up this example:
 
 Obviously what you are trying to do is extract `T`'s `value_type`
 and use it here.
-Let us try to to follow the committees logic.
+Let us try to follow the committees logic.
 The logic says maybe `T::value_type` refers to a static variable
 in `T`, which it could be of course.
 But, don't you know from the context that it's supposed to be a type?

12_merge_sort.md

@@ -18,7 +18,7 @@ I wanted this job really badly.
 A friend of mine who
 worked at this Institute recommended me to this group.
 I knew I was going to go
-there for for an interview and I'd have to say some wonderful things or they
+there for an interview and I'd have to say some wonderful things or they
 would not give me a job.
 Right before my interview, terrible thing happened.
 I ate some raw fish and it was very tasty but within
@@ -56,8 +56,8 @@ there is this thing called associativity.
 I realized that this idea will work as long as the operation is associative.
 
 This became my central theme.
-how could I talk about associative operations?
-how could I write algorithms like that?
+How could I talk about associative operations?
+How could I write algorithms like that?
 When I came to United States somewhere along the way,
 maybe in Austria, I realized that merge was associative
 It was a very big deal because I never even thought about merge in terms of `+` and `*`, but merge is associative.
@@ -141,13 +141,13 @@ There are several [iterator concepts][cpp-iterator-concepts] in STL[^sgi],
 all of which we have mentioned before:
 
 - [`InputIterator`][cpp-input-iterator]: can only advance forward and once advanced, iterators pointing to previous elements become invalid. 
-- [`ForwardIterator`][cpp-forward-iteartor]: can advance forward and have iterators pointing to previous elements.
+- [`ForwardIterator`][cpp-forward-iterator]: can advance forward and have iterators pointing to previous elements.
 - [`BidirectionalIterator`][cpp-bi-iterator]: can move iterators forward and backward.
 - [`RandomAccessIterator`][cpp-random-iterator]: can advance iterators by arbitrary steps in constant time (like pointers).
 
 [cpp-iterator-concepts]: https://en.cppreference.com/w/cpp/iterator
 [cpp-input-iterator]: https://en.cppreference.com/w/cpp/named_req/InputIterator
-[cpp-forward-iteartor]: https://en.cppreference.com/w/cpp/named_req/ForwardIterator
+[cpp-forward-iterator]: https://en.cppreference.com/w/cpp/named_req/ForwardIterator
 [cpp-bi-iterator]: https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator 
 [cpp-random-iterator]: https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator 
 
@@ -220,9 +220,9 @@ on a built-in type instead of a class.
 
         foo(x,y)
 
-    However Alex doesn't follow this convention:
+    However Alex doesn't follow this convention.
 
-[^member-functions-on-primtives]: Other programming languages, such as Swift, allow you to extend primitive types like `int` with additional member functions.
+[^member-functions-on-primitives]: Other programming languages, such as Swift, allow you to extend primitive types like `int` with additional member functions.
 
 [iterators-must-go]: https://accu.org/conf-docs/PDFs_2009/AndreiAlexandrescu_iterators-must-go.pdf
 
@@ -338,7 +338,7 @@ inheritance, smart pointers, or read certain books.
 Now I'm going to teach you to use `goto`.
 The greatest authority in computer science wrote a famous letter to
 communications of ACM called, ["Go To Statement Considered Harmful"][harmful].
-There is is nothing harmful in the computer.
+There is nothing harmful in the computer.
 The computer is good.
 It has an instruction called [JMP][jump] (or branch).
 If it's there, why not use it?
@@ -475,7 +475,7 @@ Modern processors try to predict which
 way a condition is going to go.
 If you look at our branches, the probability
 of going one way or the other is 50 percent.
-That's literally the worst thing which which could happen.
+That's literally the worst thing which could happen.
 I'm entering the territory where I haven't done work yet.
 I haven't tried see whether some kind of predication avoidance of `goto`
 could be done.
@@ -498,7 +498,7 @@ There is no code, it's just a way of invoking our merge function.
 It has 5 arguments, and we need a binary function.
 
     template <typename I, typename Compare>
-    // I is Linked Iteratork
+    // I is Linked Iterator
     struct mergesort_linked_operation
     {
       typedef I argument_type;

13_searching.md

@@ -271,7 +271,7 @@ Once upon a time I believed ranges come in two kinds[^eop-range-kinds].
 
 1. **Bounded ranges**: Ranges bounded by a first and last iterator/pointer.
 2. **Counted ranges**: Ranges constructed from a first pointer/iterator and an 
-    interger `N`.
+    integer `N`.
 
 Which one is better?
 Both are good, and both are different.
@@ -322,7 +322,7 @@ So let's try writing `find_if_n`
     Everyone loves to make non-standard names.
 
 [^wrapper]: I find this comment amusing because
-    Alex just got done talking about why `find_if_not`was such a helpful contribution
+    Alex just got done talking about why `find_if_not` was such a helpful contribution
     It's not clear how to reconcile his advice to carefully considering convenience of user,
     with this comment about not wanting to provide convenient interfaces for algorithms.