The Prince Academy株式会社 | Beyond the Basics: Recognizing Patterns and Reusability | Thinking Like a Computer: Problem Decomposition and Pseudocode | Introduction to Computer Algorithm: Data Structures, Complexity, and Optimization for Modern AI Systems

As you get more comfortable with breaking down problems and expressing them in pseudocode, you'll start to notice something exciting: many problems share similar underlying structures and require similar sets of steps. This is where the magic of pattern recognition and reusability comes into play, a cornerstone of efficient algorithm design.

Think about it: whether you're sorting a list of student grades, a collection of book titles, or a set of product prices, the fundamental operation of comparing and rearranging items is the same. Recognizing these common patterns allows us to create 'building blocks' – reusable algorithms or sub-algorithms – that can be applied to a wide variety of problems. This saves immense time and effort, preventing us from reinventing the wheel every single time.

A classic example is the process of finding the largest or smallest item in a collection. The core logic remains consistent, regardless of what type of data you're dealing with. We can abstract this general idea into a reusable pattern.

FUNCTION FindExtremeValue(list, compareFunction):
  IF list is empty THEN
    RETURN null
  END IF

  SET extremeValue = first element of list

  FOR EACH item IN list starting from the second element:
    IF compareFunction(item, extremeValue) THEN
      SET extremeValue = item
    END IF
  END FOR

  RETURN extremeValue
END FUNCTION

In the pseudocode above, list represents the collection of items, and compareFunction is a placeholder for the specific logic we'd use to determine if an item is 'greater than' (or 'smaller than') the current extremeValue. For instance, if we were finding the highest grade, compareFunction would check if the current grade is greater than the highest grade found so far. If we were finding the shortest name, it would check if the current name's length is less than the shortest name's length.

This FindExtremeValue function is a reusable component. We don't need to rewrite the entire loop and comparison logic every time we need to find the maximum or minimum. We simply call this function and provide the specific list and comparison rule.

Another common pattern involves processing elements in a sequence. Many algorithms require us to iterate through a list, perform an action on each element, and potentially accumulate a result. This is often referred to as a 'traversal' or 'iteration' pattern.

graph TD
    A[Start]
    B{Is list empty?}
    C[Initialize result]
    D[Get next element]
    E[Process element]
    F[Update result]
    G[Are there more elements?]
    H[Return result]

    A --> B
    B -- No --> C
    B -- Yes --> H
    C --> D
    D --> E
    E --> F
    F --> G
    G -- Yes --> D
    G -- No --> H

FUNCTION FindExtremeValue(list, compareFunction): IF list is empty THEN RETURN null END IF SET extremeValue = first element of list FOR EACH item IN list starting from the second element: IF compareFunction(item, extremeValue) THEN SET extremeValue = item END IF END FOR RETURN extremeValue END FUNCTION

graph TD A[Start] B{Is list empty?} C[Initialize result] D[Get next element] E[Process element] F[Update result] G[Are there more elements?] H[Return result] A --> B B -- No --> C B -- Yes --> H C --> D D --> E E --> F F --> G G -- Yes --> D G -- No --> H