I am reading chapter two. On page 43, the output of the code below should be different:

[1]: yellow = {'dandelions', 'fire hydrant', 'leaves'}
[2]: red = {'fire hydrant', 'blood', 'rose', 'leaves'}
[3]:  yellow&red

In the book, it is written {'fire hydrant'}, but it should be {'leaves', 'fire hydrant'}.

• Page 83: in the numbered list, at number 2, Mapping' definition, it reads: "Any operation that can run independently on a split is called a map. In the preceding diagram, the map operation coverts ..." I think there is a typo for the word coverts should be converts. Would you please check this?

• Page 86: in the greedy algorithm defining list number 2, it is talked about Union(S, e). I couldn't find out what is e? A bit of definition would suffice.

• Page 88: do the code in the middle of the page is complete? I think there are at least two misplaced lines of code and need changes:

for i in range(len(aTour)))
and
for c in range(number_of_cities))

• Page 69: in the code for linear search, an indentation is needed in the else statement part. It works well for items that are in the searched list, but for items that aren't in the searched list, it goes to an infinite loop and needs to interrupt the kernel. The code on page 69 is:

def LinearSearch(list, item):
    index = 0
    found = False
# Match the value with each data element
    while index < len(list) and found is False:
        if list[index] == item:
            found = True
    else:
        index = index + 1
    return found

The code above should be indented like below:

def LinearSearch(list, item):
    index = 0
    found = False
# Match the value with each data element
    while index < len(list) and found is False:
        if list[index] == item:
            found = True
        else:
            index = index + 1
    return found

Codes in here are OK.

• Page 43, the output of the code below should be different:

 [1]: yellow = {'dandelions', 'fire hydrant', 'leaves'}

 [2]: red = {'fire hydrant', 'blood', 'rose', 'leaves'}

 [3]: yellow&red

In the book, it is written {'fire hydrant'}, but it should be {'leaves', 'fire hydrant'}.

• Page 54: in the Terminology table, the Sibling nodes' definition reads: "Two nodes in a tree are called siblings if they are at the same level." By this definition, in the page 55 image, nodes E and F are also siblings, which is incorrect. I found out siblings node definition in here and here. I think the definition should be changed in one of these ways:

  • Sibling nodes are nodes on the same hierarchical level under the same parent node.

  • Child nodes with the same parent are sibling nodes.

In chapter 8 - page 235 - first code block This is part where you explain how to define a Keras model using mnist dataset as example.

In page 235 you define : inputs = tf.keras.Input(shape=(128, 128)) But the mnist dataset is 28x28.

The correct instruction should be: inputs = tf.keras.Input(shape=(28, 28))

• don't call your variables list, list is a build in type and you loose the constructor
• in bubble sort add a test if done a swap in a pass, if not => data is sorted
• no need to return the list because a list is a mutable data structure, make a copy of the list (data[:]) if needed to have different sorted list
• in insertion sort test for (j >= 0) before testing value in list, -1 is a valid list index

I am reading your book and for the interpolation search there is one point I don't understand I compared with that link and found a missing condition which is the case when list[mid] > x . Shouldn't the code be like ?

def IntPolsearch(list,x ):
   idx0 = 0
   idxn = (len(list) - 1)
   found = False
   while idx0 <= idxn and x >= list[idx0] and x <= list[idxn]:
      # Find the mid point
      mid = idx0 +int(((float(idxn - idx0)/( list[idxn] - list[idx0])) *( x - list[idx0])))
      # Compare the value at mid point with search value
      if list[mid] == x:
         found = True
         return found
      if list[mid] < x:
         idx0 = mid + 1
      if list[mid] > x:
         idxn = mid - 1
return found