Compute the sum of squares from 1 to n

In the previous article, we explored what an algorithm is and gained a foundational understanding of its definition and structure. Next, we will delve into several essential characteristics of algorithms—features that not only deepen our understanding of their nature but also guide us in selecting and designing appropriate algorithms during real-world development.

1. Finiteness

A valid algorithm must complete its task in a finite number of steps. This means the algorithm must terminate within a bounded amount of time, rather than entering an infinite loop. For example, consider a summation algorithm:

def sum_numbers(n):
    total = 0
    for i in range(n + 1):
        total += i
    return total

In this example, the sum_numbers function computes the sum of integers from 1 to $n$ in a finite number of steps when given a positive integer $n$.

2. Determinism

An algorithm must produce the same output for identical inputs. In other words, given a specific input, the execution path and resulting output must be uniquely determined. Continuing with the summation example:

result1 = sum_numbers(5)  # Returns 15
result2 = sum_numbers(5)  # Returns 15

No matter how many times it is called, sum_numbers(5) always yields 15. This determinism ensures the algorithm’s predictability.

3. Feasibility

Every step in an algorithm must be executable—that is, each operation must be unambiguous, effective, and implementable on an existing computational model. For instance, instructing a computer to print an extremely complex mathematical formula may be theoretically possible, but could prove impractical due to excessive computational complexity.

# Compute the sum of squares from 1 to n
def sum_of_squares(n):
    total = 0
    for i in range(n + 1):
        total += i ** 2
    return total

All steps here can be executed sequentially by a computer, illustrating the importance of feasibility.

4. Input and Output

Algorithms typically accept one or more inputs and produce one or more outputs. Inputs are data items provided to the algorithm; outputs are the results obtained after processing those inputs. For instance, our summation algorithm takes a single number $n$ as input and returns a number as output:

# Input: 5 → Output: 15 (i.e., 1 + 2 + 3 + 4 + 5)
print(sum_numbers(5))

This explicit mapping from input to output is central to understanding how an algorithm functions.

5. Generality

A well-designed algorithm should exhibit a degree of generality: once it solves a particular class of problems, it should be reusable across similar problems. For example, sorting algorithms like QuickSort can handle any comparable dataset—not just a specific set of numbers.

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

# Example: Sorting a list of integers
print(quicksort([3, 6, 8, 10, 1, 2, 1])) 

Regardless of the specific list of numbers provided as input, this algorithm correctly sorts it—demonstrating strong generality.

Summary

Mastering the fundamental characteristics of algorithms—finiteness, determinism, feasibility, input/output, and generality—is crucial for beginners learning algorithm design and analysis. In the next article, we will explore practical applications of algorithms and see how these core properties help solve real-world problems.

We hope this article supports and enriches your journey into learning algorithms!