[Algorithm Design and Techniques]

Author: loiane

examples/PacktDataStructuresAlgorithms.min.js

@@ -0,0 +1,8 @@
+const { lcs } = PacktDataStructuresAlgorithms;
+const { lcsPrint } = PacktDataStructuresAlgorithms;
+
+const wordX = 'acbaed';
+const wordY = 'abcadf';
+
+console.log('lcs', lcs(wordX, wordY));
+console.log('lcsPrint', lcsPrint(wordX, wordY));

examples/PacktDataStructuresAlgorithms.min.js.map

@@ -0,0 +1,6 @@
+const { lcsRecursive } = PacktDataStructuresAlgorithms;
+
+const wordX = 'acbaed';
+const wordY = 'abcadf';
+
+console.log('lcsRecursive', lcsRecursive(wordX, wordY));

examples/chapter14/07-LongestCommonSubsequenceDP.js

@@ -0,0 +1,5 @@
+const { matrixChainOrder } = PacktDataStructuresAlgorithms;
+
+const p = [10, 100, 5, 50, 1];
+const n = p.length;
+console.log(matrixChainOrder(p, n));

examples/chapter14/08-LongestCommonSubsequenceRecursive.js

@@ -0,0 +1,5 @@
+const { matrixChainOrderGreedy } = PacktDataStructuresAlgorithms;
+
+const p = [10, 100, 5, 50, 1];
+const n = p.length;
+console.log(matrixChainOrderGreedy(p, n));

examples/chapter14/09-MatrixChainMultiplicationDP.js

@@ -0,0 +1,147 @@
+console.log('Using imperative JS');
+
+var printArray = function(array){
+    for (var i=0; i<array.length; i++){
+        console.log(array[i]);
+    }
+};
+
+printArray([1, 2, 3, 4, 5]);
+
+//how can we abstract the For flow? Can we use a callback for action?
+
+console.log('Using functional JS');
+
+var forEach = function(array, action){
+    for (var i=0; i<array.length; i++){
+        action(array[i]);
+    }
+};
+
+var logItem = function (item) {
+    console.log(item);
+};
+
+forEach([1, 2, 3, 4, 5], logItem);
+
+//how can we abstract the For flow?
+console.log('Finding the min value in an array - imperative');
+
+var findMinArray = function(array){
+    var minValue = array[0];
+    for (var i=1; i<array.length; i++){
+        if (minValue > array[i]){
+            minValue = array[i];
+        }
+    }
+
+    return minValue;
+};
+
+console.log(findMinArray([8,6,4,5,9]));
+
+console.log('Finding the min value in an array - functional ES2015');
+const min_ = function(array){
+    return Math.min(...array)
+};
+
+//simplifying using arrow functions
+const min = arr => Math.min(...arr);
+
+console.log(min_([8,6,4,5,9]));
+console.log(min([8,6,4,5,9]));
+
+//concat + reduce
+console.log('merge arrays - imperative');
+
+var mergeArrays_ = function(arrays){
+    var count = arrays.length,
+        newArray = [],
+        k =0;
+    for (var i=0; i<count; i++){
+        for (var j=0; j<arrays[i].length; j++){
+            newArray[k++] = arrays[i][j];
+        }
+    }
+    return newArray;
+};
+
+console.log(mergeArrays_([[1, 2, 3], [4, 5], [6]]));
+
+console.log('merge arrays - using concat');
+var mergeArraysConcat = function(arrays){
+    return arrays.reduce( function(p,n){
+        return p.concat(n);
+    });
+};
+
+console.log(mergeArraysConcat([[1, 2, 3], [4, 5], [6]]));
+
+console.log('merge arrays - ES2015');
+
+const mergeArrays = (...arrays) => [].concat(...arrays);
+console.log(mergeArrays([1, 2, 3], [4, 5], [6]));
+
+console.log('sum values of arrays - imperative');
+var sumValues = function(array){
+    var total = array[0];
+    for (var i=1; i<array.length; i++){
+        total += array[i];
+    }
+    return total;
+};
+
+console.log(sumValues([1, 2, 3, 4, 5]));
+
+//reduce
+console.log('sum values of arrays - functional');
+var sum_ = function(array){
+    return array.reduce(function(a, b){
+        return a + b;
+    })
+};
+
+console.log(sum_([1, 2, 3, 4, 5]));
+
+console.log('sum values of arrays - ES2015');
+const sum = arr => arr.reduce((a, b) => a + b);
+
+console.log(sum([1, 2, 3, 4, 5]));
+
+//map
+var daysOfWeek = [
+    {name: 'Monday', value: 1},
+    {name: 'Tuesday', value: 2},
+    {name: 'Wednesday', value: 7}
+];
+
+var daysOfWeekValues_ = [];
+for (var i = 0; i < daysOfWeek.length; i++) {
+    daysOfWeekValues_.push(daysOfWeek[i].value);
+}
+
+//to
+var daysOfWeekValues = daysOfWeek.map(function(day) {
+    return day.value;
+});
+console.log(daysOfWeekValues);
+
+
+//filter
+var positiveNumbers_ = function(array){
+    var positive = [];
+    for (var i = 0; i < array.length; i++) {
+        if (array[i] >= 0){
+            positive.push(array[i]);
+        }
+    }
+    return positive;
+}
+console.log(positiveNumbers_([-1,1,2,-2]));
+
+var positiveNumbers = function(array){
+    return array.filter(function(num){
+        return num >= 0;
+    })
+};
+console.log(positiveNumbers([-1,1,2,-2]));

