Source code
public class LevenshteinDistance {
public static int calculate(String word1, String word2) {
int[][] distance = new int[word1.length() + 1][word2.length() + 1];
for (int i = 0; i <= word1.length(); i++) {
distance[i][0] = i;
}
for (int j = 1; j <= word2.length(); j++) {
distance[0][j] = j;
}
for (int i = 1; i <= word1.length(); i++) {
for (int j = 1; j <= word2.length(); j++) {
distance[i][j] = Math.min(
Math.min(distance[i - 1][j] + 1, distance[i][j - 1] + 1),
distance[i - 1][j - 1] + ((word1.charAt(i - 1) == word2.charAt(j - 1)) ? 0 : 1));
}
}
return distance[word1.length()][word2.length()];
}
public static void main(String[] args) {
for (int i = 0; i < args.length; i += 2) {
String word1 = args[i];
String word2 = args[i + 1];
System.out.println(calculate(word1, word2));
}
}
}
Run 1
The code is generally well-structured and readable. The Levenshtein distance algorithm is implemented clearly, with initialization loops separated from the main dynamic programming loop. Nesting is limited to two levels, which is acceptable. Variable names are descriptive, and the intention of each loop is clear. Action granularity is good—each line performs one logical operation. The main method is concise. However, readability could improve by extracting the cost calculation into a helper method or a named variable, as the inline ternary and nested Math.min make the core line dense. Input validation for odd-length args is absent, but that is outside readability. Overall, the structure and flow are natural for this algorithm.
Run 2
The code is well-structured with clear separation of initialization and computation. The Levenshtein distance algorithm is implemented concisely without excessive nesting. Variable names like `distance`, `word1`, and `word2` are meaningful. Action granularity is mostly one action per line, though the innermost `Math.min` call combines several operations, which slightly reduces readability. The reading flow is logical: initialize base cases, compute matrix, return result. Minor weaknesses include lack of comments explaining the DP recurrence and the `main` method's loop which assumes an even number of arguments. Overall, the code is highly readable and maintainable for someone familiar with dynamic programming.
Run 3
The code is well-structured and readable. The class has a single responsibility, and the method names clearly indicate purpose. Matrix initialization is split into two straightforward loops, followed by a nested dynamic programming loop that remains shallow (only two levels). Action granularity is good—each line performs one logical step. The expression for the minimum of three values is slightly dense but still clear due to consistent indentation and use of Math.min. Reading flow is natural, progressing from initialization to computation to output. Minor drawbacks include the lack of a guard against odd-length argument arrays and the inline ternary operation, which could be extracted to a helper method for additional clarity.
Run 1
Code Structure: The distance calculation and command-line entry point are cleanly separated, with initialization, computation, and return logically organized. Nesting: Two nested loops are appropriate for the algorithm; there is no excessive branching. Clarity of intent: The class, method, and variable names convey purpose, but the compact recurrence requires familiarity with Levenshtein distance; named insertion, deletion, and substitution costs would clarify it. Code length: Concise without substantial redundancy. Action granularity: Most lines perform one action, although the distance assignment combines several calculations and a conditional expression. Reading flow: Execution follows a natural sequence, with consistent indentation and useful spacing. The long recurrence expression slightly interrupts readability, and the main method leaves its paired-argument assumption implicit.
Run 2
Code Structure: Clearly separates distance calculation from command-line execution, with initialization, computation, and return logically organized. Nesting: Two nested loops are appropriate for the algorithm; there is no excessive control-flow nesting. Clarity of intent: Class, method, and variable names communicate purpose, though the dense recurrence would be clearer with named insertion, deletion, and substitution costs. Code length: Compact without unnecessary boilerplate or repetition. Action granularity: Most lines perform one action, but the nested Math.min expression combines several calculations. Reading flow: Proceeds naturally from matrix setup to computation and output, with useful spacing. The command-line loop's assumption that arguments arrive in pairs is implicit rather than documented.
Run 3
Code Structure: Clearly separates distance calculation from command-line processing, with initialization, computation, and return logically organized. Nesting: Limited to two nested loops, appropriate for the algorithm. Clarity of intent: Class, method, and variable names communicate purpose, though the dense recurrence would benefit from named insertion, deletion, and substitution costs. Code length: Compact without substantial redundancy. Action granularity: Most lines perform one action; the nested Math.min expression combines several operations and is harder to scan. Reading flow: Natural progression from matrix setup to computation and output, supported by whitespace. The differing initialization loop bounds and implicit assumption that arguments arrive in pairs introduce minor reading friction.