Create Sorted Array through Instructions - Practice Coding Problems

Create Sorted Array through Instructions - Problem

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

You're building a sorted array incrementally by following a sequence of instructions. Starting with an empty container, you'll insert elements one by one, but each insertion comes with a cost!

Given an array instructions, for each element you insert, you must pay the minimum cost between:

The number of existing elements strictly less than the new element
The number of existing elements strictly greater than the new element

Example: If you're inserting 3 into [1, 2, 3, 5]:

Elements less than 3: [1, 2] → count = 2
Elements greater than 3: [5] → count = 1
Cost = min(2, 1) = 1
Result: [1, 2, 3, 3, 5]

Return the total cost to insert all elements. Since the answer can be large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Python

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

› Output: 1

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

example_2.py — Python

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

› Output: 3

💡 Note: Insert sequence: [] → [1] → [1,2] → [1,2,3] → [1,2,3,6] → [1,2,3,5,6] → [1,2,3,4,5,6]. Costs: 0,0,0,0,1,2. Total = 3

example_3.py — Python

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

› Output: 4

💡 Note: Multiple duplicates create various insertion costs as the array grows and elements can be inserted at different relative positions

Constraints

1 ≤ instructions.length ≤ 10⁵
1 ≤ instructions[i] ≤ 10⁵
Return answer modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Map Book Types

Create index mapping for different page counts (coordinate compression)

Range Counter

Use Binary Indexed Tree to efficiently count books in page ranges

Smart Insertion

For each new book, quickly count books with fewer/more pages

Minimal Shifting

Choose the minimum between shifting lighter or heavier books

Key Takeaway

🎯 Key Insight: We don't need the actual sorted array - just efficient range counting! Binary Indexed Tree provides O(log n) updates and queries, making the overall solution O(n log n).

Asked in

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

The optimal approach uses a Binary Indexed Tree (Fenwick Tree) with coordinate compression to efficiently count elements in ranges. Instead of maintaining the actual sorted array, we track counts of values allowing O(log n) insertions and range queries, achieving overall O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simulated Insertion)	O(n²)	O(n)	Maintain actual sorted array and count elements for each insertion
Binary Indexed Tree (Optimal)	O(n log n)	O(n)	Use Fenwick Tree to efficiently count elements in ranges

Brute Force (Simulated Insertion) — Algorithm Steps

Initialize empty result array
For each instruction element:
Count elements less than current element
Count elements greater than current element
Add min(less_count, greater_count) to total cost
Insert element into correct position in array

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert 1

Array: [] → [1], Cost: min(0,0) = 0

Insert 3

Array: [1] → [1,3], Cost: min(1,0) = 0

Insert 6

Array: [1,3] → [1,3,6], Cost: min(2,0) = 0

Insert 2

Array: [1,3,6] → [1,2,3,6], Cost: min(1,2) = 1

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#define MOD 1000000007

int createSortedArray(int* instructions, int instructionsSize) {
    int* nums = (int*)malloc(instructionsSize * sizeof(int));
    int size = 0;
    long long totalCost = 0;
    
    for (int i = 0; i < instructionsSize; i++) {
        int num = instructions[i];
        int lessCount = 0, greaterCount = 0;
        
        // Count elements less than and greater than num
        for (int j = 0; j < size; j++) {
            if (nums[j] < num) lessCount++;
            else if (nums[j] > num) greaterCount++;
        }
        
        // Add minimum cost
        totalCost = (totalCost + (lessCount < greaterCount ? lessCount : greaterCount)) % MOD;
        
        // Find insertion position
        int pos = 0;
        while (pos < size && nums[pos] <= num) {
            pos++;
        }
        
        // Shift elements and insert
        for (int j = size; j > pos; j--) {
            nums[j] = nums[j-1];
        }
        nums[pos] = num;
        size++;
    }
    
    free(nums);
    return (int)totalCost;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we scan the array (up to n elements) to count and find insertion position

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to store the growing sorted array

⚡ Linearithmic Space

89.4K Views

Medium-High Frequency

~35 min Avg. Time

1.8K 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 (Simulated Insertion) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler