Skip to content

Commit c17dbf6

Browse files
th-blitzth-blitz
authored
Merge branch 'neetcode-gh:main' into main
2 parents a823735 + fcdfdb8 commit c17dbf6

8 files changed

+250
-185
lines changed

‎README.md

Lines changed: 4 additions & 4 deletions
Large diffs are not rendered by default.

‎c/0535-encode-and-decode-tinyurl.c

Lines changed: 55 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
// Represent an element in a hash table.
2+
typedef struct Hash {
3+
char* key;
4+
char* value;
5+
UT_hash_handle hh;
6+
} Hash;
7+
8+
Hash *root = NULL;
9+
10+
char *UrlToKey(char *url) {
11+
char *key = NULL;
12+
unsigned int hash = 1853;
13+
int i = 0;
14+
15+
while (i < strlen(url)) {
16+
hash = ((hash << 5) + hash) + url[i];
17+
i++;
18+
}
19+
20+
key = (char*)calloc(32, 1);
21+
snprintf(key, 32, "http://tinyurl.com/%X", hash);
22+
return key;
23+
}
24+
25+
/** Encodes a URL to a shortened URL. */
26+
char* encode(char* longUrl) {
27+
Hash *entry = NULL;
28+
char *key = NULL;
29+
key = UrlToKey(longUrl);
30+
HASH_FIND_STR(root, key, entry);
31+
if (!entry) {
32+
entry = malloc(sizeof(Hash));
33+
entry->key = key;
34+
entry->value = longUrl;
35+
HASH_ADD_KEYPTR(hh, root, key, strlen(key), entry);
36+
} else {
37+
free(key);
38+
}
39+
return entry->key;
40+
}
41+
42+
/** Decodes a shortened URL to its original URL. */
43+
char* decode(char* shortUrl) {
44+
Hash *entry = NULL;
45+
HASH_FIND_STR(root, shortUrl, entry);
46+
if (entry) {
47+
return entry->value;
48+
}
49+
return NULL;
50+
}
51+
52+
// Your functions will be called as such:
53+
// char* s = encode(s);
54+
// decode(s);
55+

‎c/1930-unique-length-3-palindromic-subsequences.c

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
int countPalindromicSubsequence(char * s){
2+
int n = strlen(s);
3+
int i, j;
4+
int c, answer;
5+
int first[26] = {[0 ... 25] = -1};
6+
int last[26] = {[0 ... 25] = -1};
7+
8+
// Use two arrays to record the first and last
9+
// location of each character.
10+
for (i = 0; i < n; i++) {
11+
c = s[i] - 'a';
12+
if (first[c] == -1) {
13+
first[c] = i;
14+
} else {
15+
last[c] = i;
16+
}
17+
}
18+
19+
// When a character appears twice, count all the
20+
// unique character between them.
21+
answer = 0;
22+
for (i = 0; i < 26; i++) {
23+
if (last[i] != -1) {
24+
int m[26] = {[0 ... 25] = -1};
25+
for (j = first[i] + 1; j < last[i]; j++) {
26+
int c = s[j] - 'a';
27+
if (m[c] == -1) {
28+
m[c] = j;
29+
answer++;
30+
}
31+
}
32+
}
33+
}
34+
35+
return answer;
36+
}

‎go/0008-string-to-integer.go

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
package stringtointeger
2+
3+
import (
4+
"math"
5+
"strconv"
6+
)
7+
8+
func myAtoi(s string) int {
9+
sign := 1
10+
sum := 0
11+
plusFound := false
12+
NumIntParsed := 0
13+
for _, v := range s {
14+
if s == "" {
15+
return 0
16+
}
17+
if v >= '0' && v <= '9' {
18+
NumIntParsed++
19+
n, err := strconv.ParseInt(string(v), 10, 32)
20+
if err == nil {
21+
sum = sum*10 + int(n)
22+
}
23+
// Max and Min int values
24+
if sum > math.MaxInt32 {
25+
if sign < 0 {
26+
return math.MinInt32
27+
} else {
28+
return math.MaxInt32
29+
}
30+
}
31+
// check if there is at last one int is parsed
32+
} else if sum >= 0 && NumIntParsed > 0 {
33+
return sign * sum
34+
} else {
35+
//-------------- checking for edge case ---------------
36+
// check for ++ and +- case
37+
if plusFound || sign == -1 {
38+
return 0
39+
}
40+
if v == '-' {
41+
sign = -1
42+
} else if v == '+' {
43+
plusFound = true
44+
45+
} else if v == ' ' {
46+
// to check for + serounded with spaces
47+
if plusFound {
48+
return 0
49+
}
50+
continue
51+
} else {
52+
break
53+
}
54+
}
55+
}
56+
return sign * sum
57+
}

