Delete Columns to Make Sorted

Delete Columns to Make Sorted - Problem

Array String Easy

You are given an array of n strings strs, all of the same length.

The strings can be arranged such that there is one on each line, making a grid. For example, strs = ["abc", "bce", "cae"] can be arranged as follows:

abc
bce
cae

You want to delete the columns that are not sorted lexicographically. In the above example (0-indexed), columns 0 ('a', 'b', 'c') and 2 ('c', 'e', 'e') are sorted, while column 1 ('b', 'c', 'a') is not, so you would delete column 1.

Return the number of columns that you will delete.

Input & Output

Example 1 — Basic Case

$ Input: strs = ["abc", "bce", "cae"]

› Output: 1

💡 Note: Column 0: 'a','b','c' is sorted. Column 1: 'b','c','a' is not sorted (c > a). Column 2: 'c','e','e' is sorted. Delete 1 column.

Example 2 — All Sorted

$ Input: strs = ["abcdef"]

› Output: 0

💡 Note: Only one string, so all columns are trivially sorted. Delete 0 columns.

Example 3 — All Unsorted

$ Input: strs = ["zyx", "wvu", "tsr"]

› Output: 3

💡 Note: All columns are in descending order. Column 0: 'z','w','t', Column 1: 'y','v','s', Column 2: 'x','u','r'. Delete all 3 columns.

Constraints

1 ≤ strs.length ≤ 100
1 ≤ strs[i].length ≤ 1000
strs[i] consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to check each column independently for lexicographic ordering. For each column, compare adjacent characters from top to bottom - if any character is greater than the one below it, the column must be deleted. Best approach is the single pass with early termination. Time: O(n×m), Space: O(1).

Common Approaches

✓ Brute Force - Check Each Column

⏱️ Time: O(n × m) Space: O(1)

For each column position, extract all characters from that column across all strings and check if they form a sorted sequence.

Single Pass Optimized

⏱️ Time: O(n × m) Space: O(1)

Same logic as brute force but with better constant factors by avoiding unnecessary operations and using early termination when a column is found to be unsorted.

Brute Force - Check Each Column — Algorithm Steps

Step 1: For each column index from 0 to string length
Step 2: Extract characters from all strings at that column
Step 3: Check if the column characters are sorted lexicographically
Step 4: Count unsorted columns

Visualization

Tap to expand

Step-by-Step Walkthrough

Grid Setup

Arrange strings as rows to form columns

Check Each Column

For each column, verify if characters are in ascending order

Count Unsorted

Count columns that need to be deleted

Code -

solution.c — C

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

int solution(char strs[][101], int n) {
    if (n == 0 || strlen(strs[0]) == 0) {
        return 0;
    }
    
    int delete_count = 0;
    int m = strlen(strs[0]);
    
    // Check each column
    for (int col = 0; col < m; col++) {
        // Check if this column is sorted
        for (int row = 1; row < n; row++) {
            if (strs[row][col] < strs[row-1][col]) {
                delete_count++;
                break;
            }
        }
    }
    
    return delete_count;
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin) == NULL) {
        printf("0\n");
        return 0;
    }
    
    // Parse JSON array
    static char strs[1000][101];
    int n = 0;
    
    char* start = strchr(line, '[');
    if (start == NULL) {
        printf("0\n");
        return 0;
    }
    
    char* ptr = start + 1;
    while (*ptr && *ptr != ']' && n < 1000) {
        // Skip whitespace and commas
        while (*ptr == ' ' || *ptr == ',' || *ptr == '\t' || *ptr == '\n') {
            ptr++;
        }
        
        if (*ptr == '"') {
            ptr++; // Skip opening quote
            int len = 0;
            while (*ptr && *ptr != '"' && len < 100) {
                strs[n][len++] = *ptr++;
            }
            strs[n][len] = '\0';
            if (*ptr == '"') ptr++; // Skip closing quote
            n++;
        } else if (*ptr != ']') {
            ptr++;
        }
    }
    
    int result = solution(strs, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

We check each column (m columns) and for each column we check n strings

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

28.5K Views

Medium Frequency

~8 min Avg. Time

845 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 - Check Each Column — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler