update

Author: MaiDeveloper

caesars-cipher.js

@@ -0,0 +1,29 @@
+/**
+ * JavaScript Algorithms and Data Structures Projects: Caesars Cipher
+ *
+ * One of the simplest and most widely known ciphers is a Caesar cipher, also known as a shift cipher. In a shift cipher the meanings of the letters are shifted by some set amount.
+ *
+ * A common modern use is the ROT13 cipher, where the values of the letters are shifted by 13 places. Thus 'A' ↔ 'N', 'B' ↔ 'O' and so on.
+ *
+ * Write a function which takes a ROT13 encoded string as input and returns a decoded string.
+ *
+ * All letters will be uppercase. Do not transform any non-alphabetic character (i.e. spaces, punctuation), but do pass them on.
+ */
+
+function rot13(str) { // LBH QVQ VG!
+  let decode = '';
+
+  for (let i = 0, l = str.length; i < l; i++) {
+    if (/[A-Z]/.test(str.charAt(i))) {
+      const code = 65 + (str.charCodeAt(i) - 65 + 13) % 26;
+      decode += String.fromCharCode(code);
+    } else {
+      decode += str.charAt(i);
+    }
+  }
+
+  return decode;
+}
+
+// Change the inputs below to test
+console.log(rot13("SERR PBQR PNZC"));

factorial.js

@@ -0,0 +1,48 @@
+/**
+ * Factorial
+ *
+ * Write a function to return the factorial of a number.
+ * Factorial of a number is given by :
+ *
+ * n! = n * (n-1) * (n-2) * ..... * 1
+ *
+ * For example :
+ * 3! = 3*2*1 = 6
+ * 4! = 4*3*2*1 = 24
+ *
+ * Note :
+ * 0! = 1
+ */
+function factorial(n) {
+  if (n <= 1) {
+    return 1;
+  }
+  return n * factorial(n - 1);
+}
+
+/**
+ * Get n numbers of factorials
+ * @param {Number} n
+ * @return {Number[]}
+ * @example
+ * factorial_nums(4) // [1, 1, 2, 6]
+ * debug:
+ * [1]
+ * [1, 1],
+ * [1, 1, 2]
+ * [1, 1, 2, 6]
+ */
+function factorial_nums(n) {
+  if (n <= 1) {
+    return [1];
+  }
+  const nums = factorial_nums(n - 1);
+  nums.push(nums[nums.length - 1] * (n - 1));
+  return nums;
+}
+
+console.log(factorial(3));
+console.log(factorial(4));
+
+console.log(factorial_nums(3));
+console.log(factorial_nums(4));

factors.js

@@ -0,0 +1,24 @@
+/**
+ * Factors of an integer
+ *
+ * Write a function that returns the factors of a positive integer.
+ *
+ * These factors are the positive integers by which the number being factored can be divided to yield a positive integer result.
+ */
+
+function factors (num) {
+  const nums = [];
+
+  for (let i = 1; i <= num; i++) {
+    if (num % i === 0) {
+      nums.push(i);
+    }
+  }
+
+  return nums;
+}
+
+
+console.log(factors(45)); // should return [1,3,5,9,15,45]
+console.log(factors(53)); //should return [1,53]
+console.log(factors(64)); //should return [1,2,4,8,16,32,64]

fibonacci.js

@@ -0,0 +1,46 @@
+/**
+ * Rosetta Code: Fibonacci sequence
+ * Write a function to generate the nth Fibonacci number.
+ *
+ * The nth Fibonacci number is given by :
+ *
+ * Fn = Fn-1 + Fn-2
+ *
+ * The first two terms of the series are 0, 1.
+ *
+ * Hence, the series is : 0, 1, 1, 2, 3, 5, 8, 13...
+ */
+
+function fibonacci_recursive(n) {
+  if (n === 1) {
+    return 0;
+  } if (n === 2) {
+    return 1;
+  }
+  return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2);
+}
+
+function fibonacci(n) {
+  const nums = [0, 1];
+
+  if (n <= 2) {
+    return nums[n - 1];
+  }
+
+  for (let i = 2; i < n; i++) {
+    const next = nums[0] + nums[1];
+    nums[0] = nums[1];
+    nums[1] = next;
+  }
+  return nums[1];
+}
+
+console.log(fibonacci_recursive(3));  // 1
+console.log(fibonacci_recursive(5));  // 3
+console.log(fibonacci_recursive(10)); // 34
+
+console.log("===");
+
+console.log(fibonacci(3));  // 1
+console.log(fibonacci(5));  // 3
+console.log(fibonacci(10)); // 34

find-missing-element-in-two-arrays.js

@@ -0,0 +1,28 @@
+function find(arr1, arr2) {
+  const n = arr1.length;
+  const m = arr2.length;
+
+  if ((n !== m - 1 && m !== n - 1) || m === n) {
+    throw new Error('Invalid input');
+  }
+
+  let ans = 0;
+
+  for (let v of arr1) {
+    ans ^= v;
+  }
+
+  for (let v of arr2) {
+    ans ^= v;
+  }
+
+  return ans;
+}
+
+
+console.log(find([1,4,5,7,9], [4,5,7,9])); // 1
+console.log(find([2,3,4,5], [2,3,4,5,6])); // 6
+console.log(find([2,3,4,5,6], [1, 2,3,4,5,6])); // 6
+// 5, 6
+
+// 5 !== 5 && 6 !== 4

integer-to-roman.js

