Sort By

Sort By - Problem

JavaScript Easy

Given an array arr and a function fn, return a sorted array sortedArr.

You can assume fn only returns numbers and those numbers determine the sort order of sortedArr. sortedArr must be sorted in ascending order by fn output.

You may assume that fn will never duplicate numbers for a given array.

Input & Output

Example 1 — Basic Sorting

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

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

💡 Note: Function returns the number itself, so we sort in ascending order: 1 < 2 < 3 < 4 < 5

Example 2 — Custom Function

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

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

💡 Note: Sort by squares: fn(1)=1, fn(2)=4, fn(3)=9, fn(4)=16, fn(5)=25. Still ascending order.

Example 3 — Reverse Effect

$ Input: arr = [2, 3, 1, 4], fn = x => -x

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

💡 Note: Sort by negative values: fn(4)=-4, fn(3)=-3, fn(2)=-2, fn(1)=-1. Ascending by fn gives [4,3,2,1].

Constraints

1 ≤ arr.length ≤ 1000
-1000 ≤ arr[i] ≤ 1000
fn returns a number for every arr[i]
fn will not return duplicate numbers for a given array

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 31 🍎 Apple 25

The key insight is to avoid recalculating function values during sorting. The optimal approach transforms all elements once, creating pairs of (value, fn_result), then sorts by fn_result. This reduces function calls from O(n² log n) to O(n). Best approach: Transform-then-sort with Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force Bubble Sort

⏱️ Time: O(n²) Space: O(1)

For each comparison in bubble sort, call the function on both elements and compare the results. This recalculates function values multiple times during sorting.

Transform Then Sort

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

First pass: calculate fn(x) for each element and store pairs. Second pass: sort the pairs by function values. This avoids recalculating function values during sorting.

Brute Force Bubble Sort — Algorithm Steps

Step 1: Use nested loops for bubble sort
Step 2: For each comparison, call fn on both elements
Step 3: Swap if fn(a) > fn(b)

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare

Call fn on adjacent elements

Swap

Swap if fn(left) > fn(right)

Repeat

Continue until array is sorted

Code -

solution.c — C

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

int parseFn(int x, char* fnStr) {
    if (strstr(fnStr, "+") != NULL) {
        char* plus = strstr(fnStr, "+");
        int val = atoi(plus + 1);
        return x + val;
    } else if (strstr(fnStr, "*") != NULL) {
        char* mult = strstr(fnStr, "*");
        int val = atoi(mult + 1);
        return x * val;
    }
    return x;
}

int* solution(int* arr, int size, char* fnStr) {
    // Create a copy
    int* result = (int*)malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) {
        result[i] = arr[i];
    }
    
    // Bubble sort with custom comparator
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (parseFn(result[j], fnStr) > parseFn(result[j + 1], fnStr)) {
                int temp = result[j];
                result[j] = result[j + 1];
                result[j + 1] = temp;
            }
        }
    }
    
    return result;
}

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);
    
    // Simple array parser
    int arr[100];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        int val = atoi(token);
        if (val != 0 || token[0] == '0') {
            arr[size++] = val;
        }
        token = strtok(NULL, "[,]");
    }
    
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int* result = solution(arr, size, line);
    
    printf("[");
    for (int i = 0; i < size; i++) {
        printf("%d", result[i]);
        if (i < size - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops with n×n comparisons, each calling fn

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses a few variables for swapping

✓ Linear Space

34.6K 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

Brute Force Bubble Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler