Merge pull request mgechev#115 from krzysztof-grzybek/longest-common-subsequence

mgechev#111 Longest common subsequence

Author: mgechev

src/searching/longest-common-subsequence.js

@@ -0,0 +1,86 @@
+(function (exports) {
+  'use strict';
+
+  exports.longestCommonSubsequence = (function () {
+
+    /**
+     * Find the lengths of longest common sub-sequences
+     * of two strings and their substrings.
+     *
+     * Complexity: O(MN).
+     *
+     * @private
+     * @param {String} first string
+     * @param {String} second string
+     * @return {Array} two dimensional array with LCS
+     * lengths of input strings and their substrings.
+     *
+     */
+    function getLcsLengths(str1, str2) {
+      var result = [];
+      for (var i = -1; i < str1.length; i = i + 1) {
+        result[i] = [];
+        for (var j = -1; j < str2.length; j = j + 1) {
+          if (i === -1 || j === -1) {
+            result[i][j] = 0;
+          } else if (str1[i] === str2[j]) {
+            result[i][j] = result[i - 1][j - 1] + 1;
+          } else {
+            result[i][j] = Math.max(result[i - 1][j], result[i][j - 1]);
+          }
+        }
+      }
+      return result;
+    }
+
+    /**
+     * Find longest common sub-sequences of two strings.
+     *
+     * Complexity: O(M + N).
+     *
+     * @private
+     * @param {String} first string
+     * @param {String} second string
+     * @return {Array} two dimensional array with LCS
+     * lengths of input strings and their substrings
+     * returned from 'getLcsLengths' function.
+     *
+     */
+    function getLcs(str1, str2, lcsLengthsMatrix) {
+      var execute = function (i, j) {
+        if (!lcsLengthsMatrix[i][j]) {
+          return '';
+        } else if (str1[i] === str2[j]) {
+          return execute(i - 1, j - 1) + str1[i];
+        } else if (lcsLengthsMatrix[i][j - 1] > lcsLengthsMatrix[i - 1][j]) {
+          return execute(i, j - 1);
+        } else {
+          return execute(i - 1, j);
+        }
+      };
+      return execute(str1.length - 1, str2.length - 1);
+    }
+
+    /**
+     * Algorithm from dynamic programming. It finds the longest
+     * common sub-sequence of two strings. For example for strings 'abcd'
+     * and 'axxcda' the longest common sub-sequence is 'acd'.
+     *
+     * @example
+     * var subsequence = require('path-to-algorithms/src/searching/'+
+     * 'longest-common-subsequence').longestCommonSubsequence;
+     * console.log(subsequence('abcd', 'axxcda'); // 'acd'
+     *
+     * @public
+     * @module searching/longest-common-subsequence
+     * @param {String} first input string.
+     * @param {String} second input string.
+     * @return {Array} Longest common subsequence.
+     */
+    return function (str1, str2) {
+      var lcsLengthsMatrix = getLcsLengths(str1, str2);
+      return getLcs(str1, str2, lcsLengthsMatrix);
+    };
+  })();
+
+})(typeof window === 'undefined' ? module.exports : window);

src/searching/longest-subsequence.js renamed to src/searching/longest-increasing-subsequence.js

