├── README.md
├── reverse
├── reverseANumberWIthoutMethods.js
└── reverseANumberWIthMethods.js
├── closure
└── closure.js
├── fibonacci
└── fibonacci.js
├── occurrences
└── occurence.js
├── arrayDuplication
└── array.html
└── arrays-merge-sort
└── mergeSort.js
/README.md:
--------------------------------------------------------------------------------
1 | # Data-structure-and-algorithms
--------------------------------------------------------------------------------
/reverse/reverseANumberWIthoutMethods.js:
--------------------------------------------------------------------------------
1 | let integersToBeReversed = 123146;
2 | const reverseNumber = (num) =>
3 | Number(num.toString().split("").reverse().join(""));
4 | console.log("Before - ", integersToBeReversed);
5 | console.log("After - ", reverseNumber(integersToBeReversed));
6 |
--------------------------------------------------------------------------------
/closure/closure.js:
--------------------------------------------------------------------------------
1 | const outerFunction = () => {
2 | let inc = "outerFunc";
3 | const innerFunction = () => {
4 | console.log(inc);
5 | };
6 | return innerFunction;
7 | };
8 |
9 | const inner = outerFunction();
10 | inner(); //1
11 | inner(); //2
12 | inner(); //3
13 | inner(); //4
14 | inner(); //5
15 |
--------------------------------------------------------------------------------
/fibonacci/fibonacci.js:
--------------------------------------------------------------------------------
1 | const fibonacciNumbersGenerator = (upto) => {
2 | let fnum = 0;
3 | let snum = 1;
4 | let next = 0;
5 | for (let i = 0; i <= upto; i++) {
6 | next = fnum + snum;
7 | console.log(fnum);
8 | fnum = snum;
9 | snum = next;
10 | }
11 | };
12 | fibonacciNumbersGenerator(100);
13 |
--------------------------------------------------------------------------------
/reverse/reverseANumberWIthMethods.js:
--------------------------------------------------------------------------------
1 | const reverseANumberWithoutHelpers = (number) => {
2 | //82456
3 | let reversed = 0;
4 | let isNegativeInput = number < 0; // false
5 | number = Math.abs(number); // 82456
6 | while (number > 0) {
7 | let lastDigit = number % 10; // 6 first iteration
8 | reversed = reversed * 10 + lastDigit; // 60 * 10 = 60 + 6 = 66 first iteration
9 | number = Math.floor(number / 10); // 60 / 10 = 6 first iteration
10 | }
11 | if (isNegativeInput) return -reversed;
12 | return reversed;
13 | };
14 | console.log(reverseANumberWithoutHelpers(65428));
15 |
--------------------------------------------------------------------------------
/occurrences/occurence.js:
--------------------------------------------------------------------------------
1 | // LEETCODE
2 |
3 | function findOccurrenceIndex(haystack, needle) {
4 | return haystack.indexOf(needle);
5 | }
6 |
7 | // WITHOUT USING INDEX OF
8 |
9 | const findOccurrencePatternIndex = (str, word) => {
10 | let startIndex = -1;
11 | for (let i = 0; i <= str.length - word.length; i++) {
12 | let chunk = str.slice(i, i + word.length);
13 | if (chunk === word) {
14 | startIndex = i;
15 | break;
16 | }
17 | }
18 | return startIndex === -1 ? "Word does not exist in string" : startIndex;
19 | };
20 | console.log(findOccurrencePatternIndex("The whole string", "string")); // should return 10
21 |
--------------------------------------------------------------------------------
/arrayDuplication/array.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Document
7 |
8 |
9 |
24 |
25 |
26 |
--------------------------------------------------------------------------------
/arrays-merge-sort/mergeSort.js:
--------------------------------------------------------------------------------
1 | const a1 = [1, 2, 3, 4, 5, 9];
2 | const a2 = [2, 4, 6, 1, 3, 4, 5, 8];
3 | // output -> [1, 2, 3, 4, 5,6,8,9]
4 | // [1, 2, 3,4, 5,6, 8, 9]
5 | // merging two arrays
6 | const mergeHandler = (a, b) => {
7 | return [...a, ...b];
8 | };
9 | // sorting an array
10 | const sortHandler = (mergedArray) => {
11 | for (i = 0; i < mergedArray.length; i++) {
12 | for (a = i + 1; a < mergedArray.length; a++) {
13 | if (mergedArray[i] > mergedArray[a]) {
14 | let temp = mergedArray[i];
15 | mergedArray[i] = mergedArray[a];
16 | mergedArray[a] = temp;
17 | // mergedArray[i] = mergedArray[i] + mergedArray[a];
18 | // mergedArray[a] = mergedArray[i] - mergedArray[a];
19 | // mergedArray[i] = mergedArray[i] - mergedArray[a];
20 | }
21 | }
22 | }
23 | return mergedArray;
24 | };
25 | // removing duplication
26 | const duplicationRemoveHandler = (sortedArr) => {
27 | const unique = [];
28 | for (let i = 0; i < sortedArr.length; i++) {
29 | if (!unique.includes(sortedArr[i])) unique.push(sortedArr[i]);
30 | }
31 | return unique;
32 | };
33 |
34 | const merged = mergeHandler(a1, a2);
35 | const sortedArray = sortHandler(merged);
36 | const uniqueArr = duplicationRemoveHandler(sortedArray);
37 |
38 | console.log("Merged => Sorted => Unique => ", uniqueArr);
39 |
--------------------------------------------------------------------------------