Merge pull request #1 from loiane/master

Code files

Author: loiane

LearningJavaScriptDataStructuresandAlgorithmsThirdEdition_Code/.babelrc

@@ -29,6 +29,7 @@
     "no-return-assign": 0,
     "no-restricted-globals": 0,
     "no-multi-assign": 0,
-    "prefer-destructuring": ["error", {"object": true, "array": false}]
+    "prefer-destructuring": ["error", {"object": true, "array": false}],
+    "padded-blocks": 0
   }
 }

LearningJavaScriptDataStructuresandAlgorithmsThirdEdition_Code/.bithoundrc

@@ -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));

LearningJavaScriptDataStructuresandAlgorithmsThirdEdition_Code/.editorconfig

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

LearningJavaScriptDataStructuresandAlgorithmsThirdEdition_Code/.eslintrc.json

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

LearningJavaScriptDataStructuresandAlgorithmsThirdEdition_Code/.firebaserc

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

LearningJavaScriptDataStructuresandAlgorithmsThirdEdition_Code/.gitignore

@@ -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]));

LearningJavaScriptDataStructuresandAlgorithmsThirdEdition_Code/.travis.yml

@@ -76,7 +76,7 @@
     "tslint": "^5.9.1",
     "typescript": "^2.7.2",
     "webpack": "^4.1.1",
-    "webpack-cli": "2.0.15",
+    "webpack-cli": "2.1.1",
     "yargs": "^11.0.0"
   },
   "dependencies": {

LearningJavaScriptDataStructuresandAlgorithmsThirdEdition_Code/.vscode/launch.json

@@ -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);
 }

LearningJavaScriptDataStructuresandAlgorithmsThirdEdition_Code/.vscode/settings.json

@@ -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';

LearningJavaScriptDataStructuresandAlgorithmsThirdEdition_Code/.vscode/tasks.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);
 }