examples/chapter14/10-MatrixChainMultiplicationRecursive.js

@@ -15,7 +15,7 @@ function printSolution(solution, wordX, m, n) {
     }
     x = solution[a][b];
   }
-  // console.log('lcs: ' + answer);
+  return answer;
 }
 export function lcs(wordX, wordY) {
   const m = wordX.length;
@@ -47,6 +47,5 @@ export function lcs(wordX, wordY) {
     // console.log(l[i].join());
     // console.log(solution[i].join());
   }
-  printSolution(solution, wordX, m, n);
-  return l[m][n];
+  return printSolution(solution, wordX, m, n);
 }

examples/chapter14/13-IntroFunctionalProgramming.js

@@ -92,5 +92,7 @@ export { knapSack as knapSackGreedy } from './algorithms/greedy/knapsack';
 export { lcs } from './algorithms/dynamic-programing/longest-common-subsequence';
 export { lcs as lcsPrint } from './algorithms/dynamic-programing/longest-common-subsequence-print';
 export { lcs as lcsRecursive } from './algorithms/greedy/longest-common-subsequence';
+export { matrixChainOrder } from './algorithms/dynamic-programing/matrix-chain-multiplication';
+export { matrixChainOrder as matrixChainOrderGreedy } from './algorithms/greedy/matrix-chain-multiplication';
 export { ratInAMaze } from './algorithms/backtracking/rat-in-maze';
 export { sudokuSolver } from './algorithms/backtracking/sudoku-solver';

package-lock.json

@@ -31,9 +31,9 @@ export function lcs(wordX: string, wordY: string) {
     // console.log(solution[i].join());
   }
 
-  printSolution(solution, wordX, m, n);
+  return printSolution(solution, wordX, m, n);
 
-  return l[m][n];
+  // return l[m][n];
 }
 
 function printSolution(solution: Array<Array<string>>, wordX: string, m: number, n: number) {
@@ -55,5 +55,6 @@ function printSolution(solution: Array<Array<string>>, wordX: string, m: number,
     x = solution[a][b];
   }
 
+  return answer;
   // console.log('lcs: ' + answer);
 }

src/js/algorithms/dynamic-programing/longest-common-subsequence-print.js

@@ -0,0 +1,16 @@
+import 'mocha';
+import { expect } from 'chai';
+import { knapSackRecursive } from '../../../../src/ts/index';
+
+describe('KnapSack Dynamic Programming - Recursive', () => {
+  const SIZE = 100;
+
+  it('works with recursive approach', () => {
+    const values = [3, 4, 5];
+    const weights = [2, 3, 4];
+    const capacity = 5;
+    const n = values.length;
+
+    expect(knapSackRecursive(capacity, weights, values, n)).to.equal(7);
+  });
+});

src/js/index.js

@@ -0,0 +1,16 @@
+import 'mocha';
+import { expect } from 'chai';
+import { knapSack } from '../../../../src/ts/index';
+
+describe('KnapSack Dynamic Programming', () => {
+  const SIZE = 100;
+
+  it('works with DP approach', () => {
+    const values = [3, 4, 5];
+    const weights = [2, 3, 4];
+    const capacity = 5;
+    const n = values.length;
+
+    expect(knapSack(capacity, weights, values, n)).to.equal(7);
+  });
+});

src/ts/algorithms/dynamic-programing/longest-common-subsequence-print.ts

@@ -2,7 +2,7 @@ import 'mocha';
 import { expect } from 'chai';
 import { knapSackGreedy } from '../../../../src/ts/index';
 
-describe('Min Coin Change Greedy', () => {
+describe('KnapSack Greedy', () => {
   const SIZE = 100;
 
   it('works with greedy approach', () => {