@@ -1,7 +1,7 @@
 (function (exports) {
   'use strict';
 
-  exports.longestSubsequence = (function () {
+  exports.longestIncreasingSubsequence = (function () {
 
     /**
     * Find the index of the first largest element in array.
@@ -57,12 +57,12 @@
     }
 
     /**
-    * Finds the longest sub-sequence for given node.<br><br>
+    * Finds the longest increasing sub-sequence for given node.<br><br>
     * Complexity: O(N^N).
     * @private
     * @param {Object} dag  Graph represented with list of neighbours.
     * @param {number} node The current node.
-    * @return {object} The longest sub-sequence for given node.
+    * @return {object} The longest increasing sub-sequence for given node.
     */
     function find(dag, node) {
       node = node || 0;
@@ -103,7 +103,7 @@
     *
     * @example
     * var subsequence = require('path-to-algorithms/src/searching/'+
-    * 'longest-increasing-subsequence').longestSubsequence;
+    * 'longest-increasing-subsequence').longestIncreasingSubsequence;
     * console.log(subsequence([1, 0, 4, 3, 5])); // 1, 4, 5
     *
     * @public

test/searching/longest-common-subsequence.spec.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var longestCommonSubsequence =
+  require('../../src/searching/' +
+    'longest-common-subsequence')
+    .longestCommonSubsequence;
+
+describe('longest common subsequence', function () {
+
+  it('should work with empty strings', function () {
+    expect(longestCommonSubsequence('', '')).toBe('');
+  });
+
+  it('should work with first string empty', function () {
+    expect(longestCommonSubsequence('', 'abcd')).toBe('');
+  });
+
+  it('should work with second string empty', function () {
+    expect(longestCommonSubsequence('abcd', '')).toBe('');
+  });
+
+  it('should work if there is no lcs', function () {
+    expect(longestCommonSubsequence('qtwer', 'zvxcv')).toBe('');
+  });
+
+  it('should work if lcs is whole first string', function () {
+    expect(longestCommonSubsequence('abc', 'abcdefghi')).toBe('abc');
+  });
+
+  it('should work if lcs is whole second string', function () {
+    expect(longestCommonSubsequence('qwerty', 'rty')).toBe('rty');
+  });
+
+  it('should work with repeated letter', function () {
+    expect(longestCommonSubsequence('AAATC', 'GGTAGGC')).toBe('AC');
+  });
+
+  it('should work with custom characters', function () {
+    expect(longestCommonSubsequence(':-)', 'B-)')).toBe('-)');
+  });
+
+  it('should work with long strings', function () {
+    expect(longestCommonSubsequence('this is the first string', 'that is second')).toBe('tht is sn');
+  });
+
+  it('should work with very long strings', function () {
+    expect(longestCommonSubsequence('giiiiiiit1huuuuuu2bbb', 'zzxxcvasdfgmntplpliiggggu2b222')).toBe('giiu2b');
+  });
+});

test/searching/longest-subsequence.spec.js renamed to test/searching/longest-increasing-subsequence.spec.js

@@ -1,36 +1,36 @@
 'use strict';
 
-var longestSubsequence =
+var longestIncreasingSubsequence =
   require('../../src/searching/' +
-    'longest-subsequence')
-    .longestSubsequence;
+    'longest-increasing-subsequence')
+    .longestIncreasingSubsequence;
 
-describe('longest subsequence', function () {
+describe('longest increasing subsequence', function () {
 
   var sequence;
   beforeEach(function () {
     sequence = [5, 2, 8, 6, 3, 6, 9, 7, 11];
   });
 
   it('should work with empty array', function () {
-    expect(longestSubsequence([]).length).toBe(0);
+    expect(longestIncreasingSubsequence([]).length).toBe(0);
   });
 
   it('should return the only element in a single element array', function () {
     var array = [1];
-    expect(longestSubsequence(array)).toEqual([1]);
+    expect(longestIncreasingSubsequence(array)).toEqual([1]);
   });
 
   it('should give the right length', function () {
-    expect(longestSubsequence(sequence).length).toBe(5);
+    expect(longestIncreasingSubsequence(sequence).length).toBe(5);
   });
 
   it('should work with empty arrays', function () {
-    expect(longestSubsequence([]).length).toBe(0);
+    expect(longestIncreasingSubsequence([]).length).toBe(0);
   });
 
   it('should return the correct path', function () {
-    expect(longestSubsequence(sequence).toString())
+    expect(longestIncreasingSubsequence(sequence).toString())
       .toBe([2, 3, 6, 9, 11].toString());
   });
 
@@ -39,7 +39,7 @@ describe('longest subsequence', function () {
       return b - a;
     };
     var seq = [1, 2, -1];
-    var result = longestSubsequence(seq, cmp);
+    var result = longestIncreasingSubsequence(seq, cmp);
     expect(result.length).toBe(2);
     expect(result).toEqual([1, -1]);
   });