‎java/0020-valid-parentheses.java

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,3 +22,31 @@ public boolean isValid(String s) {
2222
return stack.isEmpty();
2323
}
2424
}
25+
26+
//Solution with HashMap Lookup table as described in the video
27+
28+
class Solution {
29+
public boolean isValid(String s) {
30+
Stack<Character> brackets = new Stack<>();
31+
Map<Character, Character> bracketLookup = new HashMap<>();
32+
33+
bracketLookup.put(')', '(');
34+
bracketLookup.put('}', '{');
35+
bracketLookup.put(']', '[');
36+
37+
for (char c : s.toCharArray()) {
38+
if (bracketLookup.containsKey(c)) {
39+
if (brackets.size() != 0 && brackets.peek() == bracketLookup.get(c)) {
40+
brackets.pop();
41+
} else {
42+
return false;
43+
}
44+
} else {
45+
brackets.push(c);
46+
}
47+
}
48+
49+
if (brackets.size() == 0) return true;
50+
return false;
51+
}
52+
}

‎javascript/0347-top-k-frequent-elements.js

Lines changed: 17 additions & 181 deletions
Original file line numberDiff line numberDiff line change
@@ -1,188 +1,24 @@
11
/**
2-
* Hash Map - Frequency Counter
3-
* Matrix - Bucket
4-
* Time O(N^2) | Space O(N^2)
2+
* Set - Frequency Counter
3+
* Time O(NlogN) | Space O(N)
54
* https://leetcode.com/problems/top-k-frequent-elements/
65
* @param {number[]} nums
76
* @param {number} k
87
* @return {number[]}
98
*/
10-
var topKFrequent = (nums, k) => {
11-
const map = getFrequencyMap(nums); /* Time O(N) | Space O(N) */
12-
const bucket = getBucket(nums, map);/* Time O(N) | Space O(N^2) */
13-
14-
return getTopK(bucket, k); /* Time O(N^2) | Space O(K) */
9+
var topKFrequent = function(nums, k) {
10+
let frequency = {}
11+
for( let i = 0; i < nums.length; i++){
12+
if(frequency.hasOwnProperty(nums[i])) frequency[nums[i]] += 1;
13+
else frequency[nums[i]] = 1;
14+
}
15+
let result = Object.keys(frequency).map((key) => [Number(key), frequency[key]]);
16+
let sortedResult = result.sort((a,b) => {
17+
return b[1]-a[1]
18+
})
19+
let output = []
20+
for ( let i = 0; i < k; i++){
21+
output.push(sortedResult[i][0])
22+
}
23+
return output;
1524
};
16-
17-
var getFrequencyMap = (nums, map = new Map()) => {
18-
for (const num of nums) {/* Time O(N) */
19-
const count = (map.get(num) || 0) + 1;
20-
21-
map.set(num, count); /* Space O(N) */
22-
}
23-
24-
return map;
25-
};
26-
27-
const getBucket = (nums, map) => {
28-
const bucket = new Array(nums.length + 1).fill()
29-
.map(() => []);
30-
31-
for (const [ num, count ] of map.entries()) {/* Time O(N) */
32-
bucket[count].push(num); /* Space O(N * N) */
33-
}
34-
35-
return bucket.reverse(); /* Time O(N) */
36-
};
37-
38-
var getTopK = (bucket, k, topK = []) => {
39-
for (const count of bucket) {/* Time O(N) */
40-
for (const num of count) { /* Time O(N) */
41-
const isAtCapacity = topK.length === k;
42-
if (isAtCapacity) break;
43-
44-
topK.push(num); /* Space O(K) */
45-
}
46-
}
47-
48-
return topK;
49-
};
50-
51-
/**
52-
* Hash Map - Frequency Counter
53-
* Heap - Min Priority Queue
54-
* Time O(N * log(K)) | Space O(N + K)
55-
* https://leetcode.com/problems/top-k-frequent-elements/
56-
* @param {number[]} nums
57-
* @param {number} k
58-
* @return {number[]}
59-
*/
60-
var topKFrequent = (nums, k) => {
61-
const isAtCapacity = k === nums.length
62-
if (isAtCapacity) return nums;
63-
64-
const map = getFrequencyMap(nums); /* Time O(N) | Space O(N) */
65-
const minHeap = getMinHeap(map, k);/* Time O(N * log(K)) | Space O(K) */
66-
67-
return getTopK(minHeap, k); /* Time O(K * log(K)) | Space O(K) */
68-
}
69-
70-
71-
var getFrequencyMap = (nums, map = new Map()) => {
72-
for (const num of nums) {/* Time O(N) */
73-
const count = (map.get(num) || 0) + 1;
74-
75-
map.set(num, count);/* Space O(N) */
76-
}
77-
78-
return map;
79-
};
80-
81-
const getMinHeap = (map, k) => {
82-
const minHeap = new MinPriorityQueue({ priority: ([ num, count ]) => count });
83-
84-
for (const [ num, count ] of map.entries()) {/* Time O(N) */
85-
minHeap.enqueue([ num, count ]); /* Time O(log(K))) | Space O(K) */
86-
87-
const isOverCapacity = k < minHeap.size();
88-
if (isOverCapacity) minHeap.dequeue(); /* Time O(log(K))) */
89-
}
90-
91-
return minHeap;
92-
}
93-
94-
var getTopK = (minHeap, k, topK = []) => {
95-
while (k) {/* Time O(K) */
96-
const [ num, count ] = minHeap
97-
.dequeue().element;/* Time O(log(K))) */
98-
99-
topK.push(num); /* Space O(K) */
100-
k--;
101-
}
102-
103-
return topK
104-
}
105-
106-
/**
107-
* Hash Map - Frequency Counter
108-
* Sort - Quick Select - Average Time O(N) | Worst Time O(N^2)
109-
* Time O(N^2) | Space O(N)
110-
* https://leetcode.com/problems/top-k-frequent-elements/
111-
* @param {number[]} nums
112-
* @param {number} k
113-
* @return {number[]}
114-
*/
115-
var topKFrequent = (nums, k) => {
116-
const map = getFrequencyMap(nums); /* Time O(N) | Space O(N) */
117-
const distinctNums = [ ...map.keys() ]; /* Time O(N) | Space O(N) */
118-
const [ left, right, kSmallest ] = [ 0, (map.size - 1), (map.size - k) ];
119-
120-
quickselect(left, right, kSmallest, distinctNums, map);/* Time O(N || N^2) | Space O(log(N)) */
121-
122-
const [ start, end ] = [ kSmallest, map.size ];
123-
const topK = distinctNums.slice(start, end); /* Time O(K) | Space O(K) */
124-
125-
return topK;
126-
}
127-
128-
var getFrequencyMap = (nums, map = new Map) => {
129-
for (const num of nums) {/* Time O(N) */
130-
const count = (map.get(num) || 0) + 1;
131-
132-
map.set(num, count); /* Space O(N) */
133-
}
134-
135-
return map;
136-
};
137-
138-
const quickselect = (left, right, kSmallest, nums, map) => {
139-
const isBaseCase = left === right;
140-
if (isBaseCase) return;
141-
142-
const mid = partition(left, right, nums, map);/* Time O(N) */
143-
144-
const isTarget = mid === kSmallest;
145-
if (isTarget) return;
146-
147-
const isTargetGreater = mid < kSmallest;
148-
if (isTargetGreater) quickselect( /* Time O(N * N) | Space O(log(N)) */
149-
(mid + 1), right, kSmallest, nums, map
150-
);
151-
152-
const isTargetLess = kSmallest < mid;
153-
if (isTargetLess) quickselect( /* Time O(N * N) | Space O(log(N)) */
154-
left, (mid - 1), kSmallest, nums, map
155-
);
156-
157-
}
158-
159-
const partition = (left, right, nums, map) => {
160-
const mid = (left + right) >> 1;
161-
const guess = nums[mid];
162-
const count = map.get(guess);
163-
164-
swap(nums, mid, right);
165-
166-
const pivot = getPivot(left, right, count, nums, map);/* Time O(N) */
167-
168-
swap(nums, pivot, right);
169-
170-
return pivot;
171-
}
172-
173-
const swap = (arr, left, right) => [ arr[left], arr[right] ] = [ arr[right], arr[left] ];
174-
175-
const getPivot = (left, right, count, nums, map, pivot = left) => {
176-
for (let index = left; index <= right; index++) {/* Time O(N) */
177-
const num = nums[index];
178-
const numCount = map.get(num);
179-
180-
const canSkip = count <= numCount;
181-
if (canSkip) continue;
182-
183-
swap(nums, pivot, index);
184-
pivot++;
185-
}
186-
187-
return pivot;
188-
}

0 commit comments

Comments
 (0)