diff --git a/elementaryAlgo/ASCII.js b/elementaryAlgo/ASCII.js
new file mode 100644
index 0000000..680409d
--- /dev/null
+++ b/elementaryAlgo/ASCII.js
@@ -0,0 +1,3 @@
+console.log("a".codePointAt(0));
+console.log("a".charCodeAt(0));
+console.log(String.fromCharCode(97));
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/arrayOfPairsFromObject.js b/elementaryAlgo/JavaScriptCodeChallenge/arrayOfPairsFromObject.js
new file mode 100644
index 0000000..805a93a
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/arrayOfPairsFromObject.js
@@ -0,0 +1,4 @@
+let obj = { name: "rabo", age: 44 };
+const map = new Map(Object.entries(obj));
+console.log(map);
+console.log(Object.entries(obj));
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/displayAllPropertyOfnestedObjec.js b/elementaryAlgo/JavaScriptCodeChallenge/displayAllPropertyOfnestedObjec.js
new file mode 100644
index 0000000..659517c
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/displayAllPropertyOfnestedObjec.js
@@ -0,0 +1,11 @@
+let obj = { name: "rabo", detail: { age: 70, bank: { byy: 6667, num: 6667 } } };
+const allProperties = (obj) => {
+ for (let prop in obj) {
+ if (typeof obj[prop] !== "object") {
+ console.log(prop + " " + obj[prop] + "");
+ } else {
+ allProperties(obj[prop]);
+ }
+ }
+};
+console.log(allProperties(obj));
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/excludePropUsinJSON.js b/elementaryAlgo/JavaScriptCodeChallenge/excludePropUsinJSON.js
new file mode 100644
index 0000000..8f86e67
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/excludePropUsinJSON.js
@@ -0,0 +1,18 @@
+const obj = {
+ id: 1,
+ username: "Rabo",
+ email: "raboyus@agmail.com",
+ password: "password35678",
+};
+//copy the obj while excluding password
+console.log(JSON.stringify(obj, ["id", "username", "email"]));
+console.log(JSON.parse(JSON.stringify(obj, ["id", "username", "email"])));
+
+//another way
+console.log(
+ JSON.parse(
+ JSON.stringify(obj, (key, value) =>
+ key === "password" ? undefined : value
+ )
+ )
+);
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/firstLastChar.js b/elementaryAlgo/JavaScriptCodeChallenge/firstLastChar.js
new file mode 100644
index 0000000..b7aa3be
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/firstLastChar.js
@@ -0,0 +1,10 @@
+function getTheGapX(str) {
+ if (!str.includes("X")) {
+ return -1;
+ }
+ const firstIndex = str.indexOf("X");
+ const lastIndex = str.lastIndexOf("X");
+ return firstIndex === lastIndex ? -1 : lastIndex - firstIndex;
+}
+console.log(getTheGapX("JavaScript"));
+getTheGapX("Xamarin");
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/howToEmptyObj.js b/elementaryAlgo/JavaScriptCodeChallenge/howToEmptyObj.js
new file mode 100644
index 0000000..0ea2d42
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/howToEmptyObj.js
@@ -0,0 +1,7 @@
+let ob = { name: "9" };
+for (let key in ob) {
+ if (ob.hasOwnProperty(key)) {
+ delete ob[key];
+ }
+}
+console.log(ob);
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/objectCopy.js b/elementaryAlgo/JavaScriptCodeChallenge/objectCopy.js
new file mode 100644
index 0000000..9e989e4
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/objectCopy.js
@@ -0,0 +1,34 @@
+const obj = { name: "rabo", description: "black and brain" };
+//shallow copy
+let shallow = { ...obj };
+console.log(shallow);
+//shallow copy and add properties
+let shallowCopy = { ...obj, age: 0 };
+console.log(shallowCopy);
+//shallow copy by Object.assign();
+let shallowAssign = Object.assign({}, obj, { country: "nigeria" });
+console.log(shallowAssign);
+//stringify
+let dee = { age: 67, email: "rab@gmail.com", desp: { num: 0 } };
+let fee = dee;
+//console.log(fee.desp === dee.desp);
+let copy = JSON.stringify(dee);
+console.log(copy);
+let copyByJSON = JSON.parse(copy);
+//becasue of deep clone these two objects are not the same object
+console.log(copyByJSON.desp === dee.desp);
+//deep copy: JavaScript do not has a deep copy method but we can implement it
+function deepCopy(obj) {
+ if (!obj) return obj;
+ let copyObj = {};
+ for (let key in copyObj) {
+ if (typeof obj[key] !== "object" || Array.isArray(obj[key])) {
+ copyObj[key] = obj[key];
+ } else {
+ copyObj[key] = deepCopy(obj[key]);
+ }
+ }
+ return copyObj;
+}
+let t = { name: "rabo", details: { col: "black" } };
+console.log(deepCopy(t));
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/replaceThreeCenter.js b/elementaryAlgo/JavaScriptCodeChallenge/replaceThreeCenter.js
new file mode 100644
index 0000000..a528842
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/replaceThreeCenter.js
@@ -0,0 +1,24 @@
+const a = [1, 2, 3, 4, 5];
+const b = [4, 0, 0, 0, 8];
+
+const startPositionFor1stArray = a.length / 2 - 1;
+const startPositionFor2ndArray = b.length / 2 - 1;
+//console.log(startPositionFor1stArray, startPositionFor2ndArray);
+console.log(a.splice(startPositionFor1stArray));
+a.splice(
+ startPositionFor1stArray,
+ 3,
+ ...b.slice(startPositionFor2ndArray, startPositionFor2ndArray + 3)
+);
+
+const books = [
+ { name: "Warcross", author: "Marie Lu" },
+ { name: "The Hunger Games", author: "Suzanne Collins" },
+ { name: "Harry Potter", author: "Joanne Rowling" },
+];
+const sortedObj = books.sort((a, b) => {
+ let book1 = a.author.split(" ")[1];
+ let book2 = b.author.split(" ")[1];
+ return book1 < book2 ? 1 : -1;
+});
+console.log(sortedObj);
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/reverseEachWord.js b/elementaryAlgo/JavaScriptCodeChallenge/reverseEachWord.js
new file mode 100644
index 0000000..3f38284
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/reverseEachWord.js
@@ -0,0 +1,6 @@
+const str = "JavaScript is awesome";
+const arrayReverseWords = str
+ .split(" ")
+ .map((word) => word.split("").reverse().join(""))
+ .join(" ");
+console.log(arrayReverseWords);
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/reverseNum.js b/elementaryAlgo/JavaScriptCodeChallenge/reverseNum.js
new file mode 100644
index 0000000..25600ad
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/reverseNum.js
@@ -0,0 +1,4 @@
+let num = 3849;
+
+let numStr = String(num);
++numStr.split("").reverse().join(""); // 9483
\ No newline at end of file
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/threeWaysToLoopStr.js b/elementaryAlgo/JavaScriptCodeChallenge/threeWaysToLoopStr.js
new file mode 100644
index 0000000..1ab295e
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/threeWaysToLoopStr.js
@@ -0,0 +1,37 @@
+let str = "hello world";
+for (let i = 0; i < str.length; i++) {
+ console.log(str.charAt(i));
+}
+for (let word in str) {
+ console.log(str[word]);
+}
+[...str].forEach((word) => console.log(word));
+for (let char of str) {
+ console.log(char);
+}
+
+Math.abs(-5); // 5
+Math.floor(1.6); // 1
+Math.ceil(2.4); // 3
+Math.round(3.8); // 4
+Math.max(-4, 5, 6); // 6
+Math.min(-7, -2, 3); // -7
+Math.sqrt(64); // 8
+Math.pow(5, 3); // 125
+Math.trunc(-6.3); // -6
+const isInt = (value) => {
+ return value % 1 === 0;
+};
+console.log(isInt(1));
+console.log(isInt(-6661));
+console.log(isInt(0));
+console.log(isInt(4.4));
+console.log(isInt(1.6));
+console.log(1 % 1);
+console.log(3 % 1);
+console.log(4 % 10);
+console.log(50.4 % 1);
+const randomNum = (start, end) => {
+ return Math.floor(Math.random() * (end - start)) + start;
+};
+console.log(randomNum(1, 5));
diff --git a/elementaryAlgo/JavaScriptCodeChallenge/waysToCreateObject.js b/elementaryAlgo/JavaScriptCodeChallenge/waysToCreateObject.js
new file mode 100644
index 0000000..8b0d0c4
--- /dev/null
+++ b/elementaryAlgo/JavaScriptCodeChallenge/waysToCreateObject.js
@@ -0,0 +1,111 @@
+let obj = { name: "random", email: "random@example.com" };
+const result = Object.create(obj);
+result.age = 800;
+result.speak = function () {
+ return `My name is ${this.name} and I am ${this.age} years old.`;
+};
+console.log(result);
+console.log(result.name);
+console.log(result.age);
+console.log(result.hasOwnProperty("name"));
+console.log(result.hasOwnProperty("age"));
+console.log(result.hasOwnProperty("speak"));
+console.log(result.speak());
+let protoRabbit = {
+ speak(line) {
+ return `The ${this.type} rabbit says '${line}'`;
+ },
+};
+let killerRabbit = Object.create(protoRabbit);
+killerRabbit.type = "killer";
+console.log(killerRabbit.hasOwnProperty("type"));
+console.log(killerRabbit.speak("SKREEEE!"));
+// → The killer rabbit says 'SKREEEE!
+function factoryFunc(key, value) {
+ return {
+ key,
+ value,
+ };
+}
+let factory = new factoryFunc("age", 78);
+console.log(factory.value);
+console.log(factory.hasOwnProperty("value"));
+function facFunc(key, value) {
+ this[key] = value;
+}
+const fa = new facFunc("name", 800);
+console.log(fa.name);
+class Constr {
+ constructor(name, age = 0) {
+ this.name = name;
+ this.age = age;
+ }
+ getName() {
+ return this.name;
+ }
+}
+const ob = { name: "hello" };
+for (let key in ob) {
+ if (ob.hasOwnProperty(key)) {
+ console.log(key);
+ }
+}
+
+for (let key of Object.keys(ob)) {
+ if (ob.hasOwnProperty(key)) {
+ console.log(key);
+ }
+}
+Object.keys(ob).forEach((key) => {
+ if (ob.hasOwnProperty(key)) {
+ console.log(key);
+ }
+});
+const countKey = (obj) => {
+ let count = 0;
+ Object.keys(obj).forEach((key) => {
+ if (obj.hasOwnProperty(key)) {
+ count += 1;
+ }
+ });
+ return count;
+};
+console.log(countKey(ob));
+console.log(Object.create(obj).toString());
+console.log(Object.create(null));
+let valuePairs = [
+ ["0", 0],
+ ["1", 1],
+ ["2", 2],
+];
+let objPair = Object.fromEntries(valuePairs);
+console.log(objPair);
+let map = new Map([
+ ["age", 80],
+ ["name", "rabo"],
+]);
+let mapPair = Object.fromEntries(map);
+console.log(mapPair);
+for (let [key, value] of map) {
+ console.log(key, value);
+}
+console.log(new Set([8, 9, 0]));
+// let obj1 = {age: 56},
+// obj2 = {col: 'red'};
+// obj1.setPrototypeOf(obj2)
+const obj1 = { a: 1 };
+const obj2 = { b: 2 };
+Object.setPrototypeOf(obj2, obj1);
+//obj2.__proto__ = obj1;
+console.log(obj1.isPrototypeOf(obj2));
+let objWithGetSet = {};
+let o = Object.defineProperty(objWithGetSet, "data", {
+ data: 0,
+ get() {
+ return this.value;
+ },
+ set(value) {
+ this.value = value;
+ },
+});
+o.data = 90;
diff --git a/elementaryAlgo/addTwoNumber.js b/elementaryAlgo/addTwoNumber.js
new file mode 100644
index 0000000..f5bcfd8
--- /dev/null
+++ b/elementaryAlgo/addTwoNumber.js
@@ -0,0 +1,4 @@
+const addTwoNumber = (num1, num2) => {
+ return num1 + num2;
+};
+console.log(addTwoNumber(2, 4));
diff --git a/elementaryAlgo/alvin/alternateCap.js b/elementaryAlgo/alvin/alternateCap.js
new file mode 100644
index 0000000..a9bf474
--- /dev/null
+++ b/elementaryAlgo/alvin/alternateCap.js
@@ -0,0 +1,17 @@
+// Write a function `alternatingCaps` that accepts a sentence string as an argument. The function should
+// return the sentence where words alternate between lowercase and uppercase.
+const alternatingCaps = (words) => {
+ let result = "";
+ let arraySplit = words.split(" ");
+ for (let i = 0; i < arraySplit.length; i++) {
+ let word = arraySplit[i];
+ if (i % 2 === 0) {
+ result += word.toLowerCase() + " ";
+ } else {
+ result += word.toUpperCase() + " ";
+ }
+ }
+ return result;
+};
+console.log(alternatingCaps("take them to school")); // 'take THEM to SCHOOL'
+console.log(alternatingCaps("What did ThEy EAT before?")); // 'what DID they EAT before?'
diff --git a/elementaryAlgo/alvin/bleepVowels.js b/elementaryAlgo/alvin/bleepVowels.js
new file mode 100644
index 0000000..e2c618d
--- /dev/null
+++ b/elementaryAlgo/alvin/bleepVowels.js
@@ -0,0 +1,19 @@
+// Write a function `bleepVowels` that accepts a string as an argument. The function should return
+// a new string where all vowels are replaced with `*`s. Vowels are the letters a, e, i, o, u.
+function bleepVowels(str) {
+ let array = ["a", "e", "i", "o", "u"];
+ let result = "";
+ for (let i = 0; i < str.length; i++) {
+ let char = str[i];
+ if (array.indexOf(char) > -1) {
+ result += "*";
+ } else {
+ result += char;
+ }
+ }
+ return result;
+}
+console.log(bleepVowels("skateboard")); // 'sk*t*b**rd'
+console.log(bleepVowels("slipper")); // 'sl*pp*r'
+console.log(bleepVowels("range")); // 'r*ng*'
+console.log(bleepVowels("brisk morning")); // 'br*sk m*rn*ng'
diff --git a/elementaryAlgo/alvin/chooseDivisible.js b/elementaryAlgo/alvin/chooseDivisible.js
new file mode 100644
index 0000000..fc5b1d5
--- /dev/null
+++ b/elementaryAlgo/alvin/chooseDivisible.js
@@ -0,0 +1,16 @@
+// Write a function `chooseDivisibles(numbers, target)` that accepts an array of numbers and a
+// target number as arguments. The function should return an array containing elements of the original
+// array that are divisible by the target.
+const chooseDivisibles = (numbers, target) => {
+ let result = [];
+ for (let i = 0; i < numbers.length; i++) {
+ let num = numbers[i];
+ if (num % target === 0) {
+ result.push(num);
+ }
+ }
+ return result;
+};
+console.log(chooseDivisibles([40, 7, 22, 20, 24], 4)); // [40, 20, 24]
+console.log(chooseDivisibles([9, 33, 8, 17], 3)); // [9, 33]
+console.log(chooseDivisibles([4, 25, 1000], 10)); // [1000]
diff --git a/elementaryAlgo/alvin/combinations.js b/elementaryAlgo/alvin/combinations.js
new file mode 100644
index 0000000..bf94843
--- /dev/null
+++ b/elementaryAlgo/alvin/combinations.js
@@ -0,0 +1,16 @@
+const combinations = (array) => {
+ if (array.length === 0) return [[]];
+ let firstElem = array[0];
+ let withFirst = array.slice(1);
+ let combinationWithFirstElem = [];
+ let combinationWithoutFirstElem = combinations(withFirst);
+ combinationWithoutFirstElem.forEach((arr) => {
+ let WithFirstElem = [...arr, firstElem];
+ combinationWithFirstElem.push(WithFirstElem);
+ });
+ return [...combinationWithFirstElem, ...combinationWithoutFirstElem];
+};
+console.log(combinations(["a", "b", "c"]));
+console.log(combinations(["a", "b"]));
+//Time : O(2^n)
+//Space : O(n * n)
diff --git a/elementaryAlgo/alvin/commonElement.js b/elementaryAlgo/alvin/commonElement.js
new file mode 100644
index 0000000..9388309
--- /dev/null
+++ b/elementaryAlgo/alvin/commonElement.js
@@ -0,0 +1,21 @@
+// Write a function `commonElements` that accepts two arrays as arguments. The function should return
+// a new array containing the elements that are found in both of the input arrays. The order of
+// the elements in the output array doesn't matter as long as the function returns the correct elements.
+const commonElements = (array1, array2) => {
+ let result = [];
+ let set1 = new Set(array1);
+ let set2 = new Set(array2);
+ for (let elem of set1) {
+ if (set2.has(elem)) {
+ result.push(elem);
+ }
+ }
+ return result;
+};
+let arr1 = ["a", "c", "d", "b"];
+let arr2 = ["b", "a", "y"];
+console.log(commonElements(arr1, arr2)); // ['a', 'b']
+
+let arr3 = [4, 7];
+let arr4 = [32, 7, 1, 4];
+console.log(commonElements(arr3, arr4)); // [4, 7]
diff --git a/elementaryAlgo/alvin/divisors.js b/elementaryAlgo/alvin/divisors.js
new file mode 100644
index 0000000..7ffe447
--- /dev/null
+++ b/elementaryAlgo/alvin/divisors.js
@@ -0,0 +1,15 @@
+// Write a function `divisors` that accepts a number as an argument. The function should return an
+// array containing all positive numbers that can divide into the argument.
+function divisors(num) {
+ let result = [];
+ for (let i = 1; i <= num; i++) {
+ let eachNum = i;
+ if (num % eachNum === 0) {
+ result.push(eachNum);
+ }
+ }
+ return result;
+}
+console.log(divisors(15)); // [1, 3, 5, 15]
+console.log(divisors(7)); // [1, 7]
+console.log(divisors(24)); // [1, 2, 3, 4, 6, 8, 12, 24]
diff --git a/elementaryAlgo/alvin/filterLongWords.js b/elementaryAlgo/alvin/filterLongWords.js
new file mode 100644
index 0000000..99b097a
--- /dev/null
+++ b/elementaryAlgo/alvin/filterLongWords.js
@@ -0,0 +1,17 @@
+// Write a function `filterLongWords` that accepts an array of strings as an argument. The function
+// should return a new array containing only the strings that are less than 5 characters long.
+function filterLongWords(array) {
+ let result = [];
+ for (let i = 0; i < array.length; i++) {
+ let word = array[i];
+ if (word.length < 5) {
+ result.push(word);
+ }
+ }
+ return result;
+}
+console.log(filterLongWords(["kale", "cat", "retro", "axe", "heirloom"]));
+// ['kale', 'cat', 'axe']
+
+console.log(filterLongWords(["disrupt", "pour", "trade", "pic"]));
+// ['pour', 'pic']
diff --git a/elementaryAlgo/alvin/ifelse.js b/elementaryAlgo/alvin/ifelse.js
new file mode 100644
index 0000000..36f7f7a
--- /dev/null
+++ b/elementaryAlgo/alvin/ifelse.js
@@ -0,0 +1,14 @@
+let number = 10;
+if (number > 0) {
+ console.log("Is greater than zero");
+}
+if (number % 10 === 0) {
+ console.log("Is even number");
+} else {
+ console.log("hello");
+}
+
+let str = "now I love you";
+for (let i = str.length - 1; i >= 0; i--) {
+ console.log(str[i]);
+}
diff --git a/elementaryAlgo/alvin/lengthiestWord.js b/elementaryAlgo/alvin/lengthiestWord.js
new file mode 100644
index 0000000..af76bfc
--- /dev/null
+++ b/elementaryAlgo/alvin/lengthiestWord.js
@@ -0,0 +1,18 @@
+// Write a function `lengthiestWord` that accepts a sentence string as an argument. The function should
+// return the longest word of the sentence. If there is a tie, return the word that appears later
+// in the sentence.
+const lengthiestWord = (words) => {
+ let arrayWord = words.split(" ");
+ let lengthiest = arrayWord[0];
+ for (let i = 1; i < arrayWord.length; i++) {
+ let word = arrayWord[i];
+ if (lengthiest.length <= word.length) {
+ lengthiest = word;
+ }
+ }
+ return lengthiest;
+};
+console.log(lengthiestWord("I am pretty hungry")); // 'hungry'
+console.log(lengthiestWord("we should think outside of the box")); // 'outside'
+console.log(lengthiestWord("down the rabbit hole")); // 'rabbit'
+console.log(lengthiestWord("simmer down")); // 'simmer'
diff --git a/elementaryAlgo/alvin/makeAcronyms.js b/elementaryAlgo/alvin/makeAcronyms.js
new file mode 100644
index 0000000..2915a74
--- /dev/null
+++ b/elementaryAlgo/alvin/makeAcronyms.js
@@ -0,0 +1,15 @@
+// Write a function `makeAcronym` that accepts a sentence string as an argument. The function should
+// return a string containing the first character of each word in the sentence.
+const makeAcronym = (words) => {
+ let arrayWord = words.split(" ");
+ let result = "";
+ for (let i = 0; i < arrayWord.length; i++) {
+ let word = arrayWord[i][0];
+ result += word.toUpperCase();
+ }
+ return result;
+};
+console.log(makeAcronym("New York")); // NY
+console.log(makeAcronym("same stuff different day")); // SSDD
+console.log(makeAcronym("Laugh out loud")); // LOL
+console.log(makeAcronym("don't over think stuff")); // DOTS
diff --git a/elementaryAlgo/alvin/makeMatrix.js b/elementaryAlgo/alvin/makeMatrix.js
new file mode 100644
index 0000000..195d208
--- /dev/null
+++ b/elementaryAlgo/alvin/makeMatrix.js
@@ -0,0 +1,37 @@
+// Write a function `makeMatrix(m, n, value)` that accepts three arguments. The function should return
+// a 2-dimensional array of height `m` and width `n` that contains the `value` as every element.
+const makeMatrix = (m, n, value) => {
+ let matrix = [];
+ for (let i = 0; i < m; i++) {
+ let row = [];
+ for (let j = 0; j < n; j++) {
+ row.push(value);
+ }
+ matrix.push(row);
+ }
+ return matrix;
+};
+// const makeMatrix = (m, n, value) => {
+// let matrix = Array.from(Array(m), () => Array(n).fill(value));
+// return matrix
+// };
+console.log(makeMatrix(3, 5, null));
+// [
+// [ null, null, null, null, null ],
+// [ null, null, null, null, null ],
+// [ null, null, null, null, null ]
+// ]
+
+console.log(makeMatrix(4, 2, "x"));
+// [
+// [ 'x', 'x' ],
+// [ 'x', 'x' ],
+// [ 'x', 'x' ],
+// [ 'x', 'x' ]
+// ]
+
+console.log(makeMatrix(2, 2, 0));
+// [
+// [ 0, 0 ],
+// [ 0, 0 ]
+// ]
diff --git a/elementaryAlgo/alvin/maximum.js b/elementaryAlgo/alvin/maximum.js
new file mode 100644
index 0000000..e7052fd
--- /dev/null
+++ b/elementaryAlgo/alvin/maximum.js
@@ -0,0 +1,14 @@
+// Write a function `maximum` that accepts an array of numbers as an argument. The function should
+// return the largest number of the array. If the array is empty, then the function should return null.
+const maximum = (array) => {
+ if (array.length === 0) return null;
+ let max = array[0];
+ for (let i = 1; i < array.length; i++) {
+ let elem = array[i];
+ max = Math.max(max, elem);
+ }
+ return max;
+};
+console.log(maximum([5, 6, 3, 7])); // 7
+console.log(maximum([17, 15, 19, 11, 2])); // 19
+console.log(maximum([])); // null
diff --git a/elementaryAlgo/alvin/nested.js b/elementaryAlgo/alvin/nested.js
new file mode 100644
index 0000000..32f2f95
--- /dev/null
+++ b/elementaryAlgo/alvin/nested.js
@@ -0,0 +1,46 @@
+// snippet 1
+for (let i = 1; i <= 4; i++) {
+ for (let j = 1; j <= 3; j++) {
+ console.log(i, j);
+ }
+}
+
+// snippet 2
+for (let n = 0; n < 2; n++) {
+ console.log("n=" + n);
+ for (let m = 0; m < 5; m++) {
+ console.log(" m=" + m);
+ }
+ console.log("n=" + n);
+}
+
+// snippet 3
+let friends = ["philip", "abby", "phelipe", "simcha"];
+
+for (let i = 0; i < friends.length; i++) {
+ for (let j = 0; j < friends.length; j++) {
+ console.log(friends[i], friends[j]);
+ }
+}
+
+// snippet 4
+let locations = ["flatbush", "williamsburg", "bushwick", "greenpoint"];
+
+for (let i = 0; i < locations.length; i++) {
+ for (let j = i + 1; j < locations.length; j++) {
+ console.log(locations[i], locations[j]);
+ }
+}
+
+// snippet 5
+let colors = ["red", "purple", "orange"];
+
+for (let i = 0; i < colors.length; i++) {
+ let colorStr = colors[i];
+ console.log(colorStr);
+
+ for (let j = 0; j < colorStr.length; j++) {
+ let char = colorStr[j];
+ console.log(char);
+ }
+}
diff --git a/elementaryAlgo/alvin/numOdd.js b/elementaryAlgo/alvin/numOdd.js
new file mode 100644
index 0000000..2b8f9df
--- /dev/null
+++ b/elementaryAlgo/alvin/numOdd.js
@@ -0,0 +1,13 @@
+// Write a function `numOdds` that accepts an array of numbers as an argument. The function should
+// return a number representing the count of odd elements in the array.
+function numOdds(array) {
+ let count = 0;
+ for (let i = 0; i < array.length; i++) {
+ let num = array[i];
+ if (num % 2 === 1) count++;
+ }
+ return count;
+}
+console.log(numOdds([4, 7, 2, 5, 9])); // 3
+console.log(numOdds([11, 31, 58, 99, 21, 60])); // 4
+console.log(numOdds([100, 40, 4])); // 0
diff --git a/elementaryAlgo/alvin/number.js b/elementaryAlgo/alvin/number.js
new file mode 100644
index 0000000..ede2738
--- /dev/null
+++ b/elementaryAlgo/alvin/number.js
@@ -0,0 +1,14 @@
+console.log(2 > 5);
+console.log(100 > 5);
+console.log(5 > 78);
+console.log(45 === 45);
+console.log(3 >= 56);
+console.log(3 <= 57);
+console.log(4 == "4");
+console.log(5 == "5");
+console.log("a" === "a");
+console.log("b" === "bc");
+console.log("c" === "");
+console.log(40 % 10);
+console.log(100 % 10);
+console.log(101 % 10);
diff --git a/elementaryAlgo/alvin/numberRange.js b/elementaryAlgo/alvin/numberRange.js
new file mode 100644
index 0000000..f7850a3
--- /dev/null
+++ b/elementaryAlgo/alvin/numberRange.js
@@ -0,0 +1,13 @@
+// Write a function `numberRange(min, max, step)` that accepts three numbers as arguments, `min`,
+// `max`, and `step`. The function should return all numbers between `min` and `max` at `step` intervals.
+// `min` and `max` are inclusive.
+const numberRange = (min, max, step) => {
+ let result = [];
+ for (let i = min; i <= max; i += step) {
+ result.push(i);
+ }
+ return result;
+};
+console.log(numberRange(10, 40, 5)); // [10, 15, 20, 25, 30, 35, 40]
+console.log(numberRange(14, 24, 3)); // [14, 17, 20, 23]
+console.log(numberRange(8, 35, 6)); // [8, 14, 20, 26, 32]
diff --git a/elementaryAlgo/alvin/pairPrint.js b/elementaryAlgo/alvin/pairPrint.js
new file mode 100644
index 0000000..96f9ead
--- /dev/null
+++ b/elementaryAlgo/alvin/pairPrint.js
@@ -0,0 +1,25 @@
+function pairPrint(arr) {
+ for (let i = 0; i < arr.length; i++) {
+ for (let j = i + 1; j < arr.length; j++) {
+ console.log(arr[i], arr[j]);
+ }
+ }
+}
+// Write a function `pairPrint` that accepts an array as an argument. The function should print
+// all unique pairs of elements in the array. The function doesn't need to return any value. It
+// should just print to the terminal.
+
+pairPrint(["artichoke", "broccoli", "carrot", "daikon"]);
+// prints
+// artichoke - broccoli
+// artichoke - carrot
+// artichoke - daikon
+// broccoli - carrot
+// broccoli - daikon
+// carrot - daikon
+
+//pairPrint(["apple", "banana", "clementine"]);
+// prints
+// apple - banana
+// apple - clementine
+// banana - clementine
diff --git a/elementaryAlgo/alvin/permutations.js b/elementaryAlgo/alvin/permutations.js
new file mode 100644
index 0000000..a218ff3
--- /dev/null
+++ b/elementaryAlgo/alvin/permutations.js
@@ -0,0 +1,22 @@
+const permutations = (array) => {
+ if (array.length === 0) return [[]];
+ let firstElem = array[0];
+ let rest = array.slice(1);
+ let permutationsWithoutFirst = permutations(rest);
+ let allPermutation = [];
+ permutationsWithoutFirst.forEach((perm) => {
+ //inserting firstElem elements in all possible positions
+ for (let i = 0; i <= perm.length; i++) {
+ let permutationWithFirstElem = [
+ ...perm.slice(0, i),
+ firstElem,
+ ...perm.slice(i),
+ ];
+ allPermutation.push(permutationWithFirstElem);
+ }
+ });
+ return allPermutation;
+};
+console.log(permutations(["a", "b", "c"]));
+//Time: O(n!)
+//Space: O(n^2)
diff --git a/elementaryAlgo/alvin/print2d.js b/elementaryAlgo/alvin/print2d.js
new file mode 100644
index 0000000..43e2492
--- /dev/null
+++ b/elementaryAlgo/alvin/print2d.js
@@ -0,0 +1,36 @@
+// Write a function `print2d` that accepts a two-dimensional array as an argument. The function
+// should print all inner elements of the array.
+const print2d = (array) => {
+ for (let i = 0; i < array.length; i++) {
+ let innerElem = array[i];
+ for (let j = 0; j < innerElem.length; j++) {
+ console.log(innerElem[j]);
+ }
+ }
+};
+let array1 = [
+ ["a", "b", "c", "d"],
+ ["e", "f"],
+ ["g", "h", "i"],
+];
+print2d(array1);
+// prints
+// a
+// b
+// c
+// d
+// e
+// f
+// g
+// h
+// i
+
+let array2 = [[9, 3, 4], [11], [42, 100]];
+print2d(array2);
+// prints
+// 9
+// 3
+// 4
+// 11
+// 42
+// 100
diff --git a/elementaryAlgo/alvin/printCombination.js b/elementaryAlgo/alvin/printCombination.js
new file mode 100644
index 0000000..32505de
--- /dev/null
+++ b/elementaryAlgo/alvin/printCombination.js
@@ -0,0 +1,32 @@
+// Write a function `printCombinations`that accepts two arrays as arguments. The function should
+// print all combinations of the elements generated by taking an element from the first array and
+// and an element from the second array. The function doesn't need to return any value. It
+// should just print to the terminal.
+function printCombinations(array1, array2) {
+ for (let i = 0; i < array1.length; i++) {
+ const element1 = array1[i];
+ for (let j = 0; j < array2.length; j++) {
+ let element2 = array2[j];
+ console.log(element1, element2);
+ }
+ }
+}
+
+let colors = ["gray", "cream", "cyan"];
+let clothes = ["shirt", "flannel"];
+
+printCombinations(colors, clothes);
+// prints
+// gray shirt
+// gray flannel
+// cream shirt
+// cream flannel
+// cyan shirt
+// cyan flannel
+
+//printCombinations(["hot", "cold"], ["soup", "tea"]);
+// prints
+// hot soup
+// hot tea
+// cold soup
+// cold tea
diff --git a/elementaryAlgo/alvin/recursionArray.js b/elementaryAlgo/alvin/recursionArray.js
new file mode 100644
index 0000000..26273b9
--- /dev/null
+++ b/elementaryAlgo/alvin/recursionArray.js
@@ -0,0 +1,20 @@
+//Given an array of integers, write a function that return the sum all of it element using recursion
+const sum = (array) => {
+ if (array.length === 0) return 0;
+ let rest = array.slice(1);
+ return array[0] + sum(rest);
+};
+console.log(sum([2, 5, 6, 8, 9]));
+//Time: O(n^2)
+//Space: O(n)
+// can improve our space complexity like this
+const sumImprove = (array) => {
+ return _sum(array, 0);
+};
+const _sum = (array, idx) => {
+ if (array.length === idx) return 0;
+ return array[idx] + _sum(array, idx + 1);
+};
+console.log(sumImprove([2, 5, 6, 8, 9]));
+//Time: O(n)
+//Space: O(n)
diff --git a/elementaryAlgo/alvin/removeFirstVowel.js b/elementaryAlgo/alvin/removeFirstVowel.js
new file mode 100644
index 0000000..e10a3fc
--- /dev/null
+++ b/elementaryAlgo/alvin/removeFirstVowel.js
@@ -0,0 +1,18 @@
+// Write a function `removeFirstVowel` that accepts a string as an argument. The function should return
+// the string with it's first vowel removed.
+const removeFirstVowel = (words) => {
+ let vowels = ["a", "e", "i", "o", "u"];
+ for (let i = 0; i < words.length; i++) {
+ let word = words[i];
+ if (vowels.includes(word)) {
+ let copy = words.split("");
+ copy.splice(i, 1);
+ return copy.join("");
+ }
+ }
+ return words;
+};
+console.log(removeFirstVowel("volcano")); // 'vlcano'
+console.log(removeFirstVowel("celery")); // 'clery'
+console.log(removeFirstVowel("juice")); // 'jice'
+console.log(removeFirstVowel("ghshsh"));
diff --git a/elementaryAlgo/alvin/removeShortWords.js b/elementaryAlgo/alvin/removeShortWords.js
new file mode 100644
index 0000000..1218a0d
--- /dev/null
+++ b/elementaryAlgo/alvin/removeShortWords.js
@@ -0,0 +1,15 @@
+// Write a function `removeShortWords` that accepts a sentence string as an argument. The function
+// should return a new sentence where all of the words shorter than 4 characters are removed.
+const removeShortWords = (words) => {
+ let result = "";
+ let arrayWords = words.split(" ");
+ for (let i = 0; i < arrayWords.length; i++) {
+ let word = arrayWords[i];
+ if (word.length < 4) continue;
+ else result += word + " ";
+ }
+ return result;
+};
+console.log(removeShortWords("knock on the door will you")); // 'knock door will'
+console.log(removeShortWords("a terrible plan")); // 'terrible plan'
+console.log(removeShortWords("run faster that way")); // 'faster that'
diff --git a/elementaryAlgo/alvin/reverseArray.js b/elementaryAlgo/alvin/reverseArray.js
new file mode 100644
index 0000000..9cb3311
--- /dev/null
+++ b/elementaryAlgo/alvin/reverseArray.js
@@ -0,0 +1,12 @@
+// Write a function `reverseArray` that accepts an array as an argument. The function should return a
+// array containing the elements of the original array in reverse order.
+const reverseArray = (array) => {
+ let result = [];
+ for (let i = array.length - 1; i >= 0; i--) {
+ let element = array[i];
+ result.push(element);
+ }
+ return result;
+};
+console.log(reverseArray(["zero", "one", "two", "three"])); // ['three', 'two', 'one', 'zero']
+console.log(reverseArray([7, 1, 8])); // [8, 1, 7]
diff --git a/elementaryAlgo/alvin/smallestNum.js b/elementaryAlgo/alvin/smallestNum.js
new file mode 100644
index 0000000..f3de8e4
--- /dev/null
+++ b/elementaryAlgo/alvin/smallestNum.js
@@ -0,0 +1,12 @@
+const smallNum = (nums) => {
+ if (nums.length === 0) return null;
+ let smallest = nums[0];
+ for (let i = 1; i < nums.length; i++) {
+ let num = nums[i];
+ smallest = Math.min(num, smallest);
+ }
+ return smallest;
+};
+console.log(smallNum([3, 5, 8, 1, 9]));
+console.log(smallNum([]));
+console.log(smallNum([3, 5, 2, 4]));
diff --git a/elementaryAlgo/alvin/stayPositive.js b/elementaryAlgo/alvin/stayPositive.js
new file mode 100644
index 0000000..e3411c6
--- /dev/null
+++ b/elementaryAlgo/alvin/stayPositive.js
@@ -0,0 +1,15 @@
+// Write a function `stayPositive` that accepts an array of numbers as an argument. The function should
+// return an array containing only the positive numbers.
+function stayPositive(array) {
+ let result = [];
+ for (let i = 0; i < array.length; i++) {
+ let num = array[i];
+ if (num > 0) {
+ result.push(num);
+ }
+ }
+ return result;
+}
+console.log(stayPositive([10, -4, 3, 6])); // [10, 3, 6]
+console.log(stayPositive([-5, 11, -40, 30.3, -2])); // [11, 30.3]
+console.log(stayPositive([-11, -30])); // []
diff --git a/elementaryAlgo/alvin/string.js b/elementaryAlgo/alvin/string.js
new file mode 100644
index 0000000..957a6a6
--- /dev/null
+++ b/elementaryAlgo/alvin/string.js
@@ -0,0 +1,58 @@
+// console.log("promenade"[3]);
+// console.log("tiger"[1]);
+// console.log("wheel".length);
+// console.log("wheel".length - 1);
+// console.log("noMAD".toUpperCase());
+// console.log("hey programmers"[2] === "y");
+
+// console.log("volleyball".length > 20);
+// console.log("treasure".indexOf("r"));
+// console.log("treasure".indexOf("e"));
+// console.log("web"[5]);
+// console.log("red".indexOf("x"));
+// console.log("red".indexOf("R"));
+// let str = "hello programmers";
+// console.log(str.indexOf("help") > -1);
+// console.log(str.indexOf("pro") > -1);
+// let word = "suspension bridge";
+// console.log(word[4]);
+// console.log(word.length > 4 && word[0]);
+// console.log(word.length > 5 && word[0] === "d");
+// console.log(word.length > 5 && word[0] === "s");
+// console.log(word.indexOf("o") > -1);
+// console.log(word.indexOf("z") > -1);
+
+// let str = "foggy";
+// console.log(str[2 + 1]);
+// console.log(str[str.length - 1]);
+// str = " day";
+// console.log(str);
+// console.log(str.length);
+// console.log(str.indexOf("ogg"));
+let phrase = "that's all folks";
+console.log(phrase[phrase.length]);
+console.log(phrase[phrase.length - 1]);
+console.log(phrase[phrase.length - 2]);
+
+const i = 9;
+const char = phrase[i];
+console.log(char);
+console.log(phrase.indexOf(char));
+console.log(phrase.slice(2, 8));
+
+console.log("abcdefg".slice(1, 3));
+console.log("abcdefg".slice(2));
+console.log("abcdefg".slice(4));
+console.log("abcdefg".slice(2, -1));
+console.log("abcdefg".slice(2, -2));
+let string = `MIICWwIBAAKBgGEdLjFEFbegPZ2AwJWkalksXr7PzWL7wIc7pOFZxXwYPWt
+QxvANyceCwpkqbPLsfEx7nqxAris2hYOdeN1OTFqvTyNmVuzbUPcXShn6ZoDCB30voHkeu4F3cUw5
+RQEUDdLscSnv4HMxHam5qgl6vXoumVNHbjyKA5UtAnfjAgMBAAECgYAmjEyvpZTxRJvwjxDi1VaZevF
+I0Hd4WPH9PAGgqdnH84vGXnAGFj1WikqKYcqKMQW2kdjAsWwH9D9FfrkIcDDHdZ9XuGSGkFzWtOwajWMQl7
+qNV1hZ288gdpIQQMOTLDgauZY6pw1cV7h4v316qJB8knQGoBNpJCfTYQJBAKV1ctsJq0Zg4QumD2hyODepP3L
+fLeaQsERLqVAWeuOuTY5mK5gIwsSqvcSVfY7Ze1FWIsApNFRv67azKcJPwsCQQCNlyApZFJEVNY70Er7Uu5NL9t4C
+YJJC9uVVkoEHEY6d7sVslqa0vP2q0zXx9YedbMBvQjxXIbY0waXUy63FvoBGJAkB3OTJWUjVgzDY1Br5wu2Yu59NjKVKLW
+zCsu1gaCNBfhVDX7SyIyC9EYKRfUAoQxwsmPWPyQ9QVG4WKcPZJAkBRheAotPCBE2RLHHfvpiStnMhX0UXdVyaJp5tcZ6wYV61oh
+yBvCOkYhUxBJzeIGrVZcvLZSLeUzXoqRPpxQxAkEAkdCZXF0gHahpZgF5y0wWcqf9ECRT1E4Hv8bk3Mf0Exp2aW34JeI6I7Xqd1NV4I
+9H7prQ8m3y39lFwWO8PmQ`;
+console.log(string.indexOf("HEY"));
diff --git a/elementaryAlgo/alvin/stringToLength.js b/elementaryAlgo/alvin/stringToLength.js
new file mode 100644
index 0000000..70cf054
--- /dev/null
+++ b/elementaryAlgo/alvin/stringToLength.js
@@ -0,0 +1,15 @@
+// Write a function `stringsToLengths` that accepts an array of strings as an argument. The function
+// should return a new array containing the lengths of the elements of the original array.
+function stringsToLengths(array) {
+ let result = [];
+ for (let i = 0; i < array.length; i++) {
+ let word = array[i];
+ result.push(word.length);
+ }
+ return result;
+}
+console.log(stringsToLengths(["belly", "echo", "irony", "pickled"]));
+// [5, 4, 5, 7]
+
+console.log(stringsToLengths(["on", "off", "handmade"]));
+// [2, 3, 8]
diff --git a/elementaryAlgo/alvin/total.js b/elementaryAlgo/alvin/total.js
new file mode 100644
index 0000000..1030568
--- /dev/null
+++ b/elementaryAlgo/alvin/total.js
@@ -0,0 +1,22 @@
+// Write a function `total` that accepts an array of numbers as an argument. The function should return
+// the total sum of all elements of the array.
+
+function total(array) {
+ let sum = 0;
+ for (let i = 0; i < array.length; i++) {
+ sum += array[i];
+ }
+ return sum;
+}
+console.log(total([3, 2, 8])); // 13
+console.log(total([-5, 7, 4, 6])); // 12
+console.log(total([7])); // 7
+console.log(total([])); // 0
+
+let obj = {
+ name: "right",
+ number: 3,
+};
+
+if (key in obj) {
+}
diff --git a/elementaryAlgo/alvin/totalProducts.js b/elementaryAlgo/alvin/totalProducts.js
new file mode 100644
index 0000000..d9f25eb
--- /dev/null
+++ b/elementaryAlgo/alvin/totalProducts.js
@@ -0,0 +1,24 @@
+// Write a function `totalProduct(array)` that accepts a 2D array of numbers. The function should return
+// the total product of all numbers in the array.
+const totalProduct = (array) => {
+ let totalProduct = 1;
+ for (let i = 0; i < array.length; i++) {
+ let product = array[i];
+ for (let j = 0; j < product.length; j++) {
+ totalProduct *= product[j];
+ }
+ }
+ return totalProduct;
+};
+let array1 = [
+ [3, 5, 2],
+ [6, 2],
+];
+console.log(totalProduct(array1)); // 360
+
+let array2 = [
+ [4, 6],
+ [2, 3],
+ [1, 2],
+];
+console.log(totalProduct(array2)); // 288
diff --git a/elementaryAlgo/alvin/twoSum.js b/elementaryAlgo/alvin/twoSum.js
new file mode 100644
index 0000000..c8dc9e8
--- /dev/null
+++ b/elementaryAlgo/alvin/twoSum.js
@@ -0,0 +1,15 @@
+// Write a function `twoSum(numbers, target)` that accepts an array of numbers and a target number
+// as an argument. The function should return a boolean indicating whether or not there exists a pair
+// of distinct elements in the array that sum to the target.
+function twoSum(numbers, target) {
+ for (let i = 0; i < numbers.length; i++) {
+ for (let j = i + 1; j < numbers.length; j++) {
+ if (numbers[i] + numbers[j] === target) return true;
+ }
+ }
+ return false;
+}
+console.log(twoSum([2, 3, 5, 9], 7)); // true
+console.log(twoSum([2, 3, 5, 9], 4)); // false
+console.log(twoSum([6, 3, 4], 10)); // true
+console.log(twoSum([6, 5, 1], 10)); // false
diff --git a/elementaryAlgo/alvin/twoSumPairs.js b/elementaryAlgo/alvin/twoSumPairs.js
new file mode 100644
index 0000000..653a20e
--- /dev/null
+++ b/elementaryAlgo/alvin/twoSumPairs.js
@@ -0,0 +1,18 @@
+// Write a function `twoSumPairs(numbers, target)` that accepts an array of numbers and a target number
+// as arguments. The function should return a 2D array containing all unique pairs of elements that
+// sum to the target.
+const twoSumPairs = (numbers, target) => {
+ let result = [];
+ for (let i = 0; i < numbers.length; i++) {
+ for (let j = i + 1; j < numbers.length; j++) {
+ if (numbers[i] + numbers[j] === target) {
+ result.push([numbers[i], numbers[j]]);
+ }
+ }
+ }
+ return result;
+};
+console.log(twoSumPairs([2, 3, 4, 6, 5], 8)); // [ [2, 6], [3, 5] ]
+console.log(twoSumPairs([10, 7, 4, 5, 2], 12)); // [ [10, 2], [7, 5] ]
+console.log(twoSumPairs([3, 9, 8], 11)); // [ [3, 8] ]
+console.log(twoSumPairs([3, 9, 8], 10)); // [ ]
diff --git a/elementaryAlgo/alvin/wordCount.js b/elementaryAlgo/alvin/wordCount.js
new file mode 100644
index 0000000..244fd05
--- /dev/null
+++ b/elementaryAlgo/alvin/wordCount.js
@@ -0,0 +1,15 @@
+// Write a function `wordCount(sentence, targetWords)` that accepts a sentence string and an array of
+// `targetWords`. The function should return a count of the number of words of the sentence that are
+// in `targetWords`.
+const wordCount = (sentence, targetWords) => {
+ let count = 0;
+ for (let i = 0; i < targetWords.length; i++) {
+ if (sentence.indexOf(targetWords[i]) > -1) {
+ count += 1;
+ }
+ }
+ return count;
+};
+console.log(wordCount("open the window please", ["please", "open", "sorry"])); // 2
+console.log(wordCount("drive to the cinema", ["the", "driver"])); // 1
+console.log(wordCount("can I have that can", ["can", "I"])); // 3
diff --git a/elementaryAlgo/alvin/yourAverageFunc.js b/elementaryAlgo/alvin/yourAverageFunc.js
new file mode 100644
index 0000000..cc4e6e3
--- /dev/null
+++ b/elementaryAlgo/alvin/yourAverageFunc.js
@@ -0,0 +1,16 @@
+// Write a function `yourAverageFunction` that accepts an array of numbers as an argument. The
+// function should return the average of all elements of the array. If the input array is empty,
+// then the function should return null.
+const yourAverageFunction = (array) => {
+ if (array.length === 0) return null;
+ let sum = 0;
+ for (let i = 0; i < array.length; i++) {
+ let num = array[i];
+ sum += num;
+ }
+ return sum / array.length;
+};
+console.log(yourAverageFunction([5, 2, 7, 24])); // 9.5
+console.log(yourAverageFunction([100, 6])); // 53
+console.log(yourAverageFunction([31, 32, 40, 12, 33])); // 29.6
+console.log(yourAverageFunction([])); // null
diff --git a/elementaryAlgo/alvin/zipper.js b/elementaryAlgo/alvin/zipper.js
new file mode 100644
index 0000000..3537a23
--- /dev/null
+++ b/elementaryAlgo/alvin/zipper.js
@@ -0,0 +1,41 @@
+// Write a function `zipper` that accepts two arrays as arguments. The function should return a 2D
+// array containing pairs of elements at the same indices. You can assume that the arrays have the
+// same length.
+const zipper = (array1, array2) => {
+ let result = [];
+ for (let i = 0; i < array1.length; i++) {
+ let elem1 = array1[i];
+ let elem2 = array2[i];
+ result.push([elem1, elem2]);
+ }
+ return result;
+};
+// const zipper = (array1, array2) => {
+// let result = []
+// for (let i = 0; i < array1.length; i++) {
+// for (let j = 0; j < array2.length; j++) {
+// if(i === j){
+// result.push([array1[i], array2[j]])
+// }
+// }
+// }
+// return result
+// };
+let array1 = ["a", "b", "c", "d"];
+let array2 = [-1, -2, -3, -4];
+console.log(zipper(array1, array2));
+// [
+// ['a', -1],
+// ['b', -2],
+// ['c', -3],
+// ['d', -4],
+// ]
+
+let array3 = ["whisper", "talk", "shout"];
+let array4 = ["quiet", "normal", "loud"];
+console.log(zipper(array3, array4));
+// [
+// ['whisper', 'quiet'],
+// ['talk', 'normal'],
+// ['shout', 'loud'],
+// ]
diff --git a/elementaryAlgo/areaOfTriangle.js b/elementaryAlgo/areaOfTriangle.js
new file mode 100644
index 0000000..2b6682e
--- /dev/null
+++ b/elementaryAlgo/areaOfTriangle.js
@@ -0,0 +1,16 @@
+//Example 1: Area When Base and Height is Known
+const areaBaseHeight = (base, height) => {
+ let area = (base * height) / 2;
+ return area;
+};
+console.log(areaBaseHeight(2, 3));
+console.log(areaBaseHeight(3, 6));
+//Example 2: Area When All Sides are Known
+//s = (a+b+c)/2
+//area = √(s(s-a)*(s-b)*(s-c))
+const areaAllSidesKnown = (side1, side2, side3) => {
+ let s = (side1 * side2 * side3) / 2;
+ let area = Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
+ return area;
+};
+console.log(areaAllSidesKnown(2, 3, 6));
diff --git a/elementaryAlgo/calculator.js b/elementaryAlgo/calculator.js
new file mode 100644
index 0000000..c0748d5
--- /dev/null
+++ b/elementaryAlgo/calculator.js
@@ -0,0 +1,33 @@
+//simple calculation with if else statements
+const calculatorWithIfElse = (operator, num1, num2) => {
+ let result;
+ if (operator === "+") {
+ result = num1 + num2;
+ } else if (operator === "-") {
+ result = num1 - num2;
+ } else if (operator === "*") {
+ result = num1 * num2;
+ } else {
+ result = num1 / num2;
+ }
+ return result;
+};
+console.log(calculatorWithIfElse("*", 10, 10));
+const calculatorWithSwitch = (operator, num1, num2) => {
+ switch (operator) {
+ case "+":
+ result = num1 + num2;
+ break;
+ case "-":
+ result = num1 - num2;
+ break;
+ case "*":
+ result = num1 * num2;
+ break;
+ case "/":
+ result = num1 / num2;
+ break;
+ }
+ return result;
+};
+console.log(calculatorWithSwitch("+", 10, 10));
diff --git a/elementaryAlgo/countCharacters.js b/elementaryAlgo/countCharacters.js
new file mode 100644
index 0000000..f42eaab
--- /dev/null
+++ b/elementaryAlgo/countCharacters.js
@@ -0,0 +1,11 @@
+const countCharacters = (str, letter) => {
+ let count = 0;
+ for (let i = 0; i < str.length; i++) {
+ //console.log(str[i]);
+ if (str.charAt(i) === letter) {
+ count++;
+ }
+ }
+ return count;
+};
+console.log(countCharacters("hello world", "h"));
diff --git a/elementaryAlgo/generateRandomString.js b/elementaryAlgo/generateRandomString.js
new file mode 100644
index 0000000..0417df7
--- /dev/null
+++ b/elementaryAlgo/generateRandomString.js
@@ -0,0 +1,17 @@
+//Example 1: Generate Random Strings
+const generateRandomString = (len) => {
+ let word = "";
+ const characters =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+ for (let i = 0; i < len; i++) {
+ word += characters.charAt(Math.floor(Math.random() * characters.length));
+ }
+ return word;
+};
+console.log(generateRandomString(7));
+//Example 2: Generate Random Strings Using Built-in Methods
+const generateRandomStr = () => {
+ return Math.random().toString(36).substring(2, 7);
+};
+console.log(generateRandomStr());
+console.log(String(36));
diff --git a/elementaryAlgo/highCommonFactor.js b/elementaryAlgo/highCommonFactor.js
new file mode 100644
index 0000000..a8e1640
--- /dev/null
+++ b/elementaryAlgo/highCommonFactor.js
@@ -0,0 +1,24 @@
+//Example 1: Find HCF using for Loop
+const highCommonFactor = (num1, num2) => {
+ let hcf;
+ for (let i = 1; i < num1 && i < num2; i++) {
+ if (num1 % i === 0 && num2 % i === 0) {
+ hcf = i;
+ }
+ }
+ return hcf;
+};
+console.log(highCommonFactor(60, 20));
+//Example 2: HCF using while Loop and if...else
+const highCommonFactorWhile = (num1, num2) => {
+ let result;
+ while (num1 !== num2) {
+ if (num1 > num2) {
+ result = num1 -= num2;
+ } else {
+ result = num2 -= num1;
+ }
+ }
+ return result;
+};
+console.log(highCommonFactorWhile(1, 8));
diff --git a/elementaryAlgo/isLastDigitSame.js b/elementaryAlgo/isLastDigitSame.js
new file mode 100644
index 0000000..53c6eba
--- /dev/null
+++ b/elementaryAlgo/isLastDigitSame.js
@@ -0,0 +1,12 @@
+const isLastDigitSame = (num1, num2, num3) => {
+ const mod1 = num1 % 10;
+ const mod2 = num2 % 10;
+ const mod3 = num3 % 10;
+ if (mod1 === mod2 && mod2 === mod3) {
+ return true;
+ }
+ return false;
+};
+console.log(isLastDigitSame(33, 33, 53));
+console.log(isLastDigitSame(33, 33, 53));
+console.log(isLastDigitSame(33, 32, 53));
diff --git a/elementaryAlgo/lowestCommonMultiple.js b/elementaryAlgo/lowestCommonMultiple.js
new file mode 100644
index 0000000..1a3ee47
--- /dev/null
+++ b/elementaryAlgo/lowestCommonMultiple.js
@@ -0,0 +1,13 @@
+//Example 2: LCM Calculation Using HCF
+const lowestCommonMultiple = (num1, num2) => {
+ let hcf;
+ for (let i = 1; i <= num1 && i <= num2; i++) {
+ if (num1 % i === 0 && num2 % i === 0) {
+ hcf = i;
+ }
+ }
+ let lcm = (num1 * num2) / 2;
+ return lcm;
+};
+console.log(lowestCommonMultiple(30, 60));
+console.log(lowestCommonMultiple(6, 8));
diff --git a/elementaryAlgo/multiplicationTable.js b/elementaryAlgo/multiplicationTable.js
new file mode 100644
index 0000000..6435663
--- /dev/null
+++ b/elementaryAlgo/multiplicationTable.js
@@ -0,0 +1,10 @@
+//Example 1: Multiplication Table Up to 10
+const multiplicationTable = (num) => {
+ let multiples = [];
+ for (let i = 1; i <= 10; i++) {
+ multiples.push(i * num);
+ }
+ return multiples;
+};
+console.log(multiplicationTable(10));
+console.log(multiplicationTable(1));
diff --git a/elementaryAlgo/printHelloWorld.js b/elementaryAlgo/printHelloWorld.js
new file mode 100644
index 0000000..0e9d395
--- /dev/null
+++ b/elementaryAlgo/printHelloWorld.js
@@ -0,0 +1,5 @@
+// A "Hello, World!" is a simple program that prints Hello, World! on the screen.
+// Since it's a very simple program, this program is often used to introduce a
+// new programming language to beginners.
+const helloWorld = () => "hello world";
+console.log(helloWorld());
diff --git a/elementaryAlgo/raboAlgo/binarySearch.js b/elementaryAlgo/raboAlgo/binarySearch.js
new file mode 100644
index 0000000..0566add
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/binarySearch.js
@@ -0,0 +1,36 @@
+const binarySearch = (array, num) => {
+ let start = 0;
+ let end = array.length - 1;
+ while (start < end) {
+ let mid = Math.floor((end + start) / 2);
+ let middleElem = array[mid];
+ if (num === middleElem) return true;
+ else if (num < middleElem) {
+ end = mid;
+ } else {
+ start = mid + 1;
+ }
+ }
+ return false;
+};
+console.log(binarySearch([2, 4, 6, 7, 9, 0], 10));
+console.log(binarySearch([2, 4, 6, 7, 9, 0], 2));
+console.log(binarySearch([2, 4, 6, 7, 9, 0], 7));
+function binarySearchTwo(array, num) {
+ let start = 0;
+ let end = array.length - 1;
+ do {
+ let mid = Math.floor((end + start) / 2);
+ let middleElem = array[mid];
+ if (num === middleElem) return true;
+ else if (num < middleElem) {
+ end = mid;
+ } else {
+ start = mid + 1;
+ }
+ } while (start < end);
+ return false;
+}
+console.log(binarySearchTwo([2, 4, 6, 7, 9, 0], 10));
+console.log(binarySearchTwo([2, 4, 6, 7, 9, 0], 2));
+console.log(binarySearchTwo([2, 4, 6, 7, 9, 0], 7));
diff --git a/elementaryAlgo/raboAlgo/binaryTreeProblems.js b/elementaryAlgo/raboAlgo/binaryTreeProblems.js
new file mode 100644
index 0000000..83d6309
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/binaryTreeProblems.js
@@ -0,0 +1,182 @@
+class Node {
+ constructor(value) {
+ this.value = value;
+ this.right = null;
+ this.left = null;
+ }
+}
+const a = new Node("A");
+const b = new Node("B");
+const c = new Node("C");
+const d = new Node("D");
+const e = new Node("E");
+const f = new Node("F");
+a.right = b;
+a.left = c;
+b.right = d;
+b.left = e;
+c.right = f;
+console.log(a);
+
+//printDepthFirst iterative
+const printDepthFirst = (root) => {
+ if (root === null) return [];
+ let result = [];
+ let stack = [root];
+ while (stack.length > 0) {
+ let element = stack.pop();
+ result.push(element.value);
+ if (element.left) stack.push(element.left);
+ if (element.right) stack.push(element.right);
+ }
+ return result;
+};
+console.log(printDepthFirst(a));
+
+//printDepthRecursive
+const printDepthFirstRecursive = (root) => {
+ if (root === null) return [];
+ const leftValue = printDepthFirstRecursive(root.left);
+ let rightValue = printDepthFirstRecursive(root.right);
+ return [root.value, ...rightValue, ...leftValue];
+};
+console.log(printDepthFirstRecursive(a));
+
+//printBreadthFirst iterative
+const printBreadthFirst = (root) => {
+ let result = [];
+ if (root === null) return [];
+ let queue = [root];
+ while (queue.length > 0) {
+ let element = queue.shift();
+ result.push(element.value);
+ if (element.right) queue.push(element.right);
+ if (element.left) queue.push(element.left);
+ }
+ return result;
+};
+console.log(printBreadthFirst(a));
+
+//tree Includes Recursive
+const treeIncludesRecursive = (root, target) => {
+ if (root === null) return false;
+ if (root.value === target) return true;
+ let left = treeIncludesRecursive(root.left, target);
+ let right = treeIncludesRecursive(root.right, target);
+ return left === true || right === true ? true : false;
+};
+console.log(treeIncludesRecursive(a, "A"));
+//tree includes iterative
+const treeIncludes = (root, target) => {
+ if (root === null) return false;
+ let stack = [root];
+ while (stack.length > 0) {
+ let element = stack.pop();
+ if (element.value === target) return true;
+ if (element.left) stack.push(element.left);
+ if (element.right) stack.push(element.right);
+ }
+ return false;
+};
+console.log(treeIncludes(a, "A"));
+console.log(treeIncludes(b, "B"));
+console.log(treeIncludes(c, "C"));
+console.log(treeIncludes("", "D"));
+console.log(treeIncludes(null, "E"));
+console.log(treeIncludes(a, "T"));
+
+const one = new Node(1);
+const two = new Node(2);
+const three = new Node(3);
+const four = new Node(4);
+const five = new Node(5);
+const six = new Node(6);
+one.right = two;
+one.left = three;
+two.right = four;
+two.left = five;
+three.right = six;
+//tree sum recursively
+const treeSumRecursive = (root) => {
+ if (root === null) return 0;
+ let rightSum = treeSumRecursive(root.right);
+ let leftSum = treeSumRecursive(root.left);
+ return root.value + rightSum + leftSum;
+};
+console.log(treeSumRecursive(one));
+//tree sum iteratively using breadth-first
+const treeSum = (root) => {
+ let sum = 0;
+ if (root === null) return 0;
+ let queue = [root];
+ while (queue.length > 0) {
+ let element = queue.shift();
+ sum += element.value;
+ if (element.left) stack.push(element.left);
+ if (element.right) stack.push(element.right);
+ }
+ return sum;
+};
+console.log(treeSumRecursive(one));
+
+//minimum value recursion
+const treeMinValueRecursive = (root) => {
+ if (root === null) return Infinity;
+ let rootValue = root.value;
+ let leftValue = treeMinValueRecursive(root.left);
+ let rightValue = treeMinValueRecursive(root.right);
+ return Math.min(rootValue, leftValue, rightValue);
+};
+console.log(treeMinValueRecursive(one));
+
+//minimum value iterative
+const treeMinValueIterative = (root) => {
+ let min = Infinity;
+ if (root === null) return Infinity;
+ let queue = [root];
+ while (queue.length > 0) {
+ let element = queue.shift();
+ min = Math.min(min, element.value);
+ if (element.right) queue.push(element.right);
+ if (element.left) queue.push(element.left);
+ }
+ return min;
+};
+console.log(treeMinValueIterative(one));
+
+//tree max value Iterative
+const treeMaxValueIterative = (root) => {
+ let max = -Infinity;
+ if (root === null) return -Infinity;
+
+ let queue = [root];
+ while (queue.length > 0) {
+ let element = queue.shift();
+ max = Math.max(max, element.value);
+ if (element.right) queue.push(element.right);
+ if (element.left) queue.push(element.left);
+ }
+ return max;
+};
+console.log(treeMaxValueIterative(one));
+console.log(treeMaxValueIterative(null));
+//tree max value recursively
+const treeMaxValueRecursive = (root) => {
+ let max = -Infinity;
+ if (root === null) return -Infinity;
+ let rootValue = root.value;
+ max = Math.max(max, rootValue);
+ let leftValue = treeMaxValueRecursive(root.left);
+ let rightValue = treeMaxValueRecursive(root.right);
+ return Math.max(max, rightValue, leftValue);
+};
+console.log(treeMaxValueRecursive(one));
+
+//max path tree problem
+const maxPath = (root) => {
+ if (root === null) return -Infinity;
+ if (root.left === null && root.right === null) return root.value;
+ let maxLeftOrRight = Math.max(maxPath(root.left), maxPath(root.right));
+ return root.value + maxLeftOrRight;
+};
+console.log(maxPath(one));
diff --git a/elementaryAlgo/raboAlgo/bubbleSort.js b/elementaryAlgo/raboAlgo/bubbleSort.js
new file mode 100644
index 0000000..8a5a2a4
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/bubbleSort.js
@@ -0,0 +1,18 @@
+const bubbleSort = (arr) => {
+ //for every element compare with rest of elements
+ for (let i = 0; i < arr.length; i++) {
+ //start loop till one element less the end of array because of j + 1 maybe undefined
+ //element i from the left is consider to be sorted already, that is why -i
+ for (let j = 0; j < arr.length - 1 - i; j++) {
+ //if arr[j] > arr[j + 1] swap
+ if (arr[j] > arr[j + 1]) {
+ let temp = arr[j];
+ arr[j] = arr[j + 1];
+ arr[j + 1] = temp;
+ }
+ }
+ }
+ return arr;
+};
+console.log(bubbleSort([2, 1, 4, 2, 5, 16, 9]));
+// O(n^2)
diff --git a/elementaryAlgo/raboAlgo/cartesianProduct.js b/elementaryAlgo/raboAlgo/cartesianProduct.js
new file mode 100644
index 0000000..2934781
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/cartesianProduct.js
@@ -0,0 +1,11 @@
+const cartesianProduct = (arr1, arr2) => {
+ let cartesian = [];
+ for (let i = 0; i < arr1.length; i++) {
+ for (let j = 0; j < arr2.length; j++) {
+ cartesian.push([arr1[i], arr2[j]]);
+ }
+ }
+ return cartesian;
+};
+console.log(cartesianProduct([1, 3], [4, 5, 6]));
+// Time O(mn) and space
diff --git a/elementaryAlgo/raboAlgo/climbingStaircase.js b/elementaryAlgo/raboAlgo/climbingStaircase.js
new file mode 100644
index 0000000..e0cb086
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/climbingStaircase.js
@@ -0,0 +1,15 @@
+//Given a staircase of n steps, count the number of distinct ways to climb to the top.
+//you can either climb 1 step or 2 steps at a time
+const climbingStaircase = (n) => {
+ //number of ways
+ let numOfWays = [1, 2];
+ // start at i = 2; number of ways array have cover the initial positions of 0 and 1.
+ //remember you are looping through n
+ for (let i = 2; i <= n; i++) {
+ //number of ways array following fibbonuci series pattern
+ numOfWays[i] = numOfWays[i - 1] + numOfWays[i - 2];
+ }
+ //note numOfWays[n -1] because array index start from zero
+ return numOfWays[n - 1];
+};
+console.log(climbingStaircase(5));
diff --git a/elementaryAlgo/raboAlgo/hasTable.js b/elementaryAlgo/raboAlgo/hasTable.js
new file mode 100644
index 0000000..6e5f473
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/hasTable.js
@@ -0,0 +1,70 @@
+class HashTable {
+ constructor(value) {
+ this.table = new Array(value);
+ this.size = value;
+ }
+ hash(key) {
+ let total = 0;
+ for (let i = 0; i < key.length; i++) {
+ total += key.charCodeAt(i);
+ }
+ total % this.size;
+ return total;
+ }
+ set(key, value) {
+ let index = this.hash(key);
+ let bucket = this.table[index];
+ if (!bucket) {
+ this.table[index] = [[key, value]];
+ } else {
+ let someItem = bucket.find((item) => item[0] === key);
+ if (someItem) {
+ bucket[1] = value;
+ } else {
+ bucket.push([key, value]);
+ }
+ }
+ }
+ get(key) {
+ let index = this.hash(key);
+ let bucket = this.table[index];
+ if (bucket) {
+ let sameItem = bucket.find((item) => item[0] === key);
+ if (sameItem) {
+ return sameItem[1];
+ }
+ }
+ return undefined;
+ }
+ remove(key) {
+ let index = this.hash(key);
+ let bucket = this.table[index];
+ if (bucket) {
+ const sameKeyItem = bucket.find((item) => item[0] === key);
+ if (sameKeyItem) {
+ bucket.splice(bucket.indexOf(sameKeyItem), 1);
+ }
+ }
+ }
+ display() {
+ for (let i = 0; i < this.table.length; i++) {
+ if (this.table[i]) {
+ console.log(i, this.table[i]);
+ }
+ }
+ }
+}
+const map = new HashTable(50);
+map.set("name", 30);
+map.set("u", "animals");
+map.set("n", 300);
+map.set("g", "ant");
+map.set("a", 378);
+map.set("b", "bulk");
+console.log(map);
+console.log(map.get("name"));
+console.log(map.get("n"));
+console.log(map.get("g"));
+console.log(map.get("b"));
+console.log(map.remove("a"));
+map.display();
diff --git a/elementaryAlgo/raboAlgo/insertionSort.js b/elementaryAlgo/raboAlgo/insertionSort.js
new file mode 100644
index 0000000..a380659
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/insertionSort.js
@@ -0,0 +1,22 @@
+const insertionSort = (arr) => {
+ //start iteration at i = 1, because element at i = 0 with consider to be sorted
+ for (let i = 1; i < arr.length; i++) {
+ //element to the left of i = 1 should be j
+ let j = i - 1;
+ //element to be inserted
+ let elementInsert = arr[i];
+ //all elements to the left of i must best compare and if element to the left of j is greater
+ // than element to be insert
+ while (j >= 0 && arr[j] > elementInsert) {
+ //insert at j + 1 the element at j
+ arr[j + 1] = arr[j];
+ //conditions for the while loop check others element to the left of i
+ j--;
+ }
+ //after the while insert element at j + 1 to be element to be inserted
+ arr[j + 1] = elementInsert;
+ }
+ return arr;
+};
+console.log(insertionSort([2, 1, 0, 3, 4, 9, 87, 6]));
+//O(n^2)
diff --git a/elementaryAlgo/raboAlgo/islandCountBFS.js b/elementaryAlgo/raboAlgo/islandCountBFS.js
new file mode 100644
index 0000000..8de1b40
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/islandCountBFS.js
@@ -0,0 +1,57 @@
+const directions = [
+ [-1, 0],
+ [0, 1],
+ [1, 0],
+ [0, -1],
+];
+//time O(m*n) and Space O(min(m, n)) because implemented BFS
+//For the same solution for DFS with time O(m*n) and Space O(min(m, n))
+//I use BSF for better space performance
+const numberOfIsland = (matrix) => {
+ if (matrix.length === 0) {
+ return 0;
+ }
+ let islandCount = 0;
+ let queue = [];
+ //sequential order
+ for (let row = 0; row < matrix.length; row++) {
+ for (let col = 0; col < matrix[0].length; col++) {
+ if (matrix[row][col] === 1) {
+ islandCount++;
+ queue.push([row, col]);
+ while (queue.length > 0) {
+ let current = queue.shift();
+ const currRow = current[0];
+ const currCol = current[1];
+ matrix[currRow][currCol] = 0;
+ for (let i = 0; i < directions.length; i++) {
+ const [directionRow, directionCol] = directions[i];
+ const currentRow = currRow + directionRow;
+ const currentCol = currCol + directionCol;
+
+ if (
+ currentRow < 0 ||
+ currentRow >= matrix.length ||
+ currentCol < 0 ||
+ currentCol >= matrix[0].length
+ ) {
+ continue;
+ }
+ if (matrix[currentRow][currentCol] === 1) {
+ queue.push([currentRow, currentCol]);
+ }
+ }
+ }
+ }
+ }
+ }
+ return islandCount;
+};
+
+const matrix = [
+ [1, 1, 1, 1, 0],
+ [1, 1, 0, 1, 0],
+ [1, 1, 0, 0, 1],
+ [0, 0, 0, 1, 1],
+];
+console.log(numberOfIsland(matrix));
diff --git a/elementaryAlgo/raboAlgo/islandCountDFS.js b/elementaryAlgo/raboAlgo/islandCountDFS.js
new file mode 100644
index 0000000..810493b
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/islandCountDFS.js
@@ -0,0 +1,52 @@
+const directions = [
+ [-1, 0],
+ [0, 1],
+ [1, 0],
+ [0, -1],
+];
+const numberOfIsland = (matrix) => {
+ if (matrix.length === 0) return 0;
+ let stack = [];
+ islandCount = 0;
+ //sequential check
+ for (let row = 0; row < matrix.length; row++) {
+ for (let col = 0; col < matrix[0].length; col++) {
+ if (matrix[row][col] === 1) {
+ islandCount++;
+ stack.push([row, col]);
+ while (stack.length > 0) {
+ let current = stack.pop();
+ const [currRow, currCol] = current;
+ matrix[currRow][currCol] = 0;
+ for (let i = 0; i < directions.length; i++) {
+ //destructure movement up, down, right, left
+ const [x, y] = directions[i];
+ // add the movement search to the current position
+ const currentRow = x + currRow;
+ const currentCol = y + currCol;
+ if (
+ currentRow < 0 ||
+ currentRow >= matrix.length ||
+ currentCol < 0 ||
+ currentCol >= matrix[0].length
+ ) {
+ continue;
+ }
+ if (matrix[currentRow][currentCol] === 1) {
+ stack.push([currentRow, currentCol]);
+ }
+ }
+ }
+ }
+ }
+ }
+ return islandCount;
+};
+
+const matrix = [
+ [1, 1, 1, 1, 0],
+ [1, 1, 0, 1, 0],
+ [1, 1, 0, 0, 1],
+ [0, 0, 0, 1, 1],
+];
+console.log(numberOfIsland(matrix));
diff --git a/elementaryAlgo/raboAlgo/linkListClass.js b/elementaryAlgo/raboAlgo/linkListClass.js
new file mode 100644
index 0000000..1c3b723
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/linkListClass.js
@@ -0,0 +1,308 @@
+//linkedList without tail
+class Node {
+ constructor(value) {
+ this.value = value;
+ this.next = null;
+ }
+}
+class LinkedList {
+ constructor() {
+ this.head = null;
+ this.size = 0;
+ }
+ isEmpty() {
+ return this.size === 0;
+ }
+ getSize() {
+ return this.size;
+ }
+ //O(1)
+ prepend(value) {
+ let node = new Node(value);
+ if (this.isEmpty()) {
+ this.head = node;
+ } else {
+ node.next = this.head;
+ this.head = node;
+ }
+
+ this.size++;
+ }
+
+ //O(n)
+ append(value) {
+ let node = new Node(value);
+ if (this.isEmpty()) {
+ this.head = node;
+ } else {
+ let prev = this.head;
+ while (prev.next) {
+ prev = prev.next;
+ }
+ prev.next = node;
+ }
+ this.size++;
+ }
+ insert(value, index) {
+ if (index < 0 || index >= this.size) {
+ return "Invalid index";
+ }
+ if (index === 0) {
+ this.prepend(value);
+ }
+ let node = new Node(value);
+ let prev = this.head;
+ let ind = 0;
+ while (prev) {
+ if (ind === index - 1) {
+ let next = prev.next;
+ prev.next = node;
+ node.next = next;
+ this.size++;
+ }
+ prev = prev.next;
+ ind++;
+ }
+ }
+ remove(index) {
+ if (index < 0 || index >= this.size) {
+ return "Invalid index";
+ }
+ if (this.isEmpty()) {
+ return null;
+ }
+ if (index === 0) {
+ let head = this.head;
+ this.head = head.next;
+ this.size--;
+ return head.value;
+ }
+ let fast = this.head;
+ let ind = 0;
+ while (fast) {
+ if (ind === index - 1) {
+ let next = fast.next;
+ fast.next = fast.next.next;
+ this.size--;
+ return next.value;
+ }
+ fast = fast.next;
+ ind++;
+ }
+ }
+ removeValue(value) {
+ if (this.isEmpty()) {
+ return null;
+ }
+ if (value === this.head.value) {
+ let remove = this.head;
+ this.head = this.head.next;
+ this.size--;
+ return remove.value;
+ }
+ let prev = this.head;
+
+ while (prev.next && prev.next.value !== value) {
+ prev = prev.next;
+ }
+ if (prev.next) {
+ let remove = prev.next;
+ prev.next = remove.next;
+ this.size--;
+ return remove.value;
+ }
+ return null;
+ }
+ search(value) {
+ if (this.isEmpty()) {
+ return -1;
+ }
+ let prev = this.head;
+ let ind = 0;
+ while (prev) {
+ if (prev.value === value) {
+ return ind;
+ }
+ ind++;
+ prev = prev.next;
+ }
+ return -1;
+ }
+ reverse() {
+ let prev = null,
+ cur = this.head;
+ while (cur) {
+ let next = cur.next;
+ cur.next = prev;
+ //advance prev pointer
+ prev = cur;
+ //advance curr pointer
+ cur = next;
+ }
+ //set head to be new item in the list
+ this.head = prev;
+ }
+ print() {
+ if (this.isEmpty()) {
+ console.log("list is empty");
+ } else {
+ let result = "";
+ let currentNode = this.head;
+ while (currentNode) {
+ result += `${currentNode.value} `;
+ currentNode = currentNode.next;
+ }
+ console.log(result);
+ return result;
+ }
+ }
+}
+let linkedList = new LinkedList();
+console.log(linkedList.isEmpty());
+console.log(linkedList.getSize());
+linkedList.prepend(2);
+linkedList.prepend(40);
+console.log(linkedList.print());
+linkedList.append(100);
+console.log(linkedList.print());
+console.log(linkedList.insert(700, 1));
+console.log(linkedList.print());
+console.log(linkedList.remove(0));
+console.log(linkedList.print());
+console.log(linkedList.removeValue(700));
+console.log(linkedList.removeValue(1000));
+console.log(linkedList.print());
+console.log(linkedList.search(100));
+console.log(linkedList.reverse());
+console.log(linkedList.print());
+class NewNode {
+ constructor(value) {
+ this.value = value;
+ this.next = null;
+ }
+}
+//linkList with head
+class LinkedListNew {
+ constructor() {
+ this.head = null;
+ this.tail = null;
+ this.size = 0;
+ }
+ isEmpty() {
+ return this.size === 0;
+ }
+ //prepend
+ prepend(value) {
+ let node = new NewNode(value);
+ if (this.isEmpty()) {
+ this.head = node;
+ this.tail = node;
+ } else {
+ let head = this.head;
+ this.head = node;
+ node.next = head;
+ }
+ this.size++;
+ return this.head;
+ }
+ append(value) {
+ let node = new NewNode(value);
+ if (this.isEmpty()) {
+ this.head = node;
+ this.tail = node;
+ } else {
+ let tail = this.tail;
+ this.tail = node;
+ tail.next = node;
+ }
+ this.size++;
+ return this.head;
+ }
+ insert(value, index) {
+ if (index < 0 || index >= this.size) return "Invalid index";
+ if (index === 0) {
+ this.prepend(value);
+ }
+ if (index === this.size - 1) {
+ this.append(value);
+ }
+ let newNode = new NewNode(value);
+ let current = this.head;
+ let ind = 0;
+ while (current.next) {
+ if (ind === index - 1) {
+ let node = current.next;
+ current.next = newNode;
+ newNode.next = node;
+ this.size++;
+ }
+ index++;
+ current = current.next;
+ }
+ return this.head;
+ }
+ remove(index) {
+ if (index < 0 || index >= this.size - 1) return "Invilid index";
+ if (index === 0) {
+ let head = this.head;
+ this.head = head.next;
+ this.size--;
+ return head;
+ }
+ let current = this.head;
+ let ind = 0;
+ while (current) {
+ if (ind === index - 1) {
+ let next = current.next;
+ current.next = next.next;
+ this.size--;
+ return next;
+ }
+ ind++;
+ current = current.next;
+ }
+ }
+ removeFromEnd() {
+ if (this.isEmpty()) {
+ return null;
+ }
+ let head = this.tail.value;
+ if (this.size === 1) {
+ this.head = null;
+ this.tail = null;
+ this.size--;
+ return head.value;
+ } else {
+ let prev = this.head;
+ while (prev.next !== this.tail) {
+ prev = prev.next;
+ }
+ prev.next = null;
+ this.tail = prev;
+ }
+ this.size--;
+ return head;
+ }
+ print() {
+ let current = this.head;
+ let result = "";
+ while (current) {
+ result += `${current.value} `;
+ current = current.next;
+ }
+ return result;
+ }
+}
+let newLinkedList = new LinkedListNew();
+newLinkedList.prepend(2);
+newLinkedList.prepend(400);
+console.log(newLinkedList);
+console.log(newLinkedList.isEmpty());
+console.log(newLinkedList.print());
+console.log(newLinkedList.append(90));
+console.log(newLinkedList.print());
+console.log(newLinkedList.insert(600, 1));
+console.log(newLinkedList.insert(700, 3));
+console.log(newLinkedList.removeFromEnd(4));
+console.log(newLinkedList);
+console.log(newLinkedList.print());
diff --git a/elementaryAlgo/raboAlgo/linkedListProblems.js b/elementaryAlgo/raboAlgo/linkedListProblems.js
new file mode 100644
index 0000000..b4a86c9
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/linkedListProblems.js
@@ -0,0 +1,193 @@
+class Node {
+ constructor(value) {
+ this.value = value;
+ this.next = null;
+ }
+}
+const a = new Node("A");
+const b = new Node("B");
+const c = new Node("C");
+const d = new Node("D");
+a.next = b;
+b.next = c;
+c.next = d;
+
+//print to console iteratively
+const printLinkedList = (head) => {
+ let current = head;
+ while (current) {
+ console.log(current.value);
+ current = current.next;
+ }
+};
+//print to console recursively
+console.log(printLinkedList(a));
+const printLinkedListRecursive = (head) => {
+ if (head === null) return;
+ console.log(head.value);
+ printLinkedListRecursive(head.next);
+};
+console.log(printLinkedListRecursive(a));
+
+//linked list values iteratively
+const linkedListValue = (head) => {
+ let values = [];
+ let current = head;
+ while (current !== null) {
+ values.push(current.value);
+ current = current.next;
+ }
+ return values;
+};
+console.log(linkedListValue(a));
+
+//linked list values recursively
+const linkedListRecursive = (head) => {
+ let results = [];
+ results.push(head.value);
+ fillCallList(head.next, results);
+ return results;
+};
+function fillCallList(head, results) {
+ if (head === null) return;
+ results.push(head.value);
+ fillCallList(head.next, results);
+}
+console.log(linkedListRecursive(a));
+const one = new Node(1);
+const two = new Node(2);
+const three = new Node(3);
+const four = new Node(4);
+
+one.next = two;
+two.next = three;
+three.next = four;
+
+//sumList
+const sumList = (head) => {
+ let total = 0;
+ let current = head;
+ while (current) {
+ total += current.value;
+ current = current.next;
+ }
+ return total;
+};
+console.log(sumList(one));
+
+//sumList
+const sumListRecursive = (head) => {
+ if (head === null) return 0;
+ return head.value + sumListRecursive(head.next);
+};
+
+console.log(sumListRecursive(one));
+
+// target node
+const targetNode = (head, val) => {
+ let current = head;
+ while (current) {
+ if (current.value === val) {
+ return true;
+ }
+ current = current.next;
+ }
+ return false;
+};
+console.log(targetNode(a, "D"));
+console.log(targetNode(a, "B"));
+console.log(targetNode(a, ""));
+
+//target node recursively
+const targetNodeRecursive = (head, val) => {
+ if (head === null) return false;
+ if (head.value === val) return true;
+ return targetNodeRecursive(head.next, val);
+};
+console.log(targetNodeRecursive(a, "B"));
+console.log(targetNodeRecursive(a, "B"));
+console.log(targetNodeRecursive(a, ""));
+
+const getValue = (head, index) => {
+ let current = head;
+ let ind = 0;
+ while (current) {
+ if (ind === index) {
+ return current.value;
+ }
+
+ ind++;
+ current = current.next;
+ }
+ return null;
+};
+console.log(getValue(a, 1));
+console.log(getValue(a, 2));
+console.log(getValue(a, 3));
+console.log(getValue(a, 4));
+
+const getValueRecursive = (head, index) => {
+ if (head === null) return null;
+ if (index === 0) return head.value;
+ return getValueRecursive(head.next, index - 1);
+};
+console.log(getValueRecursive(a, 1));
+console.log(getValueRecursive(a, 2));
+console.log(getValueRecursive(a, 3));
+console.log(getValueRecursive(a, 4));
+
+const reverseList = (head) => {
+ let current = head;
+ let prev = null;
+ while (current) {
+ let next = current.next;
+ current.next = prev;
+
+ prev = current;
+ current = next;
+ }
+ return prev;
+};
+
+console.log(reverseList(a));
+
+const zippList = (head1, head2) => {
+ let tail = head1;
+ let current1 = head1.next;
+ let current2 = head2;
+ let count = 0;
+ while (current1 !== null && current2 !== null) {
+ //when count is even add current2 to tail
+ if (count % 2 === 0) {
+ tail.next = current2;
+ //shift current2 current node to the next
+ current2 = current2.next;
+ } else {
+ //else add current1 to tail
+ tail.next = current1;
+ //shift current1 current node to the next
+ current1 = current1.next;
+ }
+ //shift tail to the next iteration
+ tail = tail.next;
+ count++;
+ }
+ //if the while loop finishes and there is still
+ //element in either list then append them to the tail
+ if (current1 !== null) {
+ tail.next = current1;
+ }
+ if (current2 !== null) {
+ tail.next = current2;
+ }
+ //return the entry head
+ return head1;
+};
+const five = new Node(5);
+const six = new Node(6);
+const seven = new Node(7);
+five.next = six;
+six.next = seven;
+console.log(one);
+console.log(five);
+console.log(zippList(one, five));
diff --git a/elementaryAlgo/raboAlgo/mergeSort.js b/elementaryAlgo/raboAlgo/mergeSort.js
new file mode 100644
index 0000000..fd9b93f
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/mergeSort.js
@@ -0,0 +1,32 @@
+const mergeSort = (arr) => {
+ //whenever the elements are less than two return the array
+ if (arr.length < 2) return arr;
+ // get mid point
+ let mid = Math.floor(arr.length / 2);
+ // copy the element from start but not including the middle
+ let left = arr.slice(0, mid);
+ // copy the element from the middle to the end
+ let right = arr.slice(mid);
+ //make a recursive call for both left and right until
+ //all elements are one. Call the merge helper function
+ //pass in left and right.
+ return merge(mergeSort(left), mergeSort(right));
+};
+const merge = (leftArr, rightArr) => {
+ let sorted = [];
+ //check if both leftArr and rightArr still have elements
+ while (leftArr.length && rightArr.length) {
+ //check if the first element of left array is less than
+ // first element of right array, then remove it and push
+ //to the sorted array
+ if (leftArr[0] <= rightArr[0]) {
+ sorted.push(leftArr.shift());
+ } else {
+ //else
+ sorted.push(rightArr.shift());
+ }
+ }
+ //copy in this order for the elements to sorted and return
+ return [...sorted, ...leftArr, ...rightArr];
+};
+console.log(mergeSort([9, 2, -1, -6, 8, 3]));
diff --git a/elementaryAlgo/raboAlgo/numOfminutes.js b/elementaryAlgo/raboAlgo/numOfminutes.js
new file mode 100644
index 0000000..db3f898
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/numOfminutes.js
@@ -0,0 +1,38 @@
+// A company has n employees with a unique ID for each employee from 0 to n - 1. The head of the company
+// is the one with headID. Each employee has one direct manager given in the manager array where
+// manager[i] is the direct manager of the i-th employee, manager[headID] = -1. Also, it is
+// guaranteed that the subordination relationships have a tree structure. The head of the company wants to
+// inform all the company employees of an urgent piece of news. He will inform his direct subordinates, and
+// they will inform their subordinates, and so on until all employees know about the urgent news. The i-th employee
+// needs informTime[i] minutes to inform all of his direct subordinates (i.e., After informTime[i] minutes, all
+// his direct subordinates can start spreading the news). Return the number of minutes needed to inform all the
+// employees about the urgent news.
+// Example 1:
+
+// Input: n = 1, headID = 0, manager = [-1], informTime = [0]
+// Output: 0
+// Explanation: The head of the company is the only employee in the company.
+// Example 2:
+
+// Input: n = 6, headID = 2, manager = [2,2,-1,2,2,2], informTime = [0,0,1,0,0,0]
+// Output: 1
+// Explanation: The head of the company with id = 2 is the direct manager of all the employees in the company and needs 1 minute to inform them all.
+// The tree structure of the employees in the company is shown.
+
+const numOfMinutes = (n, headID, manager, informTime) => {
+ const tree = [...Array(n)].map(() => []);
+ for (let i = 0; i < n; i++) {
+ if (manager[i] !== -1) tree[manager[i]].push(i);
+ }
+ return traverse(headID, tree, informTime);
+};
+
+const traverse = (node, tree, informTime) => {
+ let maxTime = 0;
+
+ for (let subordinate of tree[node]) {
+ maxTime = Math.max(maxTime, traverse(subordinate, tree, informTime));
+ }
+ return maxTime + informTime[node];
+};
+console.log(numOfMinutes(6, 2, [2, 2, -1, 2, 2, 2], [0, 0, 1, 0, 0, 0]));
diff --git a/elementaryAlgo/raboAlgo/numberOfIsland.js b/elementaryAlgo/raboAlgo/numberOfIsland.js
new file mode 100644
index 0000000..ba295ba
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/numberOfIsland.js
@@ -0,0 +1,30 @@
+const numIslands = (grid) => {
+ let count = 0;
+ for (let r = 0; r < grid.length; r += 1) {
+ for (let c = 0; c < grid[r].length; c += 1) {
+ if (grid[r][c] === "1") {
+ count = count + explore(grid, r, c);
+ }
+ }
+ }
+ return count;
+};
+
+let explore = (grid, r, c) => {
+ if (
+ r < 0 ||
+ r > grid.length - 1 ||
+ c < 0 ||
+ c > grid[r].length - 1 ||
+ grid[r][c] === "0"
+ ) {
+ return;
+ }
+ grid[r][c] = "0";
+ explore(grid, r + 1, c);
+ explore(grid, r - 1, c);
+ explore(grid, r, c + 1);
+ explore(grid, r, c - 1);
+ return 1;
+};
+//BRD-hH7G-Mzu3-LNDv1
\ No newline at end of file
diff --git a/elementaryAlgo/raboAlgo/orangesRotting.js b/elementaryAlgo/raboAlgo/orangesRotting.js
new file mode 100644
index 0000000..a6c47cd
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/orangesRotting.js
@@ -0,0 +1,75 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var orangesRotting = function (grid) {
+ //Initialize queue for our BFS, Number of fresh oranges, and time to be returned.
+ let queue = [],
+ time = 0,
+ oranges = 0;
+
+ //Traverse matrix. If we find a fresh orange, increment orange count.
+ //If we find a rotten one, add it to the queue.
+ for (let row = 0; row < grid.length; row++) {
+ for (let col = 0; col < grid[0].length; col++) {
+ if (grid[row][col] === 1) oranges++;
+ else if (grid[row][col] === 2) queue.push([row, col, 0]);
+ }
+ }
+ //Dirs will help us check neighbors during our BFS. Adding these coordinates
+ //to a point just gets right, left, up and down. endR and endC are used later
+ //to make sure neighbor coords are within grid.
+ let dir = [
+ [-1, 0],
+ [0, 1],
+ [1, 0],
+ [0, -1],
+ ];
+ //Loop while queue is not empty and there are still fresh oranges.
+ while (queue.length && oranges) {
+ //Entry within queue can be destructured to make it easier to work with.
+ //Each queue entry has a row, column and number of minutes taken for
+ //infection to reach.
+ const [rRow, cCol, mins] = queue.shift();
+
+ //If orange is still fresh, we mark it as rotten, decrement our fresh oranges
+ //count and set time to = mins. Since we BFSing, the time it takes to infect
+ //the last orange will be the time to infect all. Once all oranges have
+ //been infected, our orange count will = 0 and our condition in while loop
+ //will stop the loop. Time can then be returned
+ if (grid[rRow][cCol] === 1) {
+ grid[rRow][cCol] = 2;
+ oranges--;
+ time = mins;
+ }
+
+ //Here's where our dir array above comes in handy. We destructure
+ //each entry and add it to our current to get neighbor coords below.
+ for (let [r, c] of dir) {
+ let nextRow = r + rRow,
+ nextCol = c + cCol;
+ //Here we obtain our new or neighbor coordinates by adding currentRow
+ //and addRow of dir. Same for col.
+
+ //Here we check to make sure new coordinates lie within the grid.
+ if (
+ nextRow < 0 ||
+ nextCol < 0 ||
+ nextRow >= grid.length ||
+ nextCol >= grid[0].length
+ )
+ continue;
+ //If neighbor coord is valid, and there is a fresh orange at those coordinates
+ //we push coordinates to our BFS to be infected next. We also increment the
+ //mins count to track time taken to spread to that orange.
+ if (grid[nextRow][nextCol] === 1) {
+ queue.push([nextRow, nextCol, mins + 1]);
+ }
+ }
+ }
+
+ //If we still have uninfected oranges, we return -1 because it won't spread
+ //to all. Otherwise, we simply return the time from initial infected to last
+ //infected orange.
+ return oranges ? -1 : time;
+};
diff --git a/elementaryAlgo/raboAlgo/quickSort.js b/elementaryAlgo/raboAlgo/quickSort.js
new file mode 100644
index 0000000..e9e165f
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/quickSort.js
@@ -0,0 +1,20 @@
+const quickSort = (arr) => {
+ //this condition is can arr.length === 1 || arr.length === 0 because arr.length can be zero
+ if (arr.length < 2) return arr;
+ //pick last element as pivot
+ let pivot = arr[arr.length - 1],
+ left = [],
+ right = [];
+ //iterate from first element but not include the pivot
+ for (let i = 0; i < arr.length - 1; i++) {
+ //current element is greater than pivot
+ if (arr[i] > pivot) right.push(arr[i]);
+ //else
+ else left.push(arr[i]);
+ }
+ //call quick sort recusively until it reaches base case
+ //and the base could be empty array or array with single element,
+ //copy the base cases into a new array with the pivot in the centre
+ return [...quickSort(left), pivot, ...quickSort(right)];
+};
+console.log(quickSort([9, 4, 5, 6, 7, 8, 10, 11]));
diff --git a/elementaryAlgo/raboAlgo/twoCrystalBalls.js b/elementaryAlgo/raboAlgo/twoCrystalBalls.js
new file mode 100644
index 0000000..bf8bdb0
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/twoCrystalBalls.js
@@ -0,0 +1,20 @@
+//Given to crystal balls that will break if dropped from high enough distance,
+//determine the exact spot in which it will break in most optimized way.
+const twoCrystalBall = (breaks) => {
+ const jmpAmount = Math.floor(Math.sqrt(breaks.length));
+ let i = jmpAmount;
+ for (; i < breaks.length; i++) {
+ if (breaks[i]) {
+ break;
+ }
+ }
+ i--;
+ for (let j = 0; j < jmpAmount && i < breaks.length; ++j, ++i) {
+ if (breaks[i]) {
+ return i;
+ }
+ }
+ return -1;
+};
+console.log(twoCrystalBall(["f", "f", "f", "t", "f", "f", "f", "f", "t"]));
+console.log(twoCrystalBall(["f", "f", "f", "t", "f"]));
diff --git a/elementaryAlgo/raboAlgo/twoDArrayOrMatrixBFS.js b/elementaryAlgo/raboAlgo/twoDArrayOrMatrixBFS.js
new file mode 100644
index 0000000..d2851cf
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/twoDArrayOrMatrixBFS.js
@@ -0,0 +1,39 @@
+const directions = [
+ [-1, 0],
+ [0, 1],
+ [1, 0],
+ [0, -1],
+];
+// time O(n) and space O(n)
+const bfs = (matrix) => {
+ let seen = new Array(matrix.length)
+ .fill(0)
+ .map(() => new Array(matrix[0].length).fill(false));
+ let values = [];
+ let queue = [[0, 0]];
+ while (queue.length > 0) {
+ let [row, col] = queue.shift();
+ if (
+ row < 0 ||
+ row >= matrix.length ||
+ col < 0 ||
+ col >= matrix[0].length ||
+ seen[row][col]
+ )
+ continue;
+ values.push(matrix[row][col]);
+ seen[row][col] = true;
+ for (let i = 0; i < directions.length; i++) {
+ let [x, y] = directions[i];
+ queue.push([row + x, col + y]);
+ }
+ }
+ return values;
+};
+const matrix = [
+ [1, 2, 3, 4, 5],
+ [6, 7, 8, 9, 10],
+ [11, 12, 13, 14, 15],
+ [16, 17, 18, 19, 20],
+];
+console.log(bfs(matrix));
diff --git a/elementaryAlgo/raboAlgo/twoDArrayOrMatrixDFS.js b/elementaryAlgo/raboAlgo/twoDArrayOrMatrixDFS.js
new file mode 100644
index 0000000..ffdfe26
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/twoDArrayOrMatrixDFS.js
@@ -0,0 +1,82 @@
+//recursive solution for BFS matrix
+let directions = [
+ [-1, 0],
+ [0, 1],
+ [1, 0],
+ [-1, 0],
+];
+//time O(n) and space O(n)
+const traversalDfS = (matrix) => {
+ const seen = new Array(array.length)
+ .fill(0)
+ //because the inner array are of the same length we can arrray[0]
+ .map(() => new Array(matrix[0].length).fill(false));
+ let values = [];
+ console.log(seen);
+ dfs(matrix, 0, 0, seen, values);
+ return values;
+};
+
+const dfs = (matrix, row, col, seen, values) => {
+ if (
+ row < 0 ||
+ col < 0 ||
+ row >= matrix.length ||
+ col >= matrix[row].length ||
+ seen[row][col]
+ )
+ return;
+ values.push(matrix[row][col]);
+ seen[row][col] = true;
+ for (let i = 0; i < directions.length; i++) {
+ const directionDir = directions[i];
+ dfs(matrix, row + directionDir[0], col + directionDir[1], seen, values);
+ }
+ // dfs(matrix, row - 1, col, seen, values);
+ // dfs(matrix, row, col + 1, seen, values);
+ // dfs(matrix, row + 1, col, seen, values);
+ // dfs(matrix, row, col - 1, seen, values);
+};
+let array = [
+ [1, 2, 3, 4, 5],
+ [6, 7, 8, 9, 10],
+ [11, 12, 13, 14, 15],
+ [16, 17, 18, 19, 20],
+];
+console.log(traversalDfS(array));
+//[ 1, 2, 3, 4, 5, 10, 15, 20, 19, 14, 9, 8, 13, 18, 17, 12, 7, 6, 11, 16 ]
+
+//iterative solution
+const bfsIterative = (matrix) => {
+ let seen = new Array(matrix.length)
+ .fill(0)
+ .map(() => new Array(matrix[0].length).fill(false));
+ console.log(seen);
+ let values = [];
+ let stack = [[0, 0]];
+ while (stack.length > 0) {
+ let [row, col] = stack.pop();
+ if (
+ row < 0 ||
+ row >= matrix.length ||
+ col < 0 ||
+ col >= matrix[0].length ||
+ seen[row][col]
+ )
+ continue;
+ seen[row][col] = true;
+ values.push(matrix[row][col]);
+ for (let i = 0; i < directions.length; i++) {
+ const [x, y] = directions[i];
+ stack.push([row + x, col + y]);
+ }
+ }
+ return values;
+};
+let arr = [
+ [1, 2, 3, 4, 5],
+ [6, 7, 8, 9, 10],
+ [11, 12, 13, 14, 15],
+ [16, 17, 18, 19, 20],
+];
+console.log(bfsIterative(arr));
diff --git a/elementaryAlgo/raboAlgo/twoDBasic.js b/elementaryAlgo/raboAlgo/twoDBasic.js
new file mode 100644
index 0000000..a2299cd
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/twoDBasic.js
@@ -0,0 +1,14 @@
+const twoDBasic = (arr) => {
+ for (let i = 0; i < arr.length; i++) {
+ for (let j = 0; j < arr[0].length; j++) {
+ console.log(arr[i][j]);
+ }
+ }
+};
+console.log(
+ twoDBasic([
+ [1, 2, 3],
+ [4, 5, 6],
+ [7, 8, 9],
+ ])
+);
diff --git a/elementaryAlgo/raboAlgo/wallsandGates.js b/elementaryAlgo/raboAlgo/wallsandGates.js
new file mode 100644
index 0000000..cca4f73
--- /dev/null
+++ b/elementaryAlgo/raboAlgo/wallsandGates.js
@@ -0,0 +1,58 @@
+// You are given a m x n 2D grid initialized with these three possible values.
+
+// -1 - A wall or an obstacle. 0 - A gate. INF - Infinity means an empty room.
+// We use the value 231 - 1 = 2147483647 to represent INF as you may assume that
+// the distance to a gate is less than 2147483647. Fill each empty room with the
+// distance to its nearest gate. If it is impossible to reach a gate, it should be
+// filled with INF.
+
+let directions = [
+ [-1, 0],
+ [1, 0],
+ [0, -1],
+ [0, 1],
+];
+
+const wallsAndGates = (rooms) => {
+ if (!rooms || rooms.length === 0) {
+ return;
+ }
+
+ let rows = rooms.length;
+ let cols = rooms[0].length;
+
+ for (let i = 0; i < rows; i++) {
+ for (let j = 0; j < cols; j++) {
+ // find all gates
+ if (rooms[i][j] === 0) {
+ traverse(rooms, i, j, rows, cols, 0);
+ }
+ }
+ }
+ return rooms;
+};
+
+function traverse(rooms, i, j, rows, cols, dist) {
+ //we have to set boundary in which we want to perform our depth first search
+ if (i >= 0 && i < rows && j >= 0 && j < cols) {
+ //even we within this bounded, if the element is not -1 and element is greater than or equal to the distance
+ if (rooms[i][j] !== -1 && rooms[i][j] >= dist) {
+ // set the element to be the new distance
+ rooms[i][j] = dist;
+ //perform depth first and increase the distance
+ traverse(rooms, i + 1, j, rows, cols, dist + 1);
+ traverse(rooms, i, j + 1, rows, cols, dist + 1);
+ traverse(rooms, i - 1, j, rows, cols, dist + 1);
+ traverse(rooms, i, j - 1, rows, cols, dist + 1);
+ }
+ }
+}
+let INF = 2187983647;
+console.log(
+ wallsAndGates([
+ [INF, -1, 0, INF],
+ [INF, INF, INF, -1],
+ [INF, -1, INF, -1],
+ [0, -1, INF, INF],
+ ])
+);
diff --git a/elementaryAlgo/randomIntegers.js b/elementaryAlgo/randomIntegers.js
new file mode 100644
index 0000000..4535b64
--- /dev/null
+++ b/elementaryAlgo/randomIntegers.js
@@ -0,0 +1,10 @@
+//Example 3: Integer Value between 1 and 10
+const randomIntegers = (min, max) => {
+ return Math.floor(Math.random() * (max - min) + min);
+};
+console.log(randomIntegers(1, 10));
+console.log(randomIntegers(1, 10));
+//Example 4: Integer Value between Two Numbers (Inclusive)
+const randomNumbers = (min, max) => {
+ return Math.floor(Math.random() * (max - min + 1) + min);
+};
diff --git a/elementaryAlgo/replaceAllOcurrenceStr.js b/elementaryAlgo/replaceAllOcurrenceStr.js
new file mode 100644
index 0000000..2c6e222
--- /dev/null
+++ b/elementaryAlgo/replaceAllOcurrenceStr.js
@@ -0,0 +1,10 @@
+const replaceAllOcurrenceStr = (str, word, rep) => {
+ return str.split(word).join(rep);
+};
+console.log(
+ replaceAllOcurrenceStr(
+ "hello world, I love you all. I mean you are my all in all",
+ "all",
+ "ah"
+ )
+);
diff --git a/elementaryAlgo/setOperations.js b/elementaryAlgo/setOperations.js
new file mode 100644
index 0000000..ff7ed4e
--- /dev/null
+++ b/elementaryAlgo/setOperations.js
@@ -0,0 +1,42 @@
+//intersection of a sets
+const intersectionOfSet = (setA, setB) => {
+ let intersection = new Set();
+ for (let i of setA) {
+ if (setB.has(i)) {
+ intersection.add(i);
+ }
+ }
+ return intersection;
+};
+console.log(
+ intersectionOfSet(new Set([1, 2, 5, 7, 8]), new Set([2, 4, 6, 8, 9]))
+);
+//union of sets
+const unionOfSet = (setA, setB) => {
+ let union = new Set(setA);
+ for (let i of setB) {
+ union.add(i);
+ }
+ return union;
+};
+console.log(unionOfSet(new Set([1, 2, 5, 7, 8]), new Set([2, 4, 6, 8, 9])));
+//difference of setA and setB
+const differenceOfSet = (setA, setB) => {
+ for(let i of setB){
+ if(setA.has(i)){
+ setA.delete(i)
+ }
+ }
+ return setA
+}
+console.log(differenceOfSet(new Set([1, 2, 5, 7, 8]), new Set([2, 4, 6, 8, 9])));
+//subse of setA and setB
+const subSet = (setA, setB) => {
+ for(let i of setB){
+ if(!setA.has(i)){
+ return false
+ }
+ }
+ return true
+}
+console.log(subSet(new Set([1, 2, 5, 7, 8]), new Set([2, 4, 6, 8, 9])))
\ No newline at end of file
diff --git a/elementaryAlgo/splitArrayIntoChunks.js b/elementaryAlgo/splitArrayIntoChunks.js
new file mode 100644
index 0000000..3d913d4
--- /dev/null
+++ b/elementaryAlgo/splitArrayIntoChunks.js
@@ -0,0 +1,18 @@
+const splitArrayIntoChunks = (array, chunk) => {
+ let result = [];
+ for (let i = 0; i < array.length; i += chunk) {
+ let temp = array.slice(i, i + chunk);
+ result.push(temp);
+ }
+ return result;
+};
+console.log(splitArrayIntoChunks([7, 8, 8, 9, 10, 11, 12, 13, 14, 15], 3));
+const splitArrayIntoChunk = (array, chunk) => {
+ let result = [];
+ while (array.length > 0) {
+ let temp = array.splice(0, chunk);
+ result.push(temp);
+ }
+ return result;
+};
+console.log(splitArrayIntoChunk([7, 8, 8, 9, 10, 11, 12, 13, 14, 15], 2));
diff --git a/elementaryAlgo/squareRoot.js b/elementaryAlgo/squareRoot.js
new file mode 100644
index 0000000..330f629
--- /dev/null
+++ b/elementaryAlgo/squareRoot.js
@@ -0,0 +1,5 @@
+const squareRoot = (number) => {
+ return Math.sqrt(number);
+};
+console.log(squareRoot(64));
+console.log(squareRoot(34));
diff --git a/elementaryAlgo/strInAnotherStr.js b/elementaryAlgo/strInAnotherStr.js
new file mode 100644
index 0000000..c786bcf
--- /dev/null
+++ b/elementaryAlgo/strInAnotherStr.js
@@ -0,0 +1,8 @@
+const stringInAnotherStr = (string, str) => {
+ if (string.indexOf(str) !== -1) {
+ return str;
+ }
+ return "";
+};
+console.log(stringInAnotherStr("hello world I love you so much", "lo"));
+console.log(stringInAnotherStr("hello world I love you so much", "hi"));
diff --git a/elementaryAlgo/sum.js b/elementaryAlgo/sum.js
new file mode 100644
index 0000000..61d2590
--- /dev/null
+++ b/elementaryAlgo/sum.js
@@ -0,0 +1,20 @@
+//Example 1: Sum of Natural Numbers Using for Loop
+const sumForLoop = (num) => {
+ let sum = 0;
+ for (let i = 1; i <= num; i++) {
+ sum += i;
+ }
+ return sum;
+};
+console.log(sumForLoop(10));
+//Example 2: Sum of Natural Numbers Using while Loop
+const sumWhileLoop = (num) => {
+ let sum = 0,
+ i = 1;
+ while (i <= num) {
+ sum += i;
+ i++;
+ }
+ return sum;
+};
+console.log(sumWhileLoop(10));
diff --git a/elementaryAlgo/swapTwoVariable.js b/elementaryAlgo/swapTwoVariable.js
new file mode 100644
index 0000000..db8017c
--- /dev/null
+++ b/elementaryAlgo/swapTwoVariable.js
@@ -0,0 +1,35 @@
+//Example 1: Using a Temporary Variable
+const swapTemporaryVariable = (arr) => {
+ let [a, b] = arr;
+ let temp = a;
+ a = b;
+ b = temp;
+ return [a, b];
+};
+console.log(swapTemporaryVariable([20, 40]));
+
+//Example 2: Using es6(ES2015) Destructuring assignment
+const swapEs6 = (arr) => {
+ let [a, b] = arr;
+ [b, a] = [a, b];
+ return [a, b];
+};
+console.log(swapEs6([20, 40]));
+//Example 3: Using Arithmetic Operators
+const swapArithmetic = (arr) => {
+ let [a, b] = arr;
+ a = a + b;
+ b = a - b;
+ a = a - b;
+ return [a, b];
+};
+console.log(swapArithmetic([20, 40]));
+//Example 4: Using Bitwise XOR operator
+const swapBitwiseXOR = (arr) => {
+ let [a, b] = arr;
+ a = a ^ b;
+ b = a ^ b;
+ a = a ^ b;
+ return [a, b];
+};
+console.log(swapBitwiseXOR([20, 40]));