Implement an exclude Helper Function in TypeScript

The exclude helper function is a utility commonly used in functional programming to filter elements from an array based on a predicate function. This challenge asks you to implement this helper in TypeScript, providing a reusable tool for creating new arrays containing only elements that do not satisfy a given condition. It's a fundamental building block for more complex data transformations.

Problem Description

You are tasked with creating a TypeScript function called exclude. This function should take two arguments:

1. array: An array of any type (any[]).
2. predicate: A function that takes a single element of the array as input and returns a boolean value. If the predicate returns true for an element, that element should be excluded from the resulting array. If it returns false, the element should be included.

The exclude function should return a new array containing only the elements from the original array for which the predicate function returned false. The original array should not be modified.

Key Requirements:

• The function must be type-safe. TypeScript should be able to infer the types of the elements in the array and the return type.
• The function should handle empty arrays gracefully.
• The function should correctly exclude elements based on the predicate.
• The function should return a new array, not a modified version of the original.

Expected Behavior:

The function should iterate through the input array and apply the predicate function to each element. Elements for which the predicate returns true should be skipped. Elements for which the predicate returns false should be added to the new array.

Edge Cases to Consider:

• Empty input array.
• Predicate function that always returns true (should return an empty array).
• Predicate function that always returns false (should return a copy of the original array).
• Array containing elements of different types (though the problem specifies any[], consider how your solution would behave).

Examples

Example 1:

Input: [1, 2, 3, 4, 5], (x: number) => x % 2 === 0
Output: [1, 3, 5]
Explanation: The predicate checks if a number is even.  The function excludes even numbers, returning an array of odd numbers.

Example 2:

Input: ['apple', 'banana', 'cherry', 'date'], (fruit: string) => fruit.startsWith('a')
Output: ['banana', 'cherry', 'date']
Explanation: The predicate checks if a string starts with 'a'. The function excludes fruits starting with 'a'.

Example 3:

Input: [1, 2, 3], (x: number) => true
Output: []
Explanation: The predicate always returns true, so all elements are excluded.

Example 4:

Input: [1, 2, 3], (x: number) => false
Output: [1, 2, 3]
Explanation: The predicate always returns false, so no elements are excluded.

Constraints

• The input array can contain any number of elements (including zero).
• The predicate function can be any function that takes a single element of the array and returns a boolean.
• The time complexity of the solution should be O(n), where n is the number of elements in the input array.
• The space complexity of the solution should be O(n) in the worst case (when no elements are excluded).

Notes

Consider using array methods like filter or a manual loop to implement the exclude function. Think about how to ensure type safety and avoid modifying the original array. The key is to create a new array containing only the elements that do not satisfy the predicate.