Learning Journal

 This week we learned more about brute-force algorithms and were introduced to divide and conquer algorithms. We learned how brute-force could be applied to find whether or not one string appears as a substring within another, which can involve comparing every character of the string in question or the majority of them multiple times. When applying brute-force to combinatorial problems, we can resort to the exhaustive search, which involves generating all potential solutions or possible cases to a problem and evaluate each of them to determine which is the most suitable solution. Additionally, brute-force can be applied to graphs using either the Depth-first algorithm, which utilizes a stack for it's operation, or the and the Breadth-fist algorithm, which utilizes a queue for it's operation. Rather than using brute-force to find the solution to a problem, divide and conquer algorithms split problems into smaller problems, referred to as subproblems, that can be solved quickly a...

 This week we learned about using asymptotic notations for analyzing both non-recursive and recursive algorithms. The three notations used for algorithm analysis are referred to as Big Oh ( O(f(n)) ), Big Theta ( Θ(f(n)) ), and Big Omega ( Ω(f(n)) ). These notations are used to represent an algorithm's efficiency based on their respective order of growth in the best-case scenario ( Big Omega - Ω ), worst-case scenario ( Big Oh - O ), and/or when all cases have the same growth ( Big Theta - Θ ). For non-recursive algorithms, the low order terms and constant coefficients must be eliminated to identify the order of growth, while in recursive algorithms, the recurrence relation and initial condition must be defined first so they can be applied during the backward substitution process used to reach the order of growth. In relation to algorithm analysis, we also learned about the brute-force approach, which involves solving a problem in the simplest way. 

 This week we reviewed concepts like writing logic in pseudocode, working with different data structures, solving problems involving graphs, sorting, and searching, and how to analyze algorithms. In summary, writing in pseudocode allows us (programmers) to illustrate logic that can be applied to a variety of languages. Additionally, learning how to analyze algorithms teaches us how to prioritize preserving resources and/or time or prioritize logic simplicity and/or proficiency.