@@ -0,0 +1,70 @@
+/**
+ * Integer to Roman
+ * Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.
+ *
+ * Symbol       Value
+ * I             1
+ * V             5
+ * X             10
+ * L             50
+ * C             100
+ * D             500
+ * M             1000
+ *
+ * For example, two is written as II in Roman numeral, just two one's added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II.
+ *
+ * Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:
+ *
+ *     I can be placed before V (5) and X (10) to make 4 and 9.
+ *     X can be placed before L (50) and C (100) to make 40 and 90.
+ *     C can be placed before D (500) and M (1000) to make 400 and 900.
+ *
+ * Given an integer, convert it to a roman numeral. Input is guaranteed to be within the range from 1 to 3999.
+ *
+ * Example 1:
+ *
+ * Input: 3
+ * Output: "III"
+ *
+ * Example 2:
+ *
+ * Input: 4
+ * Output: "IV"
+ *
+ * Example 3:
+ *
+ * Input: 9
+ * Output: "IX"
+ *
+ * Example 4:
+ *
+ * Input: 58
+ * Output: "LVIII"
+ * Explanation: L = 50, V = 5, III = 3.
+ *
+ * Example 5:
+ *
+ * Input: 1994
+ * Output: "MCMXCIV"
+ * Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
+ */
+
+/**
+ * @param {number} num
+ * @return {string}
+ */
+function intToRoman(num) {
+    const nums = [ 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 ];
+    const romans = [ 'M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I' ];
+
+    let ans = '';
+
+    for (let i = 0; i < nums.length; i++) {
+        while (num >= nums[i]) {
+            ans += romans[i];
+            num -= nums[i];
+        }
+    }
+
+    return ans;
+};

is-balance.js

@@ -0,0 +1,40 @@
+/**
+ * Balanced brackets
+ *
+ * Determine whether a generated string of brackets is balanced; that is, whether it consists entirely of pairs of opening/closing brackets (in that order), none of which mis-nest.
+ *
+ * Examples:
+ * (empty) true
+ * [] true
+ * ][ false
+ * [][] true
+ * ][][ false
+ * []][[] false
+ * [[[[]]]] true
+ */
+
+function isBalanced (str) {
+  let bal = 0;
+
+  for (let i = 0; i < str.length; i++) {
+    if (str.charAt(i) === "[") {
+      bal += 1;
+    } else {
+      bal -= 1;
+    }
+
+    if (bal < 0) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+console.log(isBalanced('') === true);
+console.log(isBalanced('[]') === true);
+console.log(isBalanced('))][') === false);
+console.log(isBalanced('[][]') === true);
+console.log(isBalanced('))][][') === false);
+console.log(isBalanced('[]][[]') === false);
+console.log(isBalanced('[[[[]]]]') === true);

longest-palindromic-substring.js

@@ -10,20 +10,20 @@ function longestPalindromeSubstring(str) {
   }
 
   let start = 0;
-  let end = 0;
+  let maxLen = 0;
 
   for (let i = 0, l = str.length; i < l; i++) {
     let len1 = expandAroundCenter(str, i, i);
     let len2 = expandAroundCenter(str, i, i + 1);
     let len = Math.max(len1, len2);
 
-    if (len > end - start) {
+    if (len > maxLen) {
+      maxLen = len;
       start = i - Math.floor((len - 1) / 2);
-      end = i + Math.floor(len / 2);
     }
   }
 
-  return str.substring(start, end + 1);
+  return str.substr(start, maxLen);
 }
 
 /**

merge-sort.js

@@ -23,28 +23,54 @@ function mergeSort(arr) {
   const left = mergeSort(arr.slice(0, mid));
   const right = mergeSort(arr.slice(mid));
 
-  let i = 0;
-  let j = 0;
-  let sorted = [];
+  return merge(left, right);
+}
+
+function merge(left, right) {
+  const arr = [];
 
-  while (i < left.length && j < right.length) {
-    if (left[i] < right[j]) {
-      sorted.push(left[i++]);
+  while (left.length && right.length) {
+    if (left[0] < right[0]) {
+      arr.push(left.shift());
     } else {
-      sorted.push(right[j++]);
+      arr.push(right.shift());
     }
   }
 
-  while (i < left.length) {
-    sorted.push(left[i++]);
-  }
+  return arr.concat(left).concat(right);
+}
 
-  while (j < right.length) {
-    sorted.push(right[j++]);
-  }
+// function mergeSort(arr) {
+//   if (arr.length <= 1) {
+//     return arr;
+//   }
 
-  return sorted;
-}
+//   const mid = Math.floor(arr.length / 2);
+//   const left = mergeSort(arr.slice(0, mid));
+//   const right = mergeSort(arr.slice(mid));
+
+//   let i = 0;
+//   let j = 0;
+//   let sorted = [];
+
+//   while (i < left.length && j < right.length) {
+//     if (left[i] < right[j]) {
+//       sorted.push(left[i++]);
+//     } else {
+//       sorted.push(right[j++]);
+//     }
+//   }
+
+//   while (i < left.length) {
+//     sorted.push(left[i++]);
+//   }
+
+//   while (j < right.length) {
+//     sorted.push(right[j++]);
+//   }
+
+//   return sorted;
+// }
 
 console.log(mergeSort([1, 4, 2, 8, 345, 123, 43, 32, 5643, 63, 123, 43, 2, 55, 1, 234, 92]));
 console.log(mergeSort([1, 4, 2, 8, 345, 3]));