Skip to content

Commit 038150e

Browse files
aakhtar3aakhtar3
authored
refactor: js | array + hash (#445)
1 parent 4253d53 commit 038150e

10 files changed

+728
-331
lines changed

‎javascript/1-Two-Sum.js

+72-8
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,79 @@
11
/**
2+
* Brute Force - Linear Search
3+
* Time O(N^2) | Space O(1)
4+
* https://leetcode.com/problems/two-sum/
25
* @param {number[]} nums
36
* @param {number} target
47
* @return {number[]}
58
*/
6-
var twoSum = function (nums, target) {
7-
let map = {};
8-
for (let i = 0; i < nums.length; i++) {
9-
if (target - nums[i] in map) {
10-
return [map[target - nums[i]], i];
11-
} else {
12-
map[nums[i]] = i;
9+
var twoSum = (nums, target) => {
10+
for (let curr = 0; curr < nums.length; curr++) {/* Time O(N) */
11+
const complement = target - nums[curr];
12+
13+
for (let next = (curr + 1); next < nums.length; next++) {/* Time O(N) */
14+
const num = nums[next];
15+
16+
const isTarget = num === complement
17+
if (isTarget) return [ curr, next ];
1318
}
1419
}
15-
};
20+
21+
return [ -1, -1 ];
22+
}
23+
24+
/**
25+
* Hash Map - 2 Pass
26+
* Time O(N) | Space O(N)
27+
* https://leetcode.com/problems/two-sum/
28+
* @param {number[]} nums
29+
* @param {number} target
30+
* @return {number[]}
31+
*/
32+
var twoSum = (nums, target) => {
33+
const map = getMap(nums); /* Time O(N) | Space O(N) */
34+
35+
return getSum(nums, target, map)/* Time O(N) */
36+
}
37+
38+
const getMap = (nums, map = new Map()) => {
39+
for (let index = 0; index < nums.length; index++) {/* Time O(N) */
40+
map.set(nums[index], index); /* Space O(N) */
41+
}
42+
43+
return map
44+
}
45+
46+
const getSum = (nums, target, map) => {
47+
for (let index = 0; index < nums.length; index++) {/* Time O(N) */
48+
const complement = target - nums[index];
49+
const sumIndex = map.get(complement);
50+
51+
const isTarget = map.has(complement) && (map.get(complement) !== index)
52+
if (isTarget) return [ index, sumIndex ]
53+
}
54+
55+
return [ -1, -1 ];
56+
}
57+
58+
/**
59+
* Hash Map - 1 Pass
60+
* Time O(N) | Space O(N)
61+
* https://leetcode.com/problems/two-sum/
62+
* @param {number[]} nums
63+
* @param {number} target
64+
* @return {number[]}
65+
*/
66+
var twoSum = (nums, target, map = new Map()) => {
67+
for (let index = 0; index < nums.length; index++) {/* Time O(N) */
68+
const num = nums[index];
69+
const complement = (target - num);
70+
const sumIndex = map.get(complement);
71+
72+
const isTarget = map.has(complement)
73+
if (isTarget) return [ index, sumIndex ];
74+
75+
map.set(num, index); /* Space O(N) */
76+
}
77+
78+
return [ -1, -1 ];
79+
}

‎javascript/128-Longest-consecutive-sequence.js

+70-70
Original file line numberDiff line numberDiff line change
@@ -1,94 +1,94 @@
1-
//////////////////////////////////////////////////////////////////////////////
2-
// Linear Search With A Hash Map
3-
// Time: O(n)
4-
// Space: O(n)
5-
// This solution only makes one pass over the `nums` array and is the highest
6-
// performing solution.
7-
//////////////////////////////////////////////////////////////////////////////
8-
91
/**
2+
* Brute Force
3+
* Greedy - Max Score
4+
* Time O (N^3) | Space O(1)
5+
* https://leetcode.com/problems/longest-consecutive-sequence/
106
* @param {number[]} nums
117
* @return {number}
128
*/
13-
function longestConsecutive(nums) {
14-
if (!nums.length) {
15-
return 0;
16-
}
9+
var longestConsecutive = (nums, maxScore = 0) => {
10+
for (const num of nums) {/* Time O(N) */
11+
let [ currNum, score ] = [ num, 1 ];
1712

18-
const map = Object.create(null);
19-
let max = 0;
20-
21-
for (const num of nums) {
22-
if (num in map) {
23-
continue;
13+
while (isStreak(nums, (currNum + 1))) {/* Time O(N * N) */
14+
currNum++;
15+
score++;
2416
}
2517

26-
const prev = num - 1;
27-
const next = num + 1;
28-
let len = 1;
29-
30-
if (prev in map) {
31-
if (next in map) {
32-
len += map[prev] + map[next];
33-
map[prev - map[prev] + 1] = len;
34-
map[next + map[next] - 1] = len;
35-
} else {
36-
len += map[prev];
37-
++map[prev - map[prev] + 1];
38-
}
39-
} else if (next in map) {
40-
len += map[next];
41-
++map[next + map[next] - 1];
42-
}
43-
map[num] = len;
44-
max = Math.max(max, len);
18+
maxScore = Math.max(maxScore, score);
4519
}
4620

47-
return max;
21+
return maxScore;
4822
}
4923

50-
//////////////////////////////////////////////////////////////////////////////
51-
// Linear Search With A Hash Set
52-
// Time: O(n)
53-
// Space: O(n)
54-
// This solution does three passes over the `nums` array. A first pass to
55-
// setup the hash set. A second pass to find the numbers that mark the
56-
// beginning of a sequence. A third pass to calculate the length of each
57-
// sequence. The nested `while` loop does not cause quadratic calculations as
58-
// it is only initiated on the first number of each sequence.
59-
//////////////////////////////////////////////////////////////////////////////
24+
const isStreak = (nums, num) => {
25+
for (let i = 0; i < nums.length; i++) {/* Time O(N) */
26+
const isEqual = nums[i] === num
27+
if (isEqual) return true;
28+
}
29+
30+
return false;
31+
}
6032

6133
/**
34+
* Sort - HeapSort Space O(1) | QuickSort Space O(log(K))
35+
* Greedy - Max Score
36+
* Time O (N * log(N)) | Space O(1)
37+
* https://leetcode.com/problems/longest-consecutive-sequence/
6238
* @param {number[]} nums
6339
* @return {number}
6440
*/
65-
function longestConsecutive(nums) {
66-
let len = nums.length;
67-
if (!len) {
68-
return 0;
41+
var longestConsecutive = (nums) => {
42+
if (!nums.length) return 0;
43+
44+
nums.sort((a, b) => a - b);/* Time O(N * log(N)) | Space O(1 || log(N)) */
45+
46+
return search(nums); /* Time O(N) */
47+
}
48+
49+
const search = (nums) => {
50+
let [ maxScore, score ] = [ 1, 1 ];
51+
52+
for (let i = 1; i < nums.length; i++) {/* Time O(N) */
53+
const isPrevDuplicate = nums[i - 1] === nums[i]
54+
if (isPrevDuplicate) continue
55+
56+
const isStreak = nums[i] === ((nums[i - 1]) + 1)
57+
if (isStreak) { score++; continue; }
58+
59+
maxScore = Math.max(maxScore, score);
60+
score = 1;
6961
}
70-
const set = new Set(nums);
71-
let max = 0;
7262

73-
for (let i = 0; i < nums.length; i++) {
74-
const num = nums[i];
63+
return Math.max(maxScore, score);
64+
}
7565

76-
if (set.has(num - 1)) {
77-
continue;
78-
}
66+
/**
67+
* Hash Set - Intelligent Sequence
68+
* Greedy - Max Score
69+
* Time O (N) | Space O(N)
70+
* https://leetcode.com/problems/longest-consecutive-sequence/
71+
* @param {number[]} nums
72+
* @return {number}
73+
*/
74+
var longestConsecutive = (nums, maxScore = 0) => {
75+
const numSet = new Set(nums); /* Time O(N) | Space O(N) */
7976

80-
let currentMax = 1;
81-
while (set.has(num + currentMax)) {
82-
currentMax++;
83-
}
77+
for (const num of [ ...numSet ]) { /* Time O(N) */
78+
const prevNum = num - 1;
8479

85-
if (currentMax > max) {
86-
max = currentMax;
87-
}
88-
if (max > len / 2) {
89-
break;
80+
if (numSet.has(prevNum)) continue;/* Time O(N) */
81+
82+
let [ currNum, score ] = [ num, 1 ];
83+
84+
const isStreak = () => numSet.has(currNum + 1)
85+
while (isStreak()) { /* Time O(N) */
86+
currNum++;
87+
score++;
9088
}
89+
90+
maxScore = Math.max(maxScore, score);
9191
}
9292

93-
return max;
94-
}
93+
return maxScore;
94+
}

‎javascript/217-Contains-Duplicate.js

+61-20
Original file line numberDiff line numberDiff line change
@@ -1,31 +1,72 @@
11
/**
2+
* Brute Force - Linear Search
3+
* Time O(N^2) | Space O(1)
4+
* https://leetcode.com/problems/contains-duplicate/
25
* @param {number[]} nums
36
* @return {boolean}
47
*/
5-
6-
//First method using Set() (exit early if true)
7-
var containsDuplicate = function (nums) {
8-
const numsSet = new Set();
9-
for (const i of nums) {
10-
if (numsSet.has(i)) {
11-
return true;
8+
var containsDuplicate = (nums) => {
9+
for (let right = 0; right < nums.length; right++) {/* Time O(N) */
10+
for (let left = 0; left < right; left++) { /* Time O(N) */
11+
const isDuplicate = nums[left] === nums[right];
12+
if (isDuplicate) return true;
1213
}
13-
numsSet.add(i);
1414
}
15+
1516
return false;
16-
};
17+
}
18+
19+
/**
20+
* Sort - HeapSort Space O(1) | QuickSort Space O(log(N))
21+
* Time O(N * log(N)) | Space O(1)
22+
* https://leetcode.com/problems/contains-duplicate/
23+
* @param {number[]} nums
24+
* @return {boolean}
25+
*/
26+
var containsDuplicate = (nums) => {
27+
nums.sort((a, b) => a - b);/* Time O(N * log(N)) | Space O(1 || log(N)) */
1728

18-
//Second method using Map() (Has to map entire array but code is more readable)
19-
var containsDuplicate = function (nums) {
20-
//create a new hashmap with all the items in the array. Any duplicates will be removed.
21-
const totalWithoutDuplicates = new Map(nums.map((i) => [i]));
29+
return hasDuplicate(nums);
30+
}
2231

23-
//check if the size of the initial array is larger than the new hashmap.
24-
return totalWithoutDuplicates.size !== nums.length;
25-
};
32+
const hasDuplicate = (nums) => {
33+
for (let curr = 0; curr < (nums.length - 1); curr++) {/* Time O(N) */
34+
const next = (curr + 1);
35+
36+
const isNextDuplicate = nums[curr] === nums[next];
37+
if (isNextDuplicate) return true;
38+
}
2639

27-
//Third method using Set() (Fastest runtime at 91.95% and very readable code)
28-
var containsDuplicate = function (nums) {
29-
//Pass the array into a Set() (which removes duplicates) and then compare its size to the original array.
30-
return new Set(nums).size !== nums.length;
40+
return false;
41+
}
42+
43+
/**
44+
* Hash Set
45+
* Time O(N) | Space O(N)
46+
* https://leetcode.com/problems/contains-duplicate/
47+
* @param {number[]} nums
48+
* @return {boolean}
49+
*/
50+
var containsDuplicate = (nums) => {
51+
const numsSet = new Set(nums);/* Time O(N) | Space O(N) */
52+
const isEqual = numsSet.size === nums.length;
53+
54+
return !isEqual;
3155
};
56+
57+
/**
58+
* Hash Set - Early Exit
59+
* Time O(N) | Space O(N)
60+
* https://leetcode.com/problems/contains-duplicate/
61+
* @param {number[]} nums
62+
* @return {boolean}
63+
*/
64+
var containsDuplicate = (nums, numsSet = new Set()) => {
65+
for (const num of nums) {/* Time O(N) */
66+
if (numsSet.has(num)) return true;
67+
68+
numsSet.add(num); /* Space O(N) */
69+
}
70+
71+
return false;
72+
};

0 commit comments

Comments
 (0)