Writing Language-Agnostic Algorithms

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

FUNCTION LinearSearch(array, target)
    // SEQUENCE: statements execute in order
    
    // ITERATION: repeat for each element
    FOR i ← 0 TO length(array) - 1 DO
        
        // SELECTION: branch based on condition
        IF array[i] = target THEN
            RETURN i  // Found at position i
        END IF
        
    END FOR
    
    RETURN -1  // Not found (conventional indicator)
END FUNCTION
 
// This algorithm uses:
// - Sequence (statements in order)
// - Iteration (FOR loop)
// - Selection (IF-THEN)
// - Comparison (array[i] = target)
// - Array access (array[i])
// - Arithmetic (length - 1)
// - Return (exit with value)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

FUNCTION CountFrequencies(array)
    // Create an empty dictionary to store frequencies
    frequency ← empty dictionary
    
    FOR EACH element IN array DO
        IF contains_key(frequency, element) THEN
            // Increment existing count
            frequency[element] ← frequency[element] + 1
        ELSE
            // Initialize count for new element
            frequency[element] ← 1
        END IF
    END FOR
    
    RETURN frequency
END FUNCTION
 
// This uses:
// - Dictionary (key-value storage)
// - Abstract operations (contains_key, assignment via [])
// - FOR EACH iteration (universal pattern)
// - No language-specific syntax

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Basic function template
FUNCTION FunctionName(parameter1, parameter2, ...)
    // Function body
    // ...
    RETURN result
END FUNCTION
 
// Procedure (no return value)
PROCEDURE ProcedureName(parameter1, parameter2, ...)
    // Procedure body
    // ...
END PROCEDURE
 
// Calling a function
result ← FunctionName(argument1, argument2)
 
// Calling a procedure
CALL ProcedureName(argument1, argument2)
// Or simply: ProcedureName(argument1, argument2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

FUNCTION Fibonacci(n)
    // Base cases
    IF n ≤ 0 THEN
        RETURN 0
    ELSE IF n = 1 THEN
        RETURN 1
    END IF
    
    // Recursive case
    RETURN Fibonacci(n - 1) + Fibonacci(n - 2)
END FUNCTION
 
// Note: This is the classic definition.
// Its exponential time complexity makes it impractical for large n.
// We present it for illustration of recursive structure.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

FUNCTION BinarySearch(array, target, low, high)
    // Base case: search space exhausted
    IF low > high THEN
        RETURN -1  // Not found
    END IF
    
    // Calculate midpoint
    mid ← low + (high - low) / 2  // Avoid overflow
    
    // Check middle element
    IF array[mid] = target THEN
        RETURN mid  // Found
    ELSE IF array[mid] < target THEN
        // Target is in right half
        RETURN BinarySearch(array, target, mid + 1, high)
    ELSE
        // Target is in left half
        RETURN BinarySearch(array, target, low, mid - 1)
    END IF
END FUNCTION
 
// Initial call wraps the array
FUNCTION FindElement(array, target)
    RETURN BinarySearch(array, target, 0, length(array) - 1)
END FUNCTION

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Python: positives = [x for x in numbers if x > 0]
// JavaScript: const positives = numbers.filter(x => x > 0);
// Java: List<Integer> positives = numbers.stream().filter(x -> x > 0).collect(...);
 
// Universal pseudocode form:
FUNCTION FilterPositive(numbers)
    result ← empty list
    
    FOR EACH x IN numbers DO
        IF x > 0 THEN
            append(result, x)
        END IF
    END FOR
    
    RETURN result
END FUNCTION

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Map: Apply function to each element
FUNCTION Map(list, transform)
    result ← empty list
    FOR EACH element IN list DO
        append(result, transform(element))
    END FOR
    RETURN result
END FUNCTION
 
// Filter: Keep elements satisfying condition
FUNCTION Filter(list, condition)
    result ← empty list
    FOR EACH element IN list DO
        IF condition(element) THEN
            append(result, element)
        END IF
    END FOR
    RETURN result
