Filter Elements from Array

Filter Elements from Array - Problem

JavaScript Easy

Given an integer array arr and a filtering function fn, return a filtered array filteredArr.

The fn function takes one or two arguments:

arr[i] - number from the arr
i - index of arr[i]

filteredArr should only contain the elements from the arr for which the expression fn(arr[i], i) evaluates to a truthy value. A truthy value is a value where Boolean(value) returns true.

Please solve it without the built-in Array.filter method.

Input & Output

Example 1 — Filter Odd Numbers

$ Input: arr = [0,10,20,30], fn = function greaterThan10(n) { return n > 10; }

› Output: [20,30]

💡 Note: Filter keeps elements > 10: greaterThan10(0)=false, greaterThan10(10)=false, greaterThan10(20)=true, greaterThan10(30)=true

Example 2 — Filter by Index

$ Input: arr = [1,2,3], fn = function firstIndex(n, i) { return i === 0; }

› Output: [1]

💡 Note: Filter keeps only first element: firstIndex(1,0)=true, firstIndex(2,1)=false, firstIndex(3,2)=false

Example 3 — No Elements Pass

$ Input: arr = [-2,-1,0,1,2], fn = function plusOne(n) { return n + 1; }

› Output: [-2,0,1,2]

💡 Note: Filter by truthy values: plusOne(-2)=-1 (truthy), plusOne(-1)=0 (falsy), plusOne(0)=1 (truthy), plusOne(1)=2 (truthy), plusOne(2)=3 (truthy)

Constraints

0 ≤ arr.length ≤ 1000
-10⁹ ≤ arr[i] ≤ 10⁹
fn returns a boolean value

Visualization

Tap to expand

Asked in

f Meta 25 G Google 20 M Microsoft 15

The key insight is to iterate through each element and test it with the filter function, collecting only those that return truthy values. Best approach is the iterative filtering with single pass. Time: O(n), Space: O(k) where k is the number of elements that pass the filter.

Common Approaches

✓ Iterative Filtering

⏱️ Time: O(n) Space: O(k)

Iterate through each element of the input array, apply the filtering function to each element along with its index, and collect elements that return truthy values into a new result array.

Single Pass with Early Collection

⏱️ Time: O(n) Space: O(k)

Same algorithm as brute force but with micro-optimizations like pre-allocating result array capacity and using more efficient iteration patterns. For this problem, the time complexity cannot be improved below O(n).

Iterative Filtering — Algorithm Steps

Step 1: Create empty result array
Step 2: Loop through input array with index
Step 3: Apply filter function to each element
Step 4: Add element to result if function returns truthy

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Array

Original array with elements to filter

Apply Filter

Test each element with the filter function

Collect Results

Build result array with passing elements

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

typedef bool (*FilterFunc)(int val, int idx);

int* solution(int* arr, int arrSize, FilterFunc fn, int* returnSize) {
    int* result = malloc(arrSize * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < arrSize; i++) {
        if (fn(arr[i], i)) {
            result[count++] = arr[i];
        }
    }
    
    *returnSize = count;
    return result;
}

bool sampleFilter(int val, int idx) {
    return val > 10;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array [1,2,3] format
    int arr[100];
    int arrSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        arr[arrSize++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    fgets(line, sizeof(line), stdin); // Read function description
    
    int resultSize;
    int* result = solution(arr, arrSize, sampleFilter, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("%d", result[i]);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through all n elements of the array

✓ Linear Growth

Space Complexity

O(k)

Result array stores k elements that pass the filter (worst case k=n)

✓ Linear Space

25.4K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative Filtering — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler