Skip to content

Commit de97da7

Browse files
deepakparameshdeepakparamesh
committed
algorithms commit
1 parent ee7ab8b commit de97da7

11 files changed

+438
-0
lines changed

‎algorithms/1 frequency_counter_same.js‎

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
// same naive
2+
function same(arr1, arr2){
3+
if(arr1.length !== arr2.length){
4+
return false;
5+
}
6+
for(let i = 0; i < arr1.length; i++){
7+
let correctIndex = arr2.indexOf(arr1[i] ** 2)
8+
if(correctIndex === -1) {
9+
return false;
10+
}
11+
console.log(arr2);
12+
arr2.splice(correctIndex,1)
13+
}
14+
return true;
15+
}
16+
17+
// refactored version
18+
function same(arr1, arr2) {
19+
if (arr1.length !== arr2.length) {
20+
return false;
21+
}
22+
let frequencyCounter1 = {}
23+
let frequencyCounter2 = {}
24+
for (let val of arr1) {
25+
frequencyCounter1[val] = (frequencyCounter1[val] || 0) + 1
26+
}
27+
for (let val of arr2) {
28+
frequencyCounter2[val] = (frequencyCounter2[val] || 0) + 1
29+
}
30+
console.log(frequencyCounter1);
31+
console.log(frequencyCounter2);
32+
for (let key in frequencyCounter1) {
33+
if (!(key ** 2 in frequencyCounter2)) {
34+
return false
35+
}
36+
if (frequencyCounter2[key ** 2] !== frequencyCounter1[key]) {
37+
return false
38+
}
39+
}
40+
return true
41+
}
42+
43+
same([1,2,3,2], [9,1,4,4])
44+

‎algorithms/10 mergeSort.js‎

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
// Merge function from earlier
2+
function merge(arr1, arr2){
3+
let results = [];
4+
let i = 0;
5+
let j = 0;
6+
while(i < arr1.length && j < arr2.length){
7+
if(arr2[j] > arr1[i]){
8+
results.push(arr1[i]);
9+
i++;
10+
} else {
11+
results.push(arr2[j])
12+
j++;
13+
}
14+
}
15+
while(i < arr1.length) {
16+
results.push(arr1[i])
17+
i++;
18+
}
19+
while(j < arr2.length) {
20+
results.push(arr2[j])
21+
j++;
22+
}
23+
return results;
24+
}
25+
26+
// Recrusive Merge Sort
27+
function mergeSort(arr){
28+
if(arr.length <= 1) return arr;
29+
let mid = Math.floor(arr.length/2);
30+
let left = mergeSort(arr.slice(0,mid));
31+
let right = mergeSort(arr.slice(mid));
32+
return merge(left, sright);
33+
}
34+
35+
mergeSort([10,24,76,73])

‎algorithms/11 quicksort.js‎

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
2+
function pivot(arr, start = 0, end = arr.length - 1) {
3+
const swap = (arr, idx1, idx2) => {
4+
[arr[idx1], arr[idx2]] = [arr[idx2], arr[idx1]];
5+
};
6+
7+
// We are assuming the pivot is always the first element
8+
let pivot = arr[start];
9+
let swapIdx = start;
10+
11+
for (let i = start + 1; i <= end; i++) {
12+
if (pivot > arr[i]) {
13+
swapIdx++;
14+
swap(arr, swapIdx, i);
15+
}
16+
}
17+
18+
// Swap the pivot from the start the swapPoint
19+
swap(arr, start, swapIdx);
20+
return swapIdx;
21+
}
22+
23+
24+
function quickSort(arr, left = 0, right = arr.length -1){
25+
if(left < right){
26+
let pivotIndex = pivot(arr, left, right) //3
27+
//left
28+
quickSort(arr,left,pivotIndex-1);
29+
//right
30+
quickSort(arr,pivotIndex+1,right);
31+
}
32+
return arr;
33+
}
34+
35+
quickSort([100,-3,2,4,6,9,1,2,5,3,23])
36+
37+
38+
39+
40+
// [4,6,9,1,2,5,3]
41+
// [3,2,1,4,6,9,5]
42+
// 4
43+
// 3,2,1 6,9,5
44+
// 3 6
45+
// 2,1 5 9
46+
// 2
47+
// 1
48+
49+
50+
51+

‎algorithms/2 anagram.js‎

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
function validAnagram(first, second) {
2+
if (first.length !== second.length) {
3+
return false;
4+
}
5+
6+
const lookup = {};
7+
8+
for (let i = 0; i < first.length; i++) {
9+
let letter = first[i];
10+
// if letter exists, increment, otherwise set to 1
11+
lookup[letter] ? lookup[letter] += 1 : lookup[letter] = 1;
12+
}
13+
console.log(lookup)
14+
15+
for (let i = 0; i < second.length; i++) {
16+
let letter = second[i];
17+
// can't find letter or letter is zero then it's not an anagram
18+
if (!lookup[letter]) {
19+
return false;
20+
} else {
21+
lookup[letter] -= 1;
22+
}
23+
}
24+
25+
return true;
26+
}
27+
28+
// {a: 0, n: 0, g: 0, r: 0, m: 0,s:1}
29+
validAnagram('anagrams', 'nagaramm')

‎algorithms/3 sum_zero.js‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
function sumZero(arr){
2+
for(let i = 0; i < arr.length; i++){
3+
for(let j = i+1; j < arr.length; j++){
4+
if(arr[i] + arr[j] === 0){
5+
return [arr[i], arr[j]];
6+
}
7+
}
8+
}
9+
}
10+
11+
12+
sumZero([-4,-3,-2,-1,0,1,2,5])
13+
14+
function sumZero(arr) {
15+
let left =0;
16+
let right = arr.length - 1;
17+
while(left < right) {
18+
let sum = arr[left] + arr[right];
19+
if(sum === 0) {
20+
return [arr[left], arr[right]];
21+
} else if(sum > 0) {
22+
right--;
23+
} else {
24+
left++;
25+
}
26+
}
27+
}

‎algorithms/4 unique_values.js.js‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
function countUniqueValues(arr){
2+
if(arr.length === 0) return 0;
3+
var i = 0;
4+
for(var j = 1; j < arr.length; j++){
5+
if(arr[i] !== arr[j]){
6+
i++;
7+
arr[i] = arr[j]
8+
}
9+
}
10+
return i + 1;
11+
}
12+
countUniqueValues([1,2,2,5,7,7,99])

‎algorithms/5 max_sum.js‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
// naive approach
2+
function maxSubarraySum(arr, num) {
3+
if (num > arr.length) {
4+
return null;
5+
}
6+
var max = -Infinity;
7+
for (let i = 0; i < arr.length - num + 1; i++) {
8+
temp = 0;
9+
for (let j = 0; j < num; j++) {
10+
temp += arr[i + j];
11+
}
12+
if (temp > max) {
13+
max = temp;
14+
}
15+
}
16+
return max;
17+
}
18+
19+
maxSubarraySum([2, 6, 9, 2, 1, 8, 5, 6, 3], 3)
20+
21+
22+
23+
function maxSubarraySum(arr, num){
24+
let maxSum = 0;
25+
let tempSum = 0;
26+
if (arr.length < num) return null;
27+
for (let i = 0; i < num; i++) {
28+
maxSum += arr[i];
29+
}
30+
tempSum = maxSum;
31+
for (let i = num; i < arr.length; i++) {
32+
tempSum = tempSum - arr[i - num] + arr[i];
33+
maxSum = Math.max(maxSum, tempSum);
34+
}
35+
return maxSum;
36+
}
37+
38+
maxSubarraySum([2,6,9,2,1,8,5,6,3],3)

‎algorithms/6 recursion.js‎

Lines changed: 138 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,138 @@
1+
// POWER SOLUTION
2+
function power(base, exponent) {
3+
if (exponent === 0) return 1;
4+
return base * power(base, exponent - 1);
5+
}
6+
// FACTORIAL SOLUTION
7+
function factorial(x) {
8+
if (x < 1) return 0;
9+
if (x === 1) return 1;
10+
return x * factorial(x - 1);
11+
}
12+
// PRODUCT OF ARRAY SOLUTION
13+
function productOfArray(arr) {
14+
if (arr.length === 0) {
15+
return 1;
16+
}
17+
return arr[0] * productOfArray(arr.slice(1));
18+
}
19+
// RECURSIVE RANGE SOLUTION
20+
function recursiveRange(x) {
21+
if (x === 0) return 0;
22+
return x + recursiveRange(x - 1);
23+
}
24+
// FIBONACCI SOLUTION
25+
function fib(n) {
26+
if (n <= 2) return 1;
27+
return fib(n - 1) + fib(n - 2);
28+
}
29+
30+
// Reverse Solution
31+
function reverse(str) {
32+
if (str.length <= 1) return str;
33+
return reverse(str.slice(1)) + str[0];
34+
}
35+
// isPalindrome Solution
36+
function isPalindrome(str) {
37+
if (str.length === 1) return true;
38+
if (str.length === 2) return str[0] === str[1];
39+
if (str[0] === str.slice(-1)) return isPalindrome(str.slice(1, -1))
40+
return false;
41+
}
42+
// someRecursive Solution
43+
function someRecursive(array, callback) {
44+
if (array.length === 0) return false;
45+
if (callback(array[0])) return true;
46+
return someRecursive(array.slice(1), callback);
47+
}
48+
// flatten Solution
49+
function flatten(oldArr) {
50+
var newArr = []
51+
for (var i = 0; i < oldArr.length; i++) {
52+
if (Array.isArray(oldArr[i])) {
53+
newArr = newArr.concat(flatten(oldArr[i]))
54+
} else {
55+
newArr.push(oldArr[i])
56+
}
57+
}
58+
return newArr;
59+
}
60+
61+
// capitalizeWords Solution
62+
function capitalizeWords(array) {
63+
if (array.length === 1) {
64+
return [array[0].toUpperCase()];
65+
}
66+
let res = capitalizeWords(array.slice(0, -1));
67+
res.push(array.slice(array.length - 1)[0].toUpperCase());
68+
return res;
69+
70+
}
71+
// nestedEvenSum Solution
72+
function nestedEvenSum(obj, sum = 0) {
73+
for (var key in obj) {
74+
if (typeof obj[key] === 'object') {
75+
sum += nestedEvenSum(obj[key]);
76+
} else if (typeof obj[key] === 'number' && obj[key] % 2 === 0) {
77+
sum += obj[key];
78+
}
79+
}
80+
return sum;
81+
}
82+
// capitalizeFire Solution
83+
function capitalizeFirst(array) {
84+
if (array.length === 1) {
85+
return [array[0][0].toUpperCase() + array[0].substr(1)];
86+
}
87+
const res = capitalizeFirst(array.slice(0, -1));
88+
const string = array.slice(array.length - 1)[0][0].toUpperCase() + array.slice(array.length - 1)[0].substr(1);
89+
res.push(string);
90+
return res;
91+
}
92+
// stringifyNumbers Solution
93+
function stringifyNumbers(obj) {
94+
var newObj = {};
95+
for (var key in obj) {
96+
if (typeof obj[key] === 'number') {
97+
newObj[key] = obj[key].toString();
98+
} else if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
99+
newObj[key] = stringifyNumbers(obj[key]);
100+
} else {
101+
newObj[key] = obj[key];
102+
}
103+
}
104+
return newObj;
105+
}
106+
107+
// collectStrings Solution: Helper Method Recursion Version
108+
function collectStrings(obj) {
109+
var stringsArr = [];
110+
111+
function gatherStrings(o) {
112+
for (var key in o) {
113+
if (typeof o[key] === 'string') {
114+
stringsArr.push(o[key]);
115+
}
116+
else if (typeof o[key] === 'object') {
117+
return gatherStrings(o[key]);
118+
}
119+
}
120+
}
121+
122+
gatherStrings(obj);
123+
124+
return stringsArr;
125+
}
126+
// collectStrings Solution: Pure Recursion Version
127+
function collectStrings(obj) {
128+
var stringsArr = [];
129+
for (var key in obj) {
130+
if (typeof obj[key] === 'string') {
131+
stringsArr.push(obj[key]);
132+
}
133+
else if (typeof obj[key] === 'object') {
134+
stringsArr = stringsArr.concat(collectStrings(obj[key]));
135+
}
136+
}
137+
138+
return stringsArr;

0 commit comments

Comments
 (0)