Learning to Think In Code

Overall this first module has been a good introduction into NumPy, and it was great seeing exactly how useful it is for data science in comparison to normal Python lists. I have used Python before but never actually used NumPy arrays in this much depth, so quite a lot of the slicing and operations were new to me. I quite like how you can operate on a full array rather than having to use a loop for it. For example, creating a boolean mask like tuition > 12000 and then using that mask to pull only certain values from the array was a lot simpler than I initially expected. I also thought fancy indexing and slicing were pretty easy once I could actually see the results of each expression. The 2D arrays took a little more th ou ght for me. I h ad to pay closer attention to which number represented the row and which represented the column, especially when we started combining indexing with conditions. Problem 20 in the 2D lab was probably the part that made me think the most because I had ...

 CST370 Engagement Week 7 This week, the topics studied were dynamic programming and greedy algorithms. It interested me because dynamic programming allows us to re-use some parts of the solution, since it saves the solutions of subproblems, meaning we don't have to re-calculate. The coin-row and coin-collecting problems helped me understand how tables can be used to build toward an optimal solution. I also learned about Warshall's and Floyd's algorithms and how they use matrices to solve different graph problems. The greedy technique was also interesting because it makes the best choice available at each step, which we saw with Prim's algorithm for finding a minimum spanning tree. Overall, the examples this week helped me better understand when these different techniques can be useful.

 Learning Journal Week 6: New data structures are introduced this week. We learned that AVL trees can maintain balance by ensuring each node has a balance factor of -1, 0, or 1 and they use several rotations (right rotation, left rotation, LR, RL) to re-balance the tree after insertion and thus avoid the O(n) worst case search time for a BST. We also briefly learned about 2-3 trees and how they use node splitting and promotion to maintain balance during insertion. Another significant topic for the week was heaps and hashing. We saw how max heaps can be used for priority queues and how heapify-up/heapify-down can maintain heap property after modification. It was also interesting to learn about bottom-up heap construction and how its runtime is better than inserting each element into a heap one by one. Lastly, we learned about hash tables and how hash function is used to provide average O(1) search time. We also studied about collisions and some commonly used collision resolution str...

 CST370 - Class Engagement Week 5: A variety of new algorithmic ideas were presented this week and they all stemmed from breaking problems down into subproblems. One topic that I particularly enjoyed was Quick Sort. I now better understand the partitioning strategy by selecting a pivot before the recursion begins. The various ways to traverse a tree (in-order, post-order, and pre-order) and when each traversal method might be applicable was enlightening. Topological sort using a DFS method and utilizing Kahn's algorithm for it was quite intriguing. Understanding the relationship between in-degree values made the algorithm much more intuitive. A fun example for us to practice making generalizations and deriving algorithms from examples was the King's Reach puzzle.

 Week 4 Learning Journal: This week we covered Merge Sort and did a review on all the major concepts for the midterm. We learned how Merge Sort works on the divide and conquer method, which works by breaking down an array into two smaller halves repeatedly until all the arrays are individual elements. Then they would recursively sort these arrays until they were back combined into one fully sorted array. It was good to get to see the recursion tree and how the Merge sort would be done in order to efficiently put the two arrays back together. We also looked at the Master Theorem and practiced determining what case to pick for a given recurrence relation. Going over graph traversals, brute force, and time complexity this week helped reinforce the ideas from the previous few weeks, leading to a good review for the midterm!

 Week 3 Learning Journal: This week, a new family of design techniques and graph traversals were presented. First, brute force design techniques were reviewed which rely on enumerating and checking each potential solution, like how we discussed brute force solution to both TSP and the Knapsack Problem, also why brute force may be impractical for large problem instances. Next, we also went over Breadth-First Search and Depth-First Search traversals to graphs, and I was surprised to learn where to use each type of traversal and their time complexities for graph representations using either an adjacency list or an adjacency matrix. I enjoyed the discussion of divide and conquer algorithms and the Master Theorem, which showed an organized technique for reasoning about time complexities of recursive functions rather than unrolling each one.