From 34508348d9dc3d6fce90136262bfb75c53dfc7e0 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:13:08 +0200 Subject: [PATCH 01/14] create 2002 in c# --- ...he-length of-2-palindromic-subsequences.cs | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) create mode 100644 csharp/2002-maximum-product-of-the-length of-2-palindromic-subsequences.cs diff --git a/csharp/2002-maximum-product-of-the-length of-2-palindromic-subsequences.cs b/csharp/2002-maximum-product-of-the-length of-2-palindromic-subsequences.cs new file mode 100644 index 000000000..12dea07e2 --- /dev/null +++ b/csharp/2002-maximum-product-of-the-length of-2-palindromic-subsequences.cs @@ -0,0 +1,50 @@ +public class Solution { + public int MaxProduct(string s) { + if(s == null || s.Length < 2) + return 0; + if(s.Length == 2) + return 1; + + int n = s.Length; + int total = 1 << n; + + List<(int, int)> possible = new List<(int, int)>(); + + for(int i = 0; i < total; i++) { + StringBuilder sb = new StringBuilder(); + + for(int j = 0; j < n; j++) { + if((i & (1 << j)) != 0) { + sb.Append(s[j]); + } + } + + if(IsPalindrome(sb.ToString())) { + possible.Add((i, sb.Length)); + } + } + + int ans = 0; + for(int i = 0; i < possible.Count; i++) { + int bitmask = possible[i].Item1; + int count = possible[i].Item2; + for(int j = i + 1; j < possible.Count; j++) { + int bitmask2 = possible[j].Item1; + int count2 = possible[j].Item2; + if((bitmask & bitmask2) == 0) + ans = Math.Max(ans, count * count2); + } + } + return ans; + } + + private bool IsPalindrome(string s){ + int i = 0; + int j = s.Length - 1; + while(i < j) { + if(s[i++] != s[j--]) + return false; + } + return true; + } +} \ No newline at end of file From 982eaa3417d5efd9ab910a35b9837531bc34faf3 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:13:24 +0200 Subject: [PATCH 02/14] create 2002 in go --- ...-length-of-two-palindromic-subsequences.go | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 go/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.go diff --git a/go/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.go b/go/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.go new file mode 100644 index 000000000..4086e0a22 --- /dev/null +++ b/go/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.go @@ -0,0 +1,46 @@ +func maxProduct(s string) (res int) { + dp := make([]int, 1< b { + return a + } + return b + } + + for m := 1; m <= mask; m++ { + dp[m] = palindromeSize(s, m) + } + + for m1 := mask; m1 > 0; m1-- { + if dp[m1]*(len(s)-dp[m1]) <= res { + continue + } + for m2 := mask ^ m1; m2 > 0; m2 = (m2 - 1) & (mask ^ m1) { + res = max(res, dp[m1]*dp[m2]) + } + } + return +} \ No newline at end of file From 4f9f2e133347c6c7e57af1bd8f0502fbfb19ea12 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:13:33 +0200 Subject: [PATCH 03/14] create 2002 in java --- ...-length of-2-palindromic-subsequences.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 java/2002-maximum-product-of-the-length of-2-palindromic-subsequences.java diff --git a/java/2002-maximum-product-of-the-length of-2-palindromic-subsequences.java b/java/2002-maximum-product-of-the-length of-2-palindromic-subsequences.java new file mode 100644 index 000000000..3c27b2387 --- /dev/null +++ b/java/2002-maximum-product-of-the-length of-2-palindromic-subsequences.java @@ -0,0 +1,27 @@ +class Solution { + public int maxProduct(String s) { + int[] dp = new int[4096]; + int res = 0, mask = (1 << s.length()) - 1; + for (int m = 1; m <= mask; ++m) + dp[m] = palSize(s, m); + for (int m1 = mask; m1 > 0; --m1) + if (dp[m1] * (s.length() - dp[m1]) > res) + for(int m2 = mask ^ m1; m2 > 0; m2 = (m2 - 1) & (mask ^ m1)) + res = Math.max(res, dp[m1] * dp[m2]); + return res; +} +private int palSize(String s, int mask) { + int p1 = 0, p2 = s.length(), res = 0; + while (p1 <= p2) { + if ((mask & (1 << p1)) == 0) + ++p1; + else if ((mask & (1 << p2)) == 0) + --p2; + else if (s.charAt(p1) != s.charAt(p2)) + return 0; + else + res += 1 + (p1++ != p2-- ? 1 : 0); + } + return res; +} +} \ No newline at end of file From 6aa720b17e594d3c3033316cc0496a91d56449e3 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:13:50 +0200 Subject: [PATCH 04/14] create 2002 in js,ts --- ...he-length of-2-palindromic-subsequences.js | 51 +++++++++++++++++++ ...he-length of-2-palindromic-subsequences.ts | 47 +++++++++++++++++ 2 files changed, 98 insertions(+) create mode 100644 javascript/2002-maximum-product-of-the-length of-2-palindromic-subsequences.js create mode 100644 kotlin/2002-maximum-product-of-the-length of-2-palindromic-subsequences.ts diff --git a/javascript/2002-maximum-product-of-the-length of-2-palindromic-subsequences.js b/javascript/2002-maximum-product-of-the-length of-2-palindromic-subsequences.js new file mode 100644 index 000000000..a498c0528 --- /dev/null +++ b/javascript/2002-maximum-product-of-the-length of-2-palindromic-subsequences.js @@ -0,0 +1,51 @@ +/** + * @param {string} s + * @return {number} + * Time Complexity: O(2^N) + * Space Complexity: O(2^N) + */ +var maxProduct = function (s) { + const N = s.length; + const first = new Array(1 << N).fill(0), + last = new Array(1 << N).fill(0); + for (let i = 0; i < N; i++) { + for (let j = 1 << i; j < 1 << (i + 1); j++) { + first[j] = i; + } + } + for (let i = 0; i < N; i++) { + for (let j = 1 << i; j < 1 << N; j += 1 << (i + 1)) { + last[j] = i; + } + } + const dp = Memo((m) => { + if ((m & (m - 1)) === 0) { + return m != 0; + } + const l = last[m], + f = first[m]; + const lb = 1 << l, + fb = 1 << f; + return Math.max( + dp(m - lb), + dp(m - fb), + dp(m - lb - fb) + (s[l] == s[f]) * 2 + ); + }); + let ans = 0; + for (let m = 1; m < 1 << N; m++) { + ans = Math.max(ans, dp(m) * dp((1 << N) - 1 - m)); + } + return ans; +}; + +var Memo = (func) => { + const map = new Map(); + var wrapper = (m) => { + if (!map.get(m)) { + map.set(m, func(m)); + } + return map.get(m); + }; + return wrapper; +}; diff --git a/kotlin/2002-maximum-product-of-the-length of-2-palindromic-subsequences.ts b/kotlin/2002-maximum-product-of-the-length of-2-palindromic-subsequences.ts new file mode 100644 index 000000000..9fb2b6e41 --- /dev/null +++ b/kotlin/2002-maximum-product-of-the-length of-2-palindromic-subsequences.ts @@ -0,0 +1,47 @@ +/** + * Time Complexity: O(2^N) + * Space Complexity: O(2^N) + */ +function maxProduct(s: string): number { + const N = s.length; + const first: number[] = new Array(1 << N).fill(0), + last: number[] = new Array(1 << N).fill(0); + for (let i = 0; i < N; i++) { + for (let j = 1 << i; j < 1 << (i + 1); j++) { + first[j] = i; + } + } + for (let i = 0; i < N; i++) { + for (let j = 1 << i; j < 1 << N; j += 1 << (i + 1)) { + last[j] = i; + } + } + const dp = cache((m: number) => { + if ((m & (m - 1)) === 0) { + return m != 0; + } + const l = last[m], f = first[m]; + const lb = 1 << l, fb = 1 << f; + return Math.max( + dp(m - lb), + dp(m - fb), + dp(m - lb - fb) + Number(s[l] === s[f]) * 2 + ); + }); + let ans = 0; + for (let m = 1; m < 1 << N; m++) { + ans = Math.max(ans, dp(m) * dp((1 << N) - 1 - m)); + } + return ans; +}; + +function cache(func:Function){ + const map = new Map(); + var wrapper = (m:number) => { + if (!map.get(m)) { + map.set(m, func(m)); + } + return map.get(m); + }; + return wrapper; +}; From c3d5f614a9ee8f62e679cb63ad911b2b88540330 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:14:04 +0200 Subject: [PATCH 05/14] create 2002 in py --- ...he-length of-2-palindromic-subsequences.py | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 python/2002-maximum-product-of-the-length of-2-palindromic-subsequences.py diff --git a/python/2002-maximum-product-of-the-length of-2-palindromic-subsequences.py b/python/2002-maximum-product-of-the-length of-2-palindromic-subsequences.py new file mode 100644 index 000000000..8d415db6d --- /dev/null +++ b/python/2002-maximum-product-of-the-length of-2-palindromic-subsequences.py @@ -0,0 +1,30 @@ +""" +Time Complexity: O(2^N) +Space Complexity: O(2^N) +""" +class Solution: + def maxProduct(self, s): + n = len(s) + + first, last = [0]*(1< Date: Sat, 4 Mar 2023 23:14:15 +0200 Subject: [PATCH 06/14] create 2002 in rust --- ...-length-of-two-palindromic-subsequences.rs | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 rust/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.rs diff --git a/rust/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.rs b/rust/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.rs new file mode 100644 index 000000000..9f3cbc180 --- /dev/null +++ b/rust/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.rs @@ -0,0 +1,55 @@ +impl Solution { + pub fn max_product(s: String) -> i32 { + let s: Vec = s.chars().collect(); + let mut s1 = vec![]; + let mut s2 = vec![]; + let mut res = 0; + + Solution::dfs(&s, &mut s1, &mut s2, &mut res, 0); + + res + } + + fn dfs(s: &[char], s1: &mut Vec, s2: &mut Vec, res: &mut i32, index: usize) { + // Base case + if index == s.len() { + if Solution::is_palindrome(s1) && Solution::is_palindrome(s2) { + let new_max = s1.len() * s2.len(); + *res = std::cmp::max(*res, new_max as i32); + } + return; + } + + // Option 0: Not in S1 nor S2 + Solution::dfs(s, s1, s2, res, index + 1); + + // Option 1: in S1 + s1.push(s[index]); + Solution::dfs(s, s1, s2, res, index + 1); + s1.pop(); + + // Option 2: in S2 + s2.push(s[index]); + Solution::dfs(s, s1, s2, res, index + 1); + s2.pop(); + } + + fn is_palindrome(s: &[char]) -> bool { + if s.len() <= 1 { + return true; + } + + let mut l = 0; + let mut r = s.len() - 1; + + while l < r { + if s[l] != s[r] { + return false; + } + l += 1; + r -= 1; + } + + true + } +} \ No newline at end of file From 1c065e89f6a93832ea73ba17b4b06d888e6abf35 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:17:10 +0200 Subject: [PATCH 07/14] create 0179 in c & c# --- c/0179-largest-number.c | 78 +++++++++++++++++++++++++++++++++++ csharp/0179-largest-number.cs | 12 ++++++ 2 files changed, 90 insertions(+) create mode 100644 c/0179-largest-number.c create mode 100644 csharp/0179-largest-number.cs diff --git a/c/0179-largest-number.c b/c/0179-largest-number.c new file mode 100644 index 000000000..66ec0080d --- /dev/null +++ b/c/0179-largest-number.c @@ -0,0 +1,78 @@ +int cmp(const void *a, const void *b) +{ + int ele1 = *(int *)a, ele2 = *(int *)b, d1 = 0, d2 = 0; + + if (!ele1 && !ele2) + return 0; // deal with zero, return 0 means don't care the order + + while (ele1) + { + ele1 /= 10; + d1++; + } + + while (ele2) + { + ele2 /= 10; + d2++; + } + + char *e1 = calloc(d1 + 1, sizeof(char)), *e2 = calloc(d2 + 1, sizeof(char)); + snprintf(e1, d1 + 1, "%d", *(int *)a); + snprintf(e2, d2 + 1, "%d", *(int *)b); + + char *p1 = e1, *p2 = e2; + while (*p1 == *p2 && (*(p1 + 1) != '\0' || *(p2 + 1) != '\0')) + { + if (*(p1 + 1) == '\0') + { + p1 = e1; + } + else + p1 = p1 + 1; // next element + + if (*(p2 + 1) == '\0') + { + p2 = e2; + } + else + { + p2 = p2 + 1; + } + } + return *p2 - *p1; // return positive means the first argument is behind the second argument, otherwise the second argument is behind the first argument +} + +char *largestNumber(int *nums, int numsSize) +{ + qsort(nums, numsSize, sizeof(int), cmp); + + bool allZero = true; // check if all elements are zero + int dig = 0; // count the digits of number + + for (int i = 0; i < numsSize; i++) + { + if (nums[i] != 0) + allZero = false; + int e = nums[i]; + if (e == 0) + dig++; // deal with 0 element + while (e) + { + e /= 10; + dig++; + } + } + + if (allZero) + return "0"; + + char *ans = (char *)calloc(dig + 1, sizeof(char)); + + for (int i = 0; i < numsSize; i++) + { + snprintf(ans + strlen(ans), dig + 1 - strlen(ans), "%d", nums[i]); + } + + return ans; +} \ No newline at end of file diff --git a/csharp/0179-largest-number.cs b/csharp/0179-largest-number.cs new file mode 100644 index 000000000..031e71538 --- /dev/null +++ b/csharp/0179-largest-number.cs @@ -0,0 +1,12 @@ +public class Solution { + public string LargestNumber(int[] nums) + { + if(nums.All(_ => _ == 0)) return "0"; + + var s = nums.Select(_ => _.ToString()).ToList(); + + s.Sort((a, b) => (b+a).CompareTo(a+b)); + + return string.Concat(s); + } +} \ No newline at end of file From 88ceee73e9a3ccedfcfa0ff8d36066877dfb727d Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:17:39 +0200 Subject: [PATCH 08/14] create 0179 in go, js, ruby --- go/0179-largest-number.go | 8 ++++++++ javascript/0179-largest.number.js | 11 +++++++++++ ruby/0179-largest-number.rb | 5 +++++ 3 files changed, 24 insertions(+) create mode 100644 go/0179-largest-number.go create mode 100644 javascript/0179-largest.number.js create mode 100644 ruby/0179-largest-number.rb diff --git a/go/0179-largest-number.go b/go/0179-largest-number.go new file mode 100644 index 000000000..4e9a97d88 --- /dev/null +++ b/go/0179-largest-number.go @@ -0,0 +1,8 @@ +func largestNumber(nums []int) string { + ans, s := "", make([]string, len(nums)) + for i, num := range nums { s[i] = strconv.Itoa(num) } + sort.Slice(s, func(a, b int) bool { return s[a] + s[b] > s[b] + s[a] }) + if s[0] == "0" { return "0" } + for _, v := range s { ans += v } + return ans +} \ No newline at end of file diff --git a/javascript/0179-largest.number.js b/javascript/0179-largest.number.js new file mode 100644 index 000000000..96eaa3da9 --- /dev/null +++ b/javascript/0179-largest.number.js @@ -0,0 +1,11 @@ +/** + * @param {number[]} nums + * @return {string} + */ +var largestNumber = function (nums) { + let largest = nums + .map((n) => n.toString()) + .sort((x, y) => y + x - (x + y)) + .join(''); + return largest[0] === '0' ? '0' : largest; +}; diff --git a/ruby/0179-largest-number.rb b/ruby/0179-largest-number.rb new file mode 100644 index 000000000..6137e6ee4 --- /dev/null +++ b/ruby/0179-largest-number.rb @@ -0,0 +1,5 @@ +# @param {Integer[]} nums +# @return {String} +def largest_number(nums) + nums.sort! {|a, b| b.to_s + a.to_s <=> a.to_s + b.to_s}.join.to_i.to_s +end \ No newline at end of file From 1fa3fd392a3968936ebf7e436c60a82b1d1914e1 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:18:08 +0200 Subject: [PATCH 09/14] create 0179 in rust ,scala, swift --- rust/0179-largest-number.rs | 11 +++++++++++ scala/0179-largest-number.scala | 5 +++++ swift/0179-largest-number.swift | 5 +++++ 3 files changed, 21 insertions(+) create mode 100644 rust/0179-largest-number.rs create mode 100644 scala/0179-largest-number.scala create mode 100644 swift/0179-largest-number.swift diff --git a/rust/0179-largest-number.rs b/rust/0179-largest-number.rs new file mode 100644 index 000000000..d25c1f1a5 --- /dev/null +++ b/rust/0179-largest-number.rs @@ -0,0 +1,11 @@ +impl Solution { + pub fn largest_number(nums: Vec) -> String { + let mut v: Vec = nums.iter().map(|&num| num.to_string()).collect(); + v.sort_by(|a: &String, b: &String| (b.clone() + a).cmp(&(a.clone() + b))); + if v[0] == "0" { + String::from("0") + } else { + v.join("") + } + } +} \ No newline at end of file diff --git a/scala/0179-largest-number.scala b/scala/0179-largest-number.scala new file mode 100644 index 000000000..687270068 --- /dev/null +++ b/scala/0179-largest-number.scala @@ -0,0 +1,5 @@ +object Solution { + def largestNumber(nums: Array[Int]): String = { + BigInt(nums.map(_.toString).sortWith((l, r) => l ++ r >= r ++ l).foldLeft("")(_ + _)).toString + } +} \ No newline at end of file diff --git a/swift/0179-largest-number.swift b/swift/0179-largest-number.swift new file mode 100644 index 000000000..99ddaf68d --- /dev/null +++ b/swift/0179-largest-number.swift @@ -0,0 +1,5 @@ +class Solution { + func largestNumber(_ nums: [Int]) -> String { + return nums.reduce(into: Bool(false), { $0 = $0 || $1 > 0 }) ? nums.map { String($0) }.sorted { $0 + $1 > $1 + $0 }.joined() : "0" + } +} \ No newline at end of file From 7c309f06324f56f1530e163d4f76348fbfd80ca3 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:21:22 +0200 Subject: [PATCH 10/14] remove 0179 in c --- c/0179-largest-number.c | 78 ----------------------------------------- 1 file changed, 78 deletions(-) delete mode 100644 c/0179-largest-number.c diff --git a/c/0179-largest-number.c b/c/0179-largest-number.c deleted file mode 100644 index 66ec0080d..000000000 --- a/c/0179-largest-number.c +++ /dev/null @@ -1,78 +0,0 @@ -int cmp(const void *a, const void *b) -{ - int ele1 = *(int *)a, ele2 = *(int *)b, d1 = 0, d2 = 0; - - if (!ele1 && !ele2) - return 0; // deal with zero, return 0 means don't care the order - - while (ele1) - { - ele1 /= 10; - d1++; - } - - while (ele2) - { - ele2 /= 10; - d2++; - } - - char *e1 = calloc(d1 + 1, sizeof(char)), *e2 = calloc(d2 + 1, sizeof(char)); - snprintf(e1, d1 + 1, "%d", *(int *)a); - snprintf(e2, d2 + 1, "%d", *(int *)b); - - char *p1 = e1, *p2 = e2; - while (*p1 == *p2 && (*(p1 + 1) != '\0' || *(p2 + 1) != '\0')) - { - if (*(p1 + 1) == '\0') - { - p1 = e1; - } - else - p1 = p1 + 1; // next element - - if (*(p2 + 1) == '\0') - { - p2 = e2; - } - else - { - p2 = p2 + 1; - } - } - return *p2 - *p1; // return positive means the first argument is behind the second argument, otherwise the second argument is behind the first argument -} - -char *largestNumber(int *nums, int numsSize) -{ - qsort(nums, numsSize, sizeof(int), cmp); - - bool allZero = true; // check if all elements are zero - int dig = 0; // count the digits of number - - for (int i = 0; i < numsSize; i++) - { - if (nums[i] != 0) - allZero = false; - int e = nums[i]; - if (e == 0) - dig++; // deal with 0 element - while (e) - { - e /= 10; - dig++; - } - } - - if (allZero) - return "0"; - - char *ans = (char *)calloc(dig + 1, sizeof(char)); - - for (int i = 0; i < numsSize; i++) - { - snprintf(ans + strlen(ans), dig + 1 - strlen(ans), "%d", nums[i]); - } - - return ans; -} \ No newline at end of file From 8bfb0b6372e374486960bbbf4782c528763ce595 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:33:32 +0200 Subject: [PATCH 11/14] create 0706 in js --- javascript/0706-design-hashmap.js | 37 +++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 javascript/0706-design-hashmap.js diff --git a/javascript/0706-design-hashmap.js b/javascript/0706-design-hashmap.js new file mode 100644 index 000000000..162c9a8a0 --- /dev/null +++ b/javascript/0706-design-hashmap.js @@ -0,0 +1,37 @@ +var MyHashMap = function () { + this.map = new Map(); +}; + +/** + * @param {number} key + * @param {number} value + * @return {void} + */ +MyHashMap.prototype.put = function (key, value) { + this.map.set(key, value); +}; + +/** + * @param {number} key + * @return {number} + */ +MyHashMap.prototype.get = function (key) { + const val = this.map.get(key); + return val !== undefined ? val : -1; +}; + +/** + * @param {number} key + * @return {void} + */ +MyHashMap.prototype.remove = function (key) { + this.map.delete(key); +}; + +/** + * Your MyHashMap object will be instantiated and called as such: + * var obj = new MyHashMap() + * obj.put(key,value) + * var param_2 = obj.get(key) + * obj.remove(key) + */ From 191c85a3fefff1b381d8414986dc9e7abfabefde Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:39:00 +0200 Subject: [PATCH 12/14] create 0706 in java --- java/0706-design-hashmap.java | 44 +++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 java/0706-design-hashmap.java diff --git a/java/0706-design-hashmap.java b/java/0706-design-hashmap.java new file mode 100644 index 000000000..f068c28c2 --- /dev/null +++ b/java/0706-design-hashmap.java @@ -0,0 +1,44 @@ +class ListNode { + int key, val; + ListNode next; + public ListNode(int key, int val, ListNode next) { + this.key = key; + this.val = val; + this.next = next; + } +} +class MyHashMap { + static final int size = 19997; + static final int mult = 12582917; + ListNode[] data; + public MyHashMap() { + this.data = new ListNode[size]; + } + private int hash(int key) { + return (int)((long)key * mult % size); + } + public void put(int key, int val) { + remove(key); + int h = hash(key); + ListNode node = new ListNode(key, val, data[h]); + data[h] = node; + } + public int get(int key) { + int h = hash(key); + ListNode node = data[h]; + for (; node != null; node = node.next) + if (node.key == key) return node.val; + return -1; + } + public void remove(int key) { + int h = hash(key); + ListNode node = data[h]; + if (node == null) return; + if (node.key == key) data[h] = node.next; + else for (; node.next != null; node = node.next) + if (node.next.key == key) { + node.next = node.next.next; + return; + } + } +} \ No newline at end of file From 913a3aca3a27b3c9118edf47b4c9935835d40db9 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sat, 4 Mar 2023 23:57:15 +0200 Subject: [PATCH 13/14] create 0706 in rust --- rust/0706-design-hashmap.rs | 45 +++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 rust/0706-design-hashmap.rs diff --git a/rust/0706-design-hashmap.rs b/rust/0706-design-hashmap.rs new file mode 100644 index 000000000..07ecd58e4 --- /dev/null +++ b/rust/0706-design-hashmap.rs @@ -0,0 +1,45 @@ +struct MyHashMap { + buckets: Vec>, +} + +// Prime number of buckets to reduce collisions +const N_BUCKETS: usize = 1031; + +impl MyHashMap { + + fn new() -> Self { + Self{ buckets: vec![vec![]; N_BUCKETS] } + } + + fn hash(key: i32) -> usize { + key as usize % N_BUCKETS + } + + fn find_entry(&mut self, key: i32) -> (&mut Vec<(i32, i32)>, Result) { + let bucket = &mut self.buckets[Self::hash(key)]; + let result = bucket.binary_search_by(|(k, v)| k.cmp(&key)); + (bucket, result) + } + + fn put(&mut self, key: i32, value: i32) { + match self.find_entry(key) { + (bucket, Ok(index)) => bucket[index] = (key, value), + (bucket, Err(index)) => bucket.insert(index, (key, value)), + } + } + + fn get(&self, key: i32) -> i32 { + let bucket = &self.buckets[Self::hash(key)]; + match bucket.binary_search_by(|(k, v)| k.cmp(&key)) { + Ok(index) => bucket[index].1, + Err(index) => -1, + } + } + + fn remove(&mut self, key: i32) { + match self.find_entry(key) { + (bucket, Ok(index)) => { bucket.remove(index); }, + _ => (), + } + } +} \ No newline at end of file From 1ca3bc959fbc4b33a73fd00b77c74fe712c0dc79 Mon Sep 17 00:00:00 2001 From: Mohamed Date: Sun, 7 May 2023 21:58:39 +0300 Subject: [PATCH 14/14] move 2002.ts from kt folder to ts folder --- ...maximum-product-of-the-length of-2-palindromic-subsequences.ts | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {kotlin => typescript}/2002-maximum-product-of-the-length of-2-palindromic-subsequences.ts (100%) diff --git a/kotlin/2002-maximum-product-of-the-length of-2-palindromic-subsequences.ts b/typescript/2002-maximum-product-of-the-length of-2-palindromic-subsequences.ts similarity index 100% rename from kotlin/2002-maximum-product-of-the-length of-2-palindromic-subsequences.ts rename to typescript/2002-maximum-product-of-the-length of-2-palindromic-subsequences.ts