Add Did You Mean Suggestion for Mistyped Commands #40

Author: Thidas Senavirathna

src/main/java/com/mycmd/App.java

@@ -1,7 +1,10 @@
 package com.mycmd;
 
 import com.mycmd.commands.*;
+import com.mycmd.utils.StringUtils;
+
 import java.util.*;
+import java.util.Scanner;
 
 public class App {
     public static void main(String[] args) {
@@ -35,12 +38,18 @@ public static void main(String[] args) {
                     System.out.println("Error: " + e.getMessage());
                 }
             } else {
-                List<String> validCommands = new ArrayList<>(commands.keySet());
-                String suggestion = StringUtils.findClosest(cmd, validCommands);
-                if (suggestion != null && !suggestion.equals(cmd)) {
-                    System.out.println("'" + cmd + "' is not recognized as an internal or external command. Did you mean '" + suggestion + "'?");
-                } else {
-                    System.out.println("'" + cmd + "' is not recognized as an internal or external command.");
+                // Single, clear not-recognized message + optional suggestion
+                System.out.println("'" + cmd + "' is not recognized as an internal or external command.");
+
+                // compute suggestion safely
+                try {
+                    List<String> validCommands = new ArrayList<>(commands.keySet());
+                    String suggestion = StringUtils.findClosest(cmd, validCommands);
+                    if (suggestion != null && !suggestion.equalsIgnoreCase(cmd)) {
+                        System.out.println("Did you mean '" + suggestion + "'?");
+                    }
+                } catch (Exception ex) {
+                    // don't let suggestion errors break the shell
                 }
             }
         }

src/main/java/com/mycmd/StringUtils.java

@@ -1,48 +1,88 @@
-package com.mycmd;
+package com.mycmd.utils;
 
-import java.util.List;
+import java.util.Collection;
+import java.util.Objects;
 
-public class StringUtils {
-    // Compute Levenshtein distance between two strings
-    public static int levenshtein(String a, String b) {
-        int[] costs = new int[b.length() + 1];
-        for (int j = 0; j < costs.length; j++) {
-            costs[j] = j;
+/**
+ * Small utility for string-based helper methods.
+ * Provides a findClosest(...) implementation using Levenshtein distance.
+ */
+public final class StringUtils {
+
+    private StringUtils() {}
+
+    /**
+     * Find the closest string in candidates to the input.
+     * Returns null when no candidate is close enough.
+     *
+     * @param input the input string
+     * @param candidates candidate strings
+     * @return the closest candidate or null
+     */
+    public static String findClosest(String input, Collection<String> candidates) {
+        if (input == null || input.isEmpty() || candidates == null || candidates.isEmpty()) {
+            return null;
         }
-        for (int i = 1; i <= a.length(); i++) {
-            costs[0] = i;
-            int nw = i - 1;
-            for (int j = 1; j <= b.length(); j++) {
-                int cj = Math.min(1 + Math.min(costs[j], costs[j - 1]), a.charAt(i - 1) == b.charAt(j - 1) ? nw : nw + 1);
-                nw = costs[j];
-                costs[j] = cj;
+
+        String best = null;
+        int bestDistance = Integer.MAX_VALUE;
+
+        for (String cand : candidates) {
+            if (cand == null || cand.isEmpty()) continue;
+            if (cand.equalsIgnoreCase(input)) {
+                // exact match ignoring case - return immediately
+                return cand;
+            }
+            int dist = levenshteinDistance(input.toLowerCase(), cand.toLowerCase());
+            if (dist < bestDistance) {
+                bestDistance = dist;
+                best = cand;
             }
         }
-        return costs[b.length()];
+
+        // Choose a threshold: allow suggestion only when distance is reasonably small.
+        // Here we allow suggestions when distance <= max(1, input.length()/3)
+        int threshold = Math.max(1, input.length() / 3);
+        if (bestDistance <= threshold) {
+            return best;
+        }
+        return null;
     }
 
-    // Find the closest string from a list
-    public static String findClosest(String input, List<String> candidates) {
-        String closest = null;
-        int minDist = Integer.MAX_VALUE;
-        for (String candidate : candidates) {
-            int dist = levenshtein(input, candidate);
-            if (dist < minDist) {
-                minDist = dist;
-                closest = candidate;
-            }
+    // Classic iterative Levenshtein algorithm (memory O(min(m,n)))
+    private static int levenshteinDistance(String a, String b) {
+        if (Objects.equals(a, b)) return 0;
+        if (a.length() == 0) return b.length();
+        if (b.length() == 0) return a.length();
+
+        // ensure a is the shorter
+        if (a.length() > b.length()) {
+            String tmp = a;
+            a = b;
+            b = tmp;
         }
-        // Only return a suggestion when the distance is small enough to be useful.
-        // A threshold of 2 works well for short typos (e.g. "di" -> "dir"),
-        // and we also allow a slightly larger threshold for longer candidates.
-        if (closest == null) return null;
-        int threshold = 2;
-        int len = Math.max(input.length(), closest.length());
-        // allow up to ~25% of the length as distance for long words (min 2)
-        int adaptive = Math.max(threshold, len / 4);
-        if (minDist <= adaptive) {
-            return closest;
+
+        int[] prev = new int[a.length() + 1];
+        int[] curr = new int[a.length() + 1];
+
+        for (int i = 0; i <= a.length(); i++) prev[i] = i;
+
+        for (int j = 1; j <= b.length(); j++) {
+            curr[0] = j;
+            char bj = b.charAt(j - 1);
+            for (int i = 1; i <= a.length(); i++) {
+                int cost = (a.charAt(i - 1) == bj) ? 0 : 1;
+                curr[i] = min3(curr[i - 1] + 1, prev[i] + 1, prev[i - 1] + cost);
+            }
+            // swap prev and curr
+            int[] tmp = prev;
+            prev = curr;
+            curr = tmp;
         }
-        return null;
+        return prev[a.length()];
+    }
+
+    private static int min3(int x, int y, int z) {
+        return Math.min(x, Math.min(y, z));
     }
 }