## 944. Delete Columns to Make Sorted

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:

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*.

**Example 1:**

Input:strs = ["cba","daf","ghi"]Output:1Explanation:The grid looks as follows: cba daf ghi Columns 0 and 2 are sorted, but column 1 is not, so you only need to delete 1 column.

**Example 2:**

Input:strs = ["a","b"]Output:0Explanation:The grid looks as follows: a b Column 0 is the only column and is sorted, so you will not delete any columns.

**Example 3:**

Input:strs = ["zyx","wvu","tsr"]Output:3Explanation:The grid looks as follows: zyx wvu tsr All 3 columns are not sorted, so you will delete all 3.

**Constraints:**

`n == strs.length`

`1 <= n <= 100`

`1 <= strs[i].length <= 1000`

`strs[i]`

consists of lowercase English letters.

## Rust Solution

```
struct Solution;
impl Solution {
fn min_deletion_size(a: Vec<String>) -> i32 {
let mut d = 0;
let a: Vec<&[u8]> = a.iter().map(|s| s.as_bytes()).collect();
let n = a.len();
let m = a[0].len();
for i in 0..m {
for j in 1..n {
if a[j][i] < a[j - 1][i] {
d += 1;
break;
}
}
}
d
}
}
#[test]
fn test() {
let a: Vec<String> = vec_string!["cba", "daf", "ghi"];
assert_eq!(Solution::min_deletion_size(a), 1);
let a: Vec<String> = vec_string!["a", "b"];
assert_eq!(Solution::min_deletion_size(a), 0);
let a: Vec<String> = vec_string!["zyx", "wvu", "tsr"];
assert_eq!(Solution::min_deletion_size(a), 3);
}
```

Having problems with this solution? Click here to submit an issue on github.