END FUNCTION
 
// Reduce: Accumulate to single value
FUNCTION Reduce(list, combine, initial)
    accumulator ← initial
    FOR EACH element IN list DO
        accumulator ← combine(accumulator, element)
    END FOR
    RETURN accumulator
END FUNCTION

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

FUNCTION MergeSort(array)
    // Precondition: array is a list of comparable elements
    // Postcondition: returns a new sorted list in ascending order
    // Time complexity: O(n log n) in all cases
    // Space complexity: O(n) for temporary arrays
    
    // Base case: single element or empty is already sorted
    IF length(array) ≤ 1 THEN
        RETURN array
    END IF
    
    // Divide: split array into two halves
    mid ← length(array) / 2
    leftHalf ← array[0 ... mid - 1]      // First half
    rightHalf ← array[mid ... end]        // Second half
    
    // Conquer: recursively sort each half
    sortedLeft ← MergeSort(leftHalf)
    sortedRight ← MergeSort(rightHalf)
    
    // Combine: merge the sorted halves
    RETURN Merge(sortedLeft, sortedRight)
END FUNCTION
 
FUNCTION Merge(left, right)
    // Merges two sorted arrays into one sorted array
    // Invariant: result contains all merged elements in sorted order
    
    result ← empty list
    i ← 0  // Pointer into left array
    j ← 0  // Pointer into right array
    
    // Compare and merge while both arrays have elements
    WHILE i < length(left) AND j < length(right) DO
        IF left[i] ≤ right[j] THEN
            append(result, left[i])
            i ← i + 1
        ELSE
            append(result, right[j])
            j ← j + 1
        END IF
    END WHILE
    
    // Append remaining elements (only one loop will execute)
    WHILE i < length(left) DO
        append(result, left[i])
        i ← i + 1
    END WHILE
    
    WHILE j < length(right) DO
        append(result, right[j])
        j ← j + 1
    END WHILE
    
    RETURN result
END FUNCTION

1
2
3
4
5
6
7
8

def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

FUNCTION TwoSum(nums, target)
    // Find two indices whose elements sum to target
    // Returns [i, j] if nums[i] + nums[j] = target, else empty
    
    seen ← empty dictionary  // Maps value → index
    
    FOR i ← 0 TO length(nums) - 1 DO
        num ← nums[i]
        complement ← target - num
        
        IF contains_key(seen, complement) THEN
            // Found pair: complement was seen at earlier index
            RETURN [seen[complement], i]
        END IF
        
        // Record this number's index for future lookups
        seen[num] ← i
    END FOR
    
    RETURN empty list  // No pair found
END FUNCTION

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

function isValid(s) {
    const stack = [];
    const pairs = { ')': '(', ']': '[', '}': '{' };
    
    for (const char of s) {
        if (['(', '[', '{'].includes(char)) {
            stack.push(char);
        } else {
            if (stack.pop() !== pairs[char]) {
                return false;
            }
        }
    }
    
    return stack.length === 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

FUNCTION IsValidParentheses(s)
    // Check if string has balanced parentheses/brackets/braces
    // Returns true if balanced, false otherwise
    
    stack ← empty stack
    
    // Define matching pairs: closing → opening
    matchingOpener ← {')': '(', ']': '[', '}': '{'}
    
    FOR EACH char IN s DO
        IF char is an opening bracket ('(', '[', or '{') THEN
            push(stack, char)
        ELSE
            // char is a closing bracket
            IF isEmpty(stack) THEN
                RETURN false  // No opener to match
            END IF
            
            top ← pop(stack)
            
            IF top ≠ matchingOpener[char] THEN
                RETURN false  // Mismatched pair
            END IF
        END IF
    END FOR
    
    // Valid only if all openers have been matched
    RETURN isEmpty(stack)
END FUNCTION