Filter Elements from Array - Practice Coding Problems

Filter Elements from Array - Problem

JavaScript Easy

Create your own array filtering function from scratch! You're given an integer array arr and a filtering function fn, and your task is to return a new filtered array containing only the elements that pass the test.

The filtering function fn can accept one or two parameters:

arr[i] - the current element from the array
i - the index of the current element

Your filtered array should only contain elements where fn(arr[i], i) returns a truthy value. A truthy value is any value that makes Boolean(value) return true.

Challenge: You must implement this without using the built-in Array.filter() method!

Example: If arr = [0, 10, 20, 30] and fn = (n, i) => n > 10, then the result should be [20, 30] because only these elements are greater than 10.

Input & Output

example_1.js — Basic Filtering

$ Input: arr = [0, 10, 20, 30], fn = (n, i) => n > 10

› Output: [20, 30]

💡 Note: Elements 20 and 30 are greater than 10, so they pass the filter. Elements 0 and 10 do not satisfy the condition.

example_2.js — Index-based Filtering

$ Input: arr = [1, 2, 3], fn = (n, i) => i === 0

› Output: [1]

💡 Note: Only the element at index 0 (which is 1) satisfies the condition i === 0.

example_3.js — Truthy Value Filtering

$ Input: arr = [-2, -1, 0, 1, 2], fn = (n) => n + 1

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

💡 Note: The function returns n + 1. For -2: -1 (truthy), -1: 0 (falsy), 0: 1 (truthy), 1: 2 (truthy), 2: 3 (truthy).

Constraints

0 ≤ arr.length ≤ 1000
-1000 ≤ arr[i] ≤ 1000
fn returns a truthy or falsy value
You cannot use the built-in Array.filter() method

Visualization

Tap to expand

Understanding the Visualization

Initialize

Create empty result array to store filtered elements

Iterate

Loop through each element in the input array with its index

Test

Apply the filtering function to current element and index

Filter

Add element to result array if function returns truthy value

Complete

Return the completed filtered array

Key Takeaway

🎯 Key Insight: Array filtering requires exactly one pass through the data - we test each element once and immediately decide whether to include it in our result, making this an inherently O(n) operation.

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a simple iterative approach with O(n) time complexity. We iterate through the input array once, apply the filtering function to each element along with its index, and build the result array by adding elements that return truthy values. This approach is both time and space efficient, making it the best solution for this filtering problem.

Common Approaches

Approach	Time	Space	Notes
✓ Iterative Filtering (Simple Loop)	O(n)	O(k)	Iterate through array once, test each element, and build result array

Iterative Filtering (Simple Loop) — Algorithm Steps

Initialize an empty result array
Loop through each element in the input array
For each element, call the filtering function with the element and its index
If the function returns a truthy value, add the element to the result array
Return the completed result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with input array

Begin with the original array and filtering function

Test each element

Apply the filtering function to each element with its index

Build result array

Add elements that pass the test to the result array

Return filtered array

Complete the process with the filtered result

Code -

solution.c — C

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

int* filterArray(int* arr, int size, bool (*fn)(int, int), int* resultSize) {
    int* result = malloc(size * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < size; i++) {
        if (fn(arr[i], i)) {
            result[count++] = arr[i];
        }
    }
    
    *resultSize = count;
    result = realloc(result, count * sizeof(int));
    return result;
}

// Example filtering function
bool greaterThanTen(int n, int i) {
    return n > 10;
}

// Example usage in main:
// int arr[] = {0, 10, 20, 30};
// int resultSize;
// int* filtered = filterArray(arr, 4, greaterThanTen, &resultSize);

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the array exactly once, where n is the length of the input array

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of elements that pass the filter (worst case O(n) if all elements pass)

✓ Linear Space

42.3K Views

High Frequency

~15 min Avg. Time

1.9K 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 (Simple Loop) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler