feat: problem solve

Author: wakidurrahman

src/hackerrank/problem-solving/algorithms-001-003.ts

@@ -0,0 +1,76 @@
+//001.  sum of two integers
+function solveMeFirst(a: number, b: number) {
+  // Hint: Type return a+b below
+  return a + b;
+}
+// 002. Sum of an Array
+// Calculate the Sum of an Array Using the reduce() Method in JavaScript
+/*
+ * Complete the 'simpleArraySum' function below.
+ *
+ * The function is expected to return an INTEGER.
+ * The function accepts INTEGER_ARRAY ar as parameter.
+ */
+
+function simpleArraySum(ar: number[]): number {
+  // Write your code here
+  // parameter 'ar' ar: an array of integers
+  const sum: number = ar.reduce((accumulator, currentValue) => {
+    return accumulator + currentValue;
+  }, 0);
+  // Return the sum of the array
+  return sum;
+}
+
+// 003: compare the triplets
+
+/*
+ * Complete the 'compareTriplets' function below.
+ *
+ * The function is expected to return an INTEGER_ARRAY.
+ * The function accepts following parameters:
+ *  1. INTEGER_ARRAY a
+ *  2. INTEGER_ARRAY b
+ */
+
+function compareTriplets(a: number[], b: number[]): number[] {
+  const score: number[] = [];
+  let pointOfAlice: number = 0;
+  let pointOfBob: number = 0;
+  // Alice and Bob
+  // input a = [1, 2, 3] , b  = [3, 4, 1]
+  // comparison a[i] > b[i], a[i] < b[i] , a[i] == b[i]
+  // retrun array [1, 1] pointOfAlice and Bob score position
+
+  for (let i = 0; i <= 2; i++) {
+    if (a[i] == b[i]) {
+      pointOfAlice;
+      pointOfBob;
+    } else if (a[i] > b[i]) {
+      pointOfAlice += 1;
+    } else if (a[i] < b[i]) {
+      pointOfBob += 1;
+    }
+  }
+
+  return score.concat(pointOfAlice, pointOfBob);
+}
+
+function compareTripletsVariationOne(a: number[], b: number[]): number[] {
+  let pointOfAlice: number = 0;
+  let pointOfBob: number = 0;
+  // Alice and Bob
+  // input a = [1, 2, 3] , b  = [3, 4, 1]
+  // comparison a[i] > b[i], a[i] < b[i] , a[i] == b[i]
+  // retrun array [1, 1] pointOfAlice and Bob score position
+
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] > b[i]) {
+      pointOfAlice += 1;
+    } else if (a[i] < b[i]) {
+      pointOfBob += 1;
+    }
+  }
+
+  return [pointOfAlice, pointOfBob];
+}

src/hackerrank/problem-solving/algorithms-004-010.js

@@ -0,0 +1,48 @@
+// 004. Sum of an Array
+
+/*
+ * Complete the 'aVeryBigSum' function below.
+ *
+ * The function is expected to return a LONG_INTEGER.
+ * The function accepts LONG_INTEGER_ARRAY ar as parameter.
+ */
+
+function aVeryBigSum(ar) {
+  // Write your code here
+  const sum = ar.reduce((acct, curr) => {
+    return acct + curr;
+  }, 0);
+  return sum;
+}
+
+// 004:
+
+function diagonalDifference(arr) {
+  const lengthOfArray = arr.length; // Length of the array
+  let leftToRight = 0;
+  let rightToLeft = 0;
+
+  for (let i = 0; i < lengthOfArray; i++) {
+    for (let j = 0; j < lengthOfArray; j++) {
+      // Find The left-to-right diagonal
+      if (i === j) {
+        leftToRight += arr[i][j];
+      }
+      // Find The right to left diagonal diagonal
+      if (i + j === lengthOfArray - 1) {
+        rightToLeft += arr[i][j];
+      }
+    }
+  }
+
+  // calculate the absolute difference between the sums of its diagonals.
+  return Math.abs(leftToRight - rightToLeft);
+}
+
+const myArray = [
+  [0, 1, 2, 3],
+  [4, 5, 6, 7],
+  [8, 9, 0, 0],
+  [4, 5, 6, 7],
+];
+diagonalDifference(myArray);