Week 10 - A2 Part 2

A2 Part 2 was more straight forward of an assignment. It didn't involve a lot of guess work as to what we could and could not do and what we needed to do and not do because the guidelines were more specific and less vague. Some of the functions, the way we solved them involved using previous exercises and assignments such as using exceptions to indicate whether a regex is valid or not. However, everything in the assignment was something we have dealt with before and it wasn't too complicate to solve. It just took time solve and figure out what each step required and for the recursive functions all the base cases and what to do for certain conditions.

Week 9 - A2 Part 1

The first part of thus assignment for me was really vague. I honestly really had no idea what to exactly do. My group and I had go to through several revisions and complete overhauls of our code in order do create a correct Binary Tree Class. We started off with very little inheritance and eventually realized that most of the code, dependent on how we wrote it could easily be inherited from sub class to another because some of the codes were very similar. Thereby, reducing the amount of duplicate code. That was a hard part of this assignment, reducing duplicate or similar code. By reducing the amount of code and inheriting more of your code, you are able to reduce the chance of bugs and reduce the amount of work you have to do. Reducing the amount of work you have is a crucial and critical part of studying comp sci. The less work you have to do to get the job done, the better.

Week - 8: Linked List

Linked List is essentially a tree that ran linearly and had no depth. It is a list but each of the values in the list pointed to the next value. So if I had a Linked List with values 1, 2, 3, 4 then the Linked List would have the value 1 pointing to value 2 and then it would be pointing to values 3 and so forth. Removing an item from the Linked List was also easy. Instead of shifting the whole list like in a normal list, you would just change which values pointed to what. Let's say we wanted to remove 2 from the Linked List 1, 2, 3, 4. We would just get value 1 to point to value 3 and that's all you had to do. Since nothing pointed to 2, it didn't exist in the Linked List anymore.

This week's lab was really confusing. I did not really understood what my TA was asking of me to do. It was very confusing. Better luck next week.

Week 7 - Recursion

Recursion, a method of solving problems by breaking down the big problems into several smaller instances of the same problem. These smaller instances are called base cases. Base cases are the simplest version of bigger problem that you are trying to solve using recursion. There many are examples of this when using recursion to solve problems that involve nested structures such as binary search trees and nested lists. For example, say I wanted to find the max of the [1, [2, 3]]. The simplest instance aka the base case of the problem is just applying the built-in method max on a single non-nested list.. So the function would cycle through the original list [1, [2, 3]], but when it reaches to the item [2, 3], it will call itself to find the max of that list which is the nested list. [2, 3] falls under a base case and the max of the list which can be found using max() is 3. The function would then replace [2, 3] with 3. So the list is now just [1, 3] and the function would simply find the max() and return 3.
By breaking down the problems into its base cases, it allows to solve many versions of the same problem if they have all the same base cases. Therefore, this technique is really useful to use because it reduces the amount of code. Many of the big problems can be simplified to its base cases and allows you to be lazy and solve the big problem with relatively few lines of code. Being lazy is of the greatest skills of a computer scientist. Also, the code is really efficient in that it doesn't require lines and lines of code. A problem can be solved recursively simply using 1 line of code. Therefore, recursion is really useful technique.
A prime example of using recursion to solve the problem at hand which was moving cheese across the four stools in A. The stools were a nested list where each stool was list that was inside a big list that holds all the stools. Therefore, this was a problem that could be solved very easily using recursion because there were base cases that could be used to solve the bigger problem. The base cases were moving a cheese from origin to destination, and moving two cheese from origin to the destination. By breaking the overall big problem of moving several cheeses across 4 stools into the base case of either moving 1 cheese or 2 cheeses, the solution of the problem was slowly built up. What I mean by the solution was built was that because you know how to move 2 cheeses, you know how to move 3 cheeses and because you know how to move 3 cheese you know how to move 4 cheeses is which just moving 3 cheese plus moving 4th cheese i.e one cheese from the origin to the destination.

Week - 6: A1 Completed

It has been a busy week for me with many things to do and exams and to study for. But the highlight of the week has to be completing A1. 

A1 definitely made understand recursion a lot better especially working out a way to solve moving the cheeses over the stool using the most efficient recursive algorithm. What I found to be really helpful in solving recursion problems is to visually see it happening. It showed patterns and insight to figuring out the solution.
The concept of trees was a fairly simple concept to understand. On the other hand, unit-testing is still a bit difficult for me code out. I still keep on referring back to previous labs and like looking up the API on how to use certain methods in the class unittest. I think I just need a bit more practice on it especially considering its on the first term test.

Week 5 - A1

A1 is finally near completion with just the doc strings left which personally, are the most annoying things to write because its so much writing. But it pales in comparison to the amount of work it took to finish everything else. One of the most annoying parts was getting the GUIController to work because I had to spend several hours debugging. I'm not sure exactly what I changed, but somehow after changing like 3 things, everything worked. I'm still trying to figure out what I changed to get it to work because there have been so many instances where I literally change one thing and everything works. It feels good that everything work especially the algorithm for A1.

The tour.py algorithm for A1 is really really annoying because when trying to find the algorithm, the tracking of which variables are which gets so confusing especially once you add more and more cheeses. I have been lost in my tracking of the variables as to which one are representing which. I don't know how many papers I have scrunched up and threw away because I got lost. However, after finally not getting lost, the feeling of accomplishment was amazing. It wasn't the best solution, but party darn close. The key to figuring it out for me was keeping track of source, dest, int1 and int2 meticulously. I drew everything out on paper and then bamn, everything made sense. Never under estimate the power of paper and pen. It is your best friend when it comes to recursion and you have to keep track of variables that change. Happy tracking.

Week 4 - Progress

What is a Function Object?
At first, I was confused too. Wikipedia attempted to explain it with many examples which to me did not help what so ever. In the end, my lab partner finally explained it to me and I got it. As it turns, I was overthinking about it. A function object is just a parameter in a function that refers to another function outside the function containing the parameter. Therefore, you don't have to call the function directly inside the function. It gets passed into the function as a parameter.

Recursion?!?!?!?
This was a fairly simple concept to comprehend, but to implement and fully understand was pretty complicated. It took a far bit of tracing before I began to understanding recursion and what it does. Recursion happens when a function uses itself in the function. I saw how it was really useful in solving problems that was really complicated to do without recursion. Simply put, recursion made solving certain problems really easy.

A1 - Brain Explosion
The assignment is really complicated and for me, really difficult to understand. I found the instructions to be really vague and I'm not really sure where to start exactly. I spent a long time just trying to see how the cheese was moved in 17 steps for only 6 pieces of cheese. Yes, I did spent my Friday night shoveling around 6 pens to try and move them across 4 pieces of paper in 17 steps. However, actually doing the program with real objects, it helped me see what things we need to do and how to do them. An example would be that each of the stools that the cheese goes on is like a stack where can you only take off the most recent one first and so forth. Hopefully a working program will be accomplished by the end of the week with another week left to further improve it.