added algorithms JS

Author: gkitg

JS/2_algorithms/0_bubbleSortUp.js

@@ -0,0 +1,17 @@
+let arr = [12, 2, 45, 6, 32, 357, 24, 6346, 123, 75];
+
+function bubbleSort(arr) {
+    for (let i = 0; i < arr.length; i++) {
+        for (let j = 0; j < arr.length - 1; j++) {
+            if (arr[j + 1] > arr[j]) {
+                let temp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = temp;
+            }
+        }
+    }
+    return arr;
+}
+
+console.log(bubbleSort(arr));
+ 

JS/2_algorithms/10_capitalization.js

@@ -0,0 +1,14 @@
+function capitalization(str) {
+  const arr = str.split(" ").map(word => {
+    word = word.split("");
+    word[0] = word[0].toUpperCase();
+    return word.join("");
+  });
+
+  return arr.join(" ");
+}
+
+console.log(capitalization("a short sentence"));
+console.log(capitalization("a lazy fox"));
+console.log(capitalization("look, it is working!"));
+ 

JS/2_algorithms/11_findWord.js

@@ -0,0 +1,29 @@
+let paragraph = "Bob hit a ball, the hit BALL flew far after it was hit";
+
+function fillArray(paragraph) {
+  let regexp = /,/;
+  let freq = {};
+  let max = 0;
+
+  paragraph = paragraph
+    .replace(regexp, "")
+    .toLowerCase()
+    .split(" ");
+
+  paragraph.forEach(word => {
+    if (freq[word]) {
+      freq[word]++;
+    } else {
+      freq[word] = 1;
+    }
+
+    if (freq[word] > max) {
+      max = freq[word];
+      result = word;
+    }
+  });
+
+  return result;
+}
+
+console.log(fillArray(paragraph)); // hit

JS/2_algorithms/12_fizzBuzz.js

@@ -0,0 +1,12 @@
+function fizzBuzz(n) {
+  for (let i = 1; i <= n; i++) {
+    str = "";
+    if (i % 3 === 0) str += "fizz";
+    if (i % 5 === 0) str += "buzz";
+
+    console.log(str ? str : i);
+  }
+}
+
+fizzBuzz(30);
+ 

JS/2_algorithms/13_isBracersCorrect.js

@@ -0,0 +1,30 @@
+let testCase1 = "()";
+let testCase2 = "()[]{}";
+let testCase3 = "(|";
+let testCase4 = "(|)]";
+let testCase5 = "{[]}";
+
+function isCorrect(str) {
+    let stack = [];
+    for (let i = 0; i < str.length; i++) {
+        if (str[i] === "[" || str[i] === "(" || str[i] === "{") {
+            stack.push(str[i]);
+        } else {
+            if (stack.length === 0) {
+                return false;
+            }
+            let top = stack.pop();
+            if (top === "[" && str[i] !== "]") return false;
+            if (top === "(" && str[i] !== ")") return false;
+            if (top === "{" && str[i] !== "}") return false;
+        }
+    }
+    return stack.length === 0 ? true : false;
+}
+
+console.log(isCorrect(testCase1)); // true
+console.log(isCorrect(testCase2)); // true
+console.log(isCorrect(testCase3)); // false
+console.log(isCorrect(testCase4)); // false
+console.log(isCorrect(testCase5)); // true
+ 

JS/2_algorithms/14_isPalindrom.js

@@ -0,0 +1,23 @@
+let testCase1 = "abba";
+let testCase2 = "a Bb  a";
+let testCase3 = "bba";
+let testCase4 = "aba";
+
+function isPalindrom(s) {
+    let regex = /\s/g;
+
+    s = s.replace(regex, "").toLowerCase();
+
+    for (let i = 0; i < s.length / 2; i++) {
+        if (s[i] !== s[s.length - 1 - i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+console.log(isPalindrom(testCase1)); // true
+console.log(isPalindrom(testCase2)); // true
+console.log(isPalindrom(testCase3)); // false
+console.log(isPalindrom(testCase4)); // true
+ 

JS/2_algorithms/15_mostCommonChar.js

@@ -0,0 +1,20 @@
+const str = "abcccdd";
+
+function maxChar(str) {
+  const obj = {};
+  let max = 0;
+  let result = "";
+
+  for (let char of str) {
+    obj[char] = obj[char] + 1 || 1;
+    if (obj[char] > max) {
+      max = obj[char];
+      result = char;
+    }
+  }
+
+  return result;
+}
+
+console.log(maxChar(str));
+ 

JS/2_algorithms/16_myOwnForEach.js

@@ -0,0 +1,10 @@
+Array.prototype.myForEach = function(func) {
+    for (var i = 0; i < this.length; i++) {
+        func(this[i]);
+    }
+};
+
+[1, 2, 3, 45].myForEach(i => {
+    console.log(i);
+});
+ 

JS/2_algorithms/17_palindrom.js

@@ -0,0 +1,23 @@
+const word = "abba";
+
+function first(word) {
+  const length = word.length - 1;
+
+  for (let i = 0; i <= length / 2; i++) {
+    if (word[i] !== word[length - i]) return false;
+  }
+  return true;
+}
+
+function second(word) {
+  const reversed = word
+    .split("")
+    .reverse()
+    .join("");
+
+  return reversed === word;
+}
+
+console.log(first(word));
+console.log(second(word));
+ 

JS/2_algorithms/18_pyramid.js

@@ -0,0 +1,19 @@
+function pyramid(n) {
+  const mid = Math.floor(n - 0.5);
+
+  for (let i = 0; i < n; i++) {
+    let line = "";
+
+    for (let j = 0; j <= 2 * n - 1; j++) {
+      if (mid - i <= j && mid + i >= j) {
+        line += "#";
+      } else {
+        line += " ";
+      }
+    }
+    console.log(line, line.length);
+  }
+}
+
+console.log(pyramid(4));
+