Create Sorted Array through Instructions

Create Sorted Array through Instructions - Problem

Array Binary Search Divide and Conquer Binary Indexed Tree Segment Tree Merge Sort Ordered Set Hard

Given an integer array instructions, you are asked to create a sorted array from the elements in instructions. You start with an empty container nums.

For each element from left to right in instructions, insert it into nums. The cost of each insertion is the minimum of the following:

The number of elements currently in nums that are strictly less than instructions[i].
The number of elements currently in nums that are strictly greater than instructions[i].

For example, if inserting element 3 into nums = [1,2,3,5], the cost of insertion is min(2, 1) (elements 1 and 2 are less than 3, element 5 is greater than 3) and nums will become [1,2,3,3,5].

Return the total cost to insert all elements from instructions into nums. Since the answer may be large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: instructions = [1,5,6,2]

› Output: 1

💡 Note: Insert 1: cost=0. Insert 5: smaller=[1], larger=[], cost=0. Insert 6: smaller=[1,5], larger=[], cost=0. Insert 2: smaller=[1], larger=[5,6], cost=min(1,2)=1. Total=1.

Example 2 — Multiple Costs

$ Input: instructions = [1,2,3,6,5,4]

› Output: 3

💡 Note: Each insertion incurs the minimum of smaller/larger elements count. Cost accumulates as: 0+0+0+0+1+2=3.

Example 3 — Duplicates

$ Input: instructions = [1,3,3,3,2,4,2,1,2]

› Output: 4

💡 Note: When inserting duplicates, they don't count as strictly smaller or larger, minimizing costs in some cases.

Constraints

1 ≤ instructions.length ≤ 10⁵
1 ≤ instructions[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that insertion cost is always the minimum of elements smaller or larger than current element. The optimal approach uses Binary Indexed Tree with coordinate compression to achieve O(n log n) time by efficiently counting elements in ranges. Time: O(n log n), Space: O(n).

Common Approaches

✓ Binary Search Optimization

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

Maintain a sorted array but use binary search to find the insertion position quickly. Count smaller and larger elements based on the insertion index.

Brute Force - Linear Search

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

Insert each instruction into a sorted array by finding the correct position through linear search. Count elements smaller and larger than the current element to calculate cost.

Coordinate Compression + Binary Indexed Tree

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

Compress coordinates to handle large values, then use Binary Indexed Tree (Fenwick Tree) to efficiently count elements smaller and larger than each insertion in O(log n) time.

Binary Search Optimization — Algorithm Steps

Step 1: Use binary search to find insertion position in sorted array
Step 2: Calculate smaller count as insertion index, larger as remaining elements
Step 3: Insert element at correct position and update total cost

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search

Find insertion position in O(log n)

Count Elements

Calculate smaller/larger from position

Insert & Update

Insert element and update cost

Code -

solution.c — C

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

int binarySearchLeft(int* nums, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (nums[mid] < target) left = mid + 1;
        else right = mid;
    }
    return left;
}

int binarySearchRight(int* nums, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (nums[mid] <= target) left = mid + 1;
        else right = mid;
    }
    return left;
}

int solution(int* instructions, int size) {
    const int MOD = 1000000007;
    int* nums = (int*)malloc(size * sizeof(int));
    int numsSize = 0;
    long long totalCost = 0;
    
    for (int i = 0; i < size; i++) {
        int num = instructions[i];
        int pos = binarySearchLeft(nums, numsSize, num);
        int smaller = pos;
        int larger = numsSize - binarySearchRight(nums, numsSize, num);
        
        int cost = (smaller < larger) ? smaller : larger;
        totalCost = (totalCost + cost) % MOD;
        
        for (int j = numsSize; j > pos; j--) {
            nums[j] = nums[j - 1];
        }
        nums[pos] = num;
        numsSize++;
    }
    
    free(nums);
    return (int)totalCost;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int instructions[100000];
    int size = 0;
    
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0) {
            instructions[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int result = solution(instructions, size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Binary search is O(log n) but insertion still requires O(n) shifting, done n times

⚡ Linearithmic

Space Complexity

O(n)

Extra array to maintain sorted elements

⚡ Linearithmic Space

28.0K Views

Medium Frequency

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

Binary Search Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler