Finding the bundle of the most similar strings in an array

I used the minimum edit distance algorithm to find the bundle of the most similar strings in an array. So, I have to travel double for loop to compare all elements.

If the data is large enough, this algorithm is Inefficient.

Values have rules:

1. value's length is 10
2. value is A-Z and can't be duplicated

Is there a way to optimize?

let data = [
"10000", // count
"asdfqwerty", "asdfzxcvgh", "asdfpoiuyt", // values
...
]

for i in 1..<data.count {
let string = data[i]
for j in (i + 1)..<data.count {
let newMin = string.minimumEditDistance(other: data[j])

if min >= newMin {
// some logic
}
}
}

extension String {
public func minimumEditDistance(other: String, default: Int = 10) -> Int {
let m = self.count
let n = other.count

if m == 0 || n == 0 {
return default
}

var matrix = [[Int]](repeating: [Int](repeating: 0, count: n + 1), count: m + 1)

// initialize matrix
for index in 1...m {
// the distance of any first string to an empty second string
matrix[index][0] = index
}

for index in 1...n {
// the distance of any second string to an empty first string
matrix[0][index] = index
}

// compute Levenshtein distance
for (i, selfChar) in self.enumerated() {
for (j, otherChar) in other.enumerated() {
if otherChar == selfChar {
// substitution of equal symbols with cost 0
matrix[i + 1][j + 1] = matrix[i][j]
} else {
// minimum of the cost of insertion, deletion, or substitution
$$$$
`