Add one more solution for StringTransformation task

Author: andrei-punko

interview-materials/tasks.md

@@ -19,22 +19,6 @@ Add operation with pets batch update (for example, add new field - owner).
 Propose algorithm for sorting a bunch of long strings situated on disk.
 We have restriction of RAM size: so only one string could be loaded into RAM simultaneously.
 
-## Make one string from another
-
-Написать метод, на вход которого приходит две строки.
-На выходе надо проверить, можно ли получить одну строку из другой за одно исправление:
-
-- замена одного символа в одной строке
-- вставка/удаление одного символа из одной строки
-
-Примеры тестовых сценариев:
-
-- first = "a", second = "b" -> true
-- first = "ab", second = "b" -> true
-- first = "ab", second = "cb" -> true
-- first = "ab", second = "ba" -> false
-- first = "abcd", second = "abd" -> true
-
 ## Сортировки:
 
 - быстрая

src/main/java/by/andd3dfx/string/StringTransformation.java

@@ -2,6 +2,8 @@
 
 import org.apache.commons.lang3.StringUtils;
 
+import static org.apache.commons.lang3.math.NumberUtils.min;
+
 /**
  * <pre>
  * Написать метод (класс и импорты не нужны) на вход которого приходит две строки.
@@ -67,4 +69,49 @@ private static boolean remainingPartsShouldBeEqual(String first, int from1, Stri
                 second.substring(from2)
         );
     }
+
+    public static boolean couldTransformUsingLevenshteinDistance(String first, String second) {
+        return levenshteinDistance(first, second) <= 1;
+    }
+
+    /**
+     * Use Wagner-Fisher algorithm. For details check
+     * <a href="https://habr.com/ru/articles/676858/">article1</a>,
+     * <a href="https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorithm">article2</a>
+     *
+     * @param str1 First string
+     * @param str2 Second string
+     * @return Levenshtein distance
+     */
+    public static int levenshteinDistance(String str1, String str2) {
+        var m = str1.length();
+        var n = str2.length();
+        // for all i and j, d[i,j] will hold the distance between
+        // the first i characters of s and the first j characters of t
+        // note that d has (m+1)*(n+1) values
+        var d = new int[m + 1][n + 1];
+
+        // source prefixes can be transformed into empty string by
+        // dropping all characters
+        for (int i = 1; i <= m; i++) {
+            d[i][0] = i;
+        }
+
+        // target prefixes can be reached from empty source prefix
+        // by inserting every character
+        for (int j = 1; j <= n; j++) {
+            d[0][j] = j;
+        }
+
+        for (int j = 1; j <= n; j++) {
+            for (int i = 1; i <= m; i++) {
+                var substitutionCost = (str1.charAt(i - 1) == str2.charAt(j - 1)) ? 0 : 1;
+
+                d[i][j] = min(d[i - 1][j] + 1,               // deletion
+                        d[i][j - 1] + 1,                        // insertion
+                        d[i - 1][j - 1] + substitutionCost);    // substitution
+            }
+        }
+        return d[m][n];
+    }
 }

src/test/java/by/andd3dfx/string/StringTransformationTest.java

@@ -3,6 +3,7 @@
 import org.junit.Test;
 
 import static by.andd3dfx.string.StringTransformation.couldTransform;
+import static by.andd3dfx.string.StringTransformation.couldTransformUsingLevenshteinDistance;
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class StringTransformationTest {
@@ -12,32 +13,51 @@ public void couldTransform_changeOneChar() {
         assertThat(couldTransform("a", "b")).isTrue();      // change one char, 1-char string
         assertThat(couldTransform("a1b", "c1b")).isTrue();  // change one (first) char
         assertThat(couldTransform("a1b", "a1d")).isTrue();  // change one (last) char
+
+        assertThat(couldTransformUsingLevenshteinDistance("a", "b")).isTrue();      // change one char, 1-char string
+        assertThat(couldTransformUsingLevenshteinDistance("a1b", "c1b")).isTrue();  // change one (first) char
+        assertThat(couldTransformUsingLevenshteinDistance("a1b", "a1d")).isTrue();  // change one (last) char
     }
 
     @Test
     public void couldTransform_removeOneChar() {
         assertThat(couldTransform("abcd", "bcd")).isTrue(); // remove one (first) char
         assertThat(couldTransform("abcd", "acd")).isTrue(); // remove one (inner) char
         assertThat(couldTransform("abcd", "abc")).isTrue(); // remove one (last) char
+
+        assertThat(couldTransformUsingLevenshteinDistance("abcd", "bcd")).isTrue(); // remove one (first) char
+        assertThat(couldTransformUsingLevenshteinDistance("abcd", "acd")).isTrue(); // remove one (inner) char
+        assertThat(couldTransformUsingLevenshteinDistance("abcd", "abc")).isTrue(); // remove one (last) char
     }
 
     @Test
     public void couldTransform_addOneChar() {
         assertThat(couldTransform("bcd", "abcd")).isTrue(); // add one (first) char
         assertThat(couldTransform("abd", "abcd")).isTrue(); // add one (inner) char
         assertThat(couldTransform("abc", "abcd")).isTrue(); // add one (last) char
+
+        assertThat(couldTransformUsingLevenshteinDistance("bcd", "abcd")).isTrue(); // add one (first) char
+        assertThat(couldTransformUsingLevenshteinDistance("abd", "abcd")).isTrue(); // add one (inner) char
+        assertThat(couldTransformUsingLevenshteinDistance("abc", "abcd")).isTrue(); // add one (last) char
     }
 
     @Test
     public void couldTransform_significantlyDifferentLengths() {
         assertThat(couldTransform("abcd", "ab")).isFalse();
         assertThat(couldTransform("bc", "abcd")).isFalse();
+
+        assertThat(couldTransformUsingLevenshteinDistance("abcd", "ab")).isFalse();
+        assertThat(couldTransformUsingLevenshteinDistance("bc", "abcd")).isFalse();
     }
 
     @Test
     public void couldTransform_transformIsNotPossible() {
         assertThat(couldTransform("ab", "ba")).isFalse();       // same lengths
         assertThat(couldTransform("abcde", "abdm")).isFalse();  // different lengths
         assertThat(couldTransform("abdm", "abcde")).isFalse();  // different lengths
+
+        assertThat(couldTransformUsingLevenshteinDistance("ab", "ba")).isFalse();       // same lengths
+        assertThat(couldTransformUsingLevenshteinDistance("abcde", "abdm")).isFalse();  // different lengths
+        assertThat(couldTransformUsingLevenshteinDistance("abdm", "abcde")).isFalse();  // different lengths
     }
 }