Sort By - Practice Coding Problems

Sort By - Problem

JavaScript Easy

Sort By Custom Function

You are given an array arr and a function fn that transforms each element into a number. Your task is to sort the array based on the output of the function, not the original values.

For example, if you have an array of objects representing students, you might want to sort them by their grades (using a function that extracts the grade) rather than alphabetically by name.

Goal: Return a new sorted array where elements are ordered by the ascending values returned by the function fn.

Key Points:
• The function fn always returns numbers
• Sort in ascending order by function output
• The function will never return duplicate numbers for the given array
• You must preserve the original elements, just reorder them

Input & Output

example_1.js — Basic Number Sorting

$ Input: arr = [5, 4, 1, 3, 2], fn = (x) => x

› Output: [1, 2, 3, 4, 5]

💡 Note: The function returns the number itself, so we sort in ascending numerical order. Each element is compared by its own value.

example_2.js — Reverse Order

$ Input: arr = [{'x': 1}, {'x': 0}, {'x': -1}], fn = (d) => -d.x

› Output: [{'x': 1}, {'x': 0}, {'x': -1}]

💡 Note: The function returns the negative of x. So fn({'x': 1}) = -1, fn({'x': 0}) = 0, fn({'x': -1}) = 1. Sorting by these values gives us the reverse order of x values.

example_3.js — String Length Sorting

$ Input: arr = ['hello', 'world', 'hi', 'a'], fn = (s) => s.length

› Output: ['a', 'hi', 'hello', 'world']

💡 Note: Sorting by string length: 'a' (length 1), 'hi' (length 2), 'hello' (length 5), 'world' (length 5). Since hello comes before world in original array and they have same length, order is preserved.

Constraints

1 ≤ arr.length ≤ 1000
fn returns distinct integers for each element
arr can contain any valid JSON values
fn will always return a number for comparison

Visualization

Tap to expand

Understanding the Visualization

Extract Sort Keys

Apply the function to each element to get comparable values

Compare Elements

Use these values to determine the correct order

Rearrange Array

Move elements to their final sorted positions

Return Result

Output the array with original elements in new order

Key Takeaway

🎯 Key Insight: The custom function transforms each element into a comparable value, allowing us to sort by any criteria while preserving the original elements in their new order.

Asked in

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

The optimal approach uses the built-in sort function with a custom comparator. Simply call arr.sort((a, b) => fn(a) - fn(b)) in JavaScript or sorted(arr, key=fn) in Python. This leverages highly optimized sorting algorithms while keeping the code clean and readable. Time complexity is O(n log n) and space complexity is O(log n) for the sorting algorithm's stack space.

Common Approaches

Approach	Time	Space	Notes
✓ Built-in Sort with Custom Comparator (Optimal)	O(n log n)	O(log n)	Use built-in sort with custom comparator - most efficient and clean approach
Two-Pass with Precomputed Values	O(n log n)	O(n)	First pass: compute all function values, Second pass: sort using precomputed values
Brute Force (Selection Sort with Custom Comparison)	O(n²)	O(n)	Manually implement selection sort using the custom function for comparisons

Built-in Sort with Custom Comparator (Optimal) — Algorithm Steps

Use the built-in sort function of the language
Provide a custom comparator that uses fn(a) - fn(b) for comparison
Let the sorting algorithm handle all the complex optimization
Return the sorted array directly

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Comparator

Provide custom comparison function to built-in sort

Smart Comparisons

Sorting algorithm makes optimal comparisons using our function

Efficient Result

Get sorted array with minimal function calls

Code -

solution.c — C

#include <stdlib.h>

// Global function pointer for comparison
static int (*global_fn)(const void*);

int compareWrapper(const void* a, const void* b) {
    return global_fn(a) - global_fn(b);
}

void** sortBy(void** arr, int size, int (*fn)(const void*)) {
    // Create a copy of the array
    void** result = malloc(size * sizeof(void*));
    for (int i = 0; i < size; i++) {
        result[i] = arr[i];
    }
    
    // Set global function pointer and sort
    global_fn = fn;
    qsort(result, size, sizeof(void*), compareWrapper);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by the built-in sorting algorithm, which is typically optimized (like Timsort or Quicksort)

⚡ Linearithmic

Space Complexity

O(log n)

Space used by the sorting algorithm for recursion stack (or O(n) if creating a copy)

⚡ Linearithmic Space

47.5K Views

Medium Frequency

~12 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

Built-in Sort with Custom Comparator (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler