Filter Elements from Array - Practice Coding Problems

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,-1,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

Understanding the Visualization

Input Array

Original array [0,10,20,30] and filter function n > 10

Apply Filter

Test each element with the filter function

Filtered Output

Collect elements that pass: [20,30]

Key Takeaway

🎯 Key Insight: Build result array incrementally by testing each element with the filter function

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

Approach	Time	Space	Notes
✓ Iterative Filtering	O(n)	O(k)	Loop through array, test each element with function, collect passing elements
Single Pass with Early Collection	O(n)	O(k)	Optimized version that builds result array incrementally during iteration

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;
}

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