SLOG Entry#10

     Its finally here faithful SLOG readers. My final SLOG entry of this semester. Hope you've all enjoyed yourselves. I know I have. In computer science this week, we talked about how dictionaries were far more efficient in accessing and inserting data then trees. Even sorted trees. This is because dictionaries are basically lists, and in Python, lists have constant access to their elements. The downside to this is that dictionaries may not be sorted. So there is a trade off for the efficiency. The rest of the week was then spent in review for the final exam. That will be interesting. This is my final SLOG entry. Thank you all for reading. Good luck and have fun.

SLOG Entry#9

     Here's another SLOG entry. Its midterm week again. On Monday we covered some more about big-oh, talking about how O(lg n) is the big-oh of a function that cuts a list in half again and again for a certain amount of recursion. Most of the fun was on Wednesday when we had another midterm. It wasn't so bad, and I found it easier then the last midterm. Tune in in next time for more computer science.

SLOG Entry #8

     Here's my weekly SLOG entry. This week, in computer science, we covered some questions about assignment two and learned some new sorts. The sorts we learned were quick sort and merge sort. In quick sort, a pivot is chosen, the list is sorted around the pivot and then each new partition is then also quick sorted. In merge sort, the list is divided in half, each half is merge sorted and then the two halves are joined together. These sorts are more complicated then the sorts we learned before, but they are also quicker and more efficient, as shown when we calculated their big-ohs. Check in next week for more computer science!

SLOG Entry #7

     Well here's another SLOG entry. Sorry for the wait. This week, in the world of computer science, we learned about performance and big oh. Performance basically asks how efficient is a certain function for this task. In our case, it was which sorts take less time. Depending on the type of tests the function is going to be called on, examples being best-case-scenario and worst-case-scenario, each function has a different algorithm that shows it's processing time. These alogriths can be represented by big-oh, or O(y) for y being the complexity of the algorithm. This is useful, as we can compare effeciencies of different functions by comparing different O's. By testing the performance of our sorts, we saw that several were far more effecient then others in the worst-case-scenario. This seems like a useful skill that will be helpful for far larger and more complicated programs, for which a fast performance is vital. That's all for this week.