Delete Columns to Make Sorted - Practice Coding Problems

Delete Columns to Make Sorted - Problem

Array String Easy

Delete Columns to Make Sorted

Imagine you have a collection of words displayed as a grid where each word forms a row, and each column represents characters at the same position across all words. Your task is to clean up this grid by removing columns that aren't sorted in lexicographical (alphabetical) order.

For example, given ["abc", "bce", "cae"], we can visualize it as:

a b c
b c e
c a e

Looking at each column vertically:
• Column 0: a → b → c ✅ (sorted)
• Column 1: b → c → a ❌ (not sorted, 'a' comes after 'c')
• Column 2: c → e → e ✅ (sorted)

You need to count how many columns must be deleted to make all remaining columns sorted. In this case, we delete 1 column (column 1).

Input & Output

example_1.py — Basic Case

$ Input: ["cba", "daf", "ghi"]

› Output: 1

💡 Note: Column 0: c→d→g (sorted ✓), Column 1: b→a→h (not sorted ✗), Column 2: a→f→i (sorted ✓). Delete 1 column.

example_2.py — All Sorted

$ Input: ["a", "b"]

› Output: 0

💡 Note: Only one column with a→b, which is already sorted. No deletions needed.

example_3.py — All Unsorted

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

› Output: 3

💡 Note: All columns are in descending order, so all 3 columns must be deleted.

Constraints

1 ≤ strs.length ≤ 1000
1 ≤ strs[i].length ≤ 1000
strs[i] consists of lowercase English letters
All strings have the same length

Visualization

Tap to expand

Understanding the Visualization

Form the Grid

Arrange all strings as rows to create a character grid

Check Each Column

For each column, scan from top to bottom checking if characters are in ascending order

Count Violations

Count how many columns have at least one out-of-order pair

Key Takeaway

🎯 Key Insight: We only need to scan each column once from top to bottom - the moment we find a character that's smaller than the previous one, we know that column must be deleted.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 5

This problem requires checking each column of the string grid to see if characters are in lexicographically sorted order. The optimal approach is to iterate through each column and check adjacent pairs - as soon as we find an out-of-order pair, we mark that column for deletion. Time complexity is O(n × m) where n is the number of strings and m is the string length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Column-by-Column Check)	O(n * m)	O(1)	Check each column by comparing all adjacent pairs

Brute Force (Column-by-Column Check) — Algorithm Steps

Iterate through each column index from 0 to string length
For each column, compare every adjacent pair of characters
If any pair is out of order (current > next), mark column for deletion
Count total columns marked for deletion

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup Grid

Arrange strings as rows in a grid format

Check Column 0

Compare characters vertically: a ≤ b ≤ c (sorted)

Check Column 1

Compare characters vertically: b ≤ c > a (not sorted)

Check Column 2

Compare characters vertically: c ≤ e = e (sorted)

Code -

solution.c — C

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

int minDeletionSize(char** strs, int strsSize) {
    if (strsSize == 0 || strlen(strs[0]) == 0) {
        return 0;
    }
    
    int rows = strsSize;
    int cols = strlen(strs[0]);
    int deleteCount = 0;
    
    // Check each column
    for (int col = 0; col < cols; col++) {
        // Check if current column is sorted
        for (int row = 1; row < rows; row++) {
            if (strs[row-1][col] > strs[row][col]) {
                deleteCount++;
                break;
            }
        }
    }
    
    return deleteCount;
}

int main() {
    int n;
    scanf("%d", &n);
    char** strs = (char**)malloc(n * sizeof(char*));
    for (int i = 0; i < n; i++) {
        strs[i] = (char*)malloc(1001 * sizeof(char));
        scanf("%s", strs[i]);
    }
    printf("%d\n", minDeletionSize(strs, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

n is number of strings, m is string length. We check each character in each column once.

✓ Linear Growth

Space Complexity

O(1)

Only using a counter variable, no additional space needed

✓ Linear Space

24.5K Views

Medium Frequency

~10 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 (Column-by-Column Check) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler