solved a few and added some new ques

Author: MalihaKabir

CoderByte/firstFactorial.js

@@ -0,0 +1,29 @@
+// From CoderByte:
+// First Factorial:
+// Have the function FirstFactorial(num) take the num parameter being passed and return the factorial of it.For example: if num = 4, then your program should return (4 * 3 * 2 * 1) = 24. For the test cases, the range will be between 1 and 18 and the input will always be an integer.
+// Examples:
+// Input: 4
+// Output: 24
+// Input: 8
+// Output: 40320
+
+// Solution:
+function FirstFactorial (num) {
+// code goes here
+if (num < 1 || num > 18 || num !== parseInt(num)) {
+return 'Sorry! The range of your input will be between 1 and 18 and will always be an integer.';
+} else {
+let storeFactorialNum = num;
+for (let i = num - 1; i > 0; i--) {
+storeFactorialNum *= i;
+}
+return storeFactorialNum;
+}
+}
+
+// keep this function call here
+console.log(FirstFactorial(11));
+
+// resource of "How to check if a variable is an integer in JavaScript?": https://stackoverflow.com/questions/14636536/how-to-check-if-a-variable-is-an-integer-in-javascript
+
+

CoderByte/firstReverse.js

@@ -0,0 +1,20 @@
+// CoderByte!
+// First Reverse:
+// Have the function FirstReverse(str) take the str parameter being passed and return the string in reversed order.For example: if the input string is "Hello World and Coders" then your program should return the string sredoC dna dlroW olleH.
+// Examples
+// Input: "coderbyte"
+// Output: etybredoc
+// Input: "I Love Code"
+// Output: edoC evoL I
+
+function FirstReverse (str) {
+// code goes here
+let store = '';
+for (let i = str.length - 1; i >= 0; i--) {
+store += str[i];
+}
+return store;
+}
+
+// keep this function call here
+console.log(FirstReverse('Hello World and Coders'));

primeNum.js renamed to CoderByte/primeNum.js

@@ -0,0 +1,46 @@
+// /*
+// To Subtract the numbers in the array OR to get the integer Sum of the elements in the array, use "reduce()" method.
+// It'll give you a result in a single output value.
+// Since "reduce()" is a method, so it requires a callback function that add or subtract, (to pass it through) as a param.
+// */
+
+// Brute force approach:
+const array = [ 1001, 1002, 1003 ];
+function sumOfArr (arr) {
+let total = 0;
+for (let i = 0; i < arr.length; i++) {
+total += arr[i];
+}
+return total;
+}
+
+console.log(sumOfArr(array));
+// Brute Force Algorithms refers to a programming style that does not include any shortcuts to improve performance, but instead relies on sheer computing power to try all possibilities until the solution to a problem is found. A classic example is the traveling salesman problem (TSP).
+
+// Mild/Applicable approach:
+function aVeryBigSum0 (ar) {
+let storeArSum = ar.reduce(function (accumulator, currentValue) {
+return accumulator + currentValue;
+});
+return storeArSum;
+}
+console.log('aVeryBigSum0', aVeryBigSum0([ 13, 5, 7 ]));
+
+// OR
+const reducer = function (accumulator, currentValue) {
+return accumulator + currentValue;
+};
+function aVeryBigSum1 (ar) {
+let storeArSum = ar.reduce(reducer);
+return storeArSum;
+}
+console.log('aVeryBigSum1', aVeryBigSum1([ 5, 5, 7 ]));
+
+// More short-cut:
+const aVeryBigSum2 = (ar) => ar.reduce((a, b) => a + b, 0);
+// or ar.reduce((total, currentValue) => total + currentValue, 0);
+console.log('aVeryBigSum2', aVeryBigSum2([ 5, 5, 3 ]));
+
+// **The reduce() method executes a reducer function (that you provide) on each element of the array (loop through it), resulting in a single output value.**
+
+// For more: https://www.youtube.com/watch?v=g1C40tDP0Bk

HackerRank/aVeryBigSum/a-very-big-sum-English.pdf

@@ -0,0 +1,25 @@
+function compareTriplets (a, b) {
+let a1 = 0;
+let b1 = 0;
+let arr = [];
+
+for (let i = 0; i < a.length; i++) {
+if (a[i] > b[i]) {
+a1++;
+arr[0] = a1;
+arr[1] = b1;
+} else if (a[i] < b[i]) {
+b1++;
+arr[0] = a1;
+arr[1] = b1;
+} else if (a[i] === b[i]) {
+a1 += 0;
+ b1 += 0;
+ arr[0] = a1;
+ arr[1] = b1;
+}
+}
+return arr;
+}
+
+compareTriplets([ 1, 2, 3 ], [ 1, 2, 3 ]);

HackerRank/aVeryBigSum/aVeryBigSum.js

@@ -0,0 +1,63 @@
+// 3D Matrix/Array -> perfect square.
+// My Solution:
+function diagonalDifference0 (arr) {
+let n = arr.length;
+let diff = 0;
+for (let i = 0; i < (n - 1) / 2; i++) {
+let leftDSum = 0;
+let rightDSum = 0;
+leftDSum += arr[i][i] + arr[n - 2 - i][n - 2 - i] + arr[n - 1 - i][n - 1 - i];
+rightDSum += arr[i][n - 1 - i] + arr[n - 2 - i][n - 2 - i] + arr[n - 1 - i][i];
+diff += leftDSum - rightDSum;
+}
+return Math.abs(diff);
+}
+console.log(diagonalDifference0([ [ 11, 2, 4 ], [ 4, 5, 6 ], [ 10, 8, -12 ] ]));
+
+// Dissection:
+function diagonalDifference1 (arr) {
+let n = arr.length;
+let diff = 0;
+// here, (n-1)/2 = (3-1)/2 = 2/2 = 1. So, i < 1. And that means, this loop runs only once while i = 0 and less than 1, of course.
+for (let i = 0; i < (n - 1) / 2; i++) {
+let leftDSum = 0;
+let rightDSum = 0;
+leftDSum += arr[i][i] + arr[n - 2 - i][n - 2 - i] + arr[n - 1 - i][n - 1 - i];
+// leftDSum += 11 + 5 + (-12) = 16 - 12 = 4
+console.log('leftDSum', leftDSum); // check
+rightDSum += arr[i][n - 1 - i] + arr[n - 2 - i][n - 2 - i] + arr[n - 1 - i][i];
+// rightDSum += 4 + 5 + 10 = 19
+console.log('rightDSum', rightDSum);
+diff += leftDSum - rightDSum;
+// diff += 4 - 19 = -15
+console.log('diff', diff);
+}
+return Math.abs(diff);
+}
+console.log(diagonalDifference1([ [ 11, 2, 4 ], [ 4, 5, 6 ], [ 10, 8, -12 ] ]));
+
+// The second one is(Good one):
+function diagonalDiff0 (arr) {
+let n = arr.length;
+let leftDSum = 0;
+let rightDSum = 0;
+for (let i = 0, j = n - 1; i < n; i++, j--) {
+leftDSum += arr[i][i];
+rightDSum += arr[j][i];
+}
+return Math.abs(leftDSum - rightDSum);
+}
+console.log('diagonalDiff0', diagonalDiff0([ [ 11, 2, 4 ], [ 4, 5, 6 ], [ 10, 8, -12 ] ]));
+
+// Dissecting:
+function diagonalDiff1 (arr) {
+let n = arr.length;
+let leftDSum = 0;
+let rightDSum = 0;
+for (let i = 0; i < n; i++) {
+leftDSum += arr[i][i];
+rightDSum += arr[n - 1 - i][i];
+}
+return Math.abs(leftDSum - rightDSum);
+}
+console.log('diagonalDiff1', diagonalDiff1([ [ 11, 2, 4 ], [ 4, 5, 6 ], [ 10, 8, -12 ] ]));

HackerRank/compare-the-triplets/compare-the-triplets/compare-the-triplets-English.pdf

@@ -0,0 +1,74 @@
+// Brute force approach:
+// function diagonalDifference(arr) {
+// return Math.abs((arr[0][0]+arr[1][1]+arr[2][2]) - (arr[0][2]+arr[1][1]+arr[2][0]))
+// }
+
+// console.log(diagonalDifference([[11, 2, 4], [4, 5, 6], [10, 8, - 12]]));
+
+// Good one!
+function diagonalDiff (arr) {
+let n = arr.length;
+let leftDSum = 0;
+let rightDSum = 0;
+for (let i = 0; i < n; i++) {
+leftDSum += arr[i][i];
+rightDSum += arr[n - 1 - i][i];
+}
+return Math.abs(leftDSum - rightDSum);
+}
+console.log('diagonalDiff', diagonalDiff([ [ 11, 2, 4 ], [ 4, 5, 6 ], [ 10, 8, -12 ] ]));
+
+// 2:
+function diagonalDifference1 (arr) {
+let n = arr.length;
+let diff = 0;
+// here, (n-1)/2 = (3-1)/2 = 2/2 = 1. So, i < 1. And that means, this loop runs only once while i = 0 and less than 1, of course.
+for (let i = 0; i < (n - 1) / 2; i++) {
+let leftDSum = 0;
+let rightDSum = 0;
+leftDSum += arr[i][i] + arr[n - 2 - i][n - 2 - i] + arr[n - 1 - i][n - 1 - i];
+// leftDSum += 11 + 5 + (-12) = 16 - 12 = 4
+console.log('leftDSum', leftDSum); // check
+rightDSum += arr[i][n - 1 - i] + arr[n - 2 - i][n - 2 - i] + arr[n - 1 - i][i];
+// rightDSum += 4 + 5 + 10 = 19
+console.log('rightDSum', rightDSum);
+diff += leftDSum - rightDSum;
+// diff += 4 - 19 = -15
+console.log('diff', diff);
+}
+return Math.abs(diff);
+}
+console.log('diagonalDifference1', diagonalDifference1([ [ 11, 2, 4 ], [ 4, 5, 6 ], [ 10, 8, -12 ] ]));
+
+// Another one(Don't like it but might be the best one so far):
+function diagonalDifference2 (arr) {
+let n = arr.length;
+let diff = 0;
+for (let i = 0; i < n / 2; i++) {
+diff += arr[i][i] + arr[n - 1 - i][n - 1 - i] - arr[i][n - 1 - i] - arr[n - 1 - i][i];
+}
+return Math.abs(diff);
+}
+console.log(diagonalDifference2([ [ 11, 2, 4 ], [ 4, 5, 6 ], [ 10, 8, -12 ] ]));
+
+// Dissecting:
+function diagonalDifference3 (arr) {
+let n = arr.length;
+let diff = 0;
+// in the case of 3D Matrix, n/2 means the loop will run only once.
+for (let i = 0; i < n / 2; i++) {
+diff += arr[i][i] + arr[n - i - 1][n - i - 1] - arr[i][n - i - 1] - arr[n - i - 1][i];
+// diff += (i0 i0 + i2 i2 - i0 i2 - i2 i0);
+// diff += (11 + (-12) - 4 - 10);
+console.log('Level Zero Confusion', arr[i][i]);
+console.log('First Confusion 0', arr[n - i - 1]);
+console.log('First Confusion 1', arr[n - i - 1][n - i - 1]);
+console.log('Second Confusion', arr[i][n - i - 1]);
+console.log('Third Confusion', arr[n - i - 1][i]);
+console.log('WHOLE Confusion 0', arr[i][i] + arr[n - i - 1][n - i - 1]);
+console.log('WHOLE Confusion 1', arr[i][n - i - 1] - arr[n - i - 1][i]);
+console.log('WHOLE Confusion 2', arr[i][i] + arr[n - i - 1][n - i - 1] - arr[i][n - i - 1] - arr[n - i - 1][i]);
+}
+return Math.abs(diff);
+}
+console.log(diagonalDifference3([ [ 11, 2, 4 ], [ 4, 5, 6 ], [ 10, 8, -12 ] ]));