From 0fa4bbc5c56e6bab082214db83dbeff3456b6241 Mon Sep 17 00:00:00 2001 From: Jeehay28 Date: Mon, 19 May 2025 15:23:58 +0900 Subject: [PATCH 1/3] Add reverse-bits solution in TS --- reverse-bits/Jeehay28.ts | 70 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 reverse-bits/Jeehay28.ts diff --git a/reverse-bits/Jeehay28.ts b/reverse-bits/Jeehay28.ts new file mode 100644 index 000000000..970637212 --- /dev/null +++ b/reverse-bits/Jeehay28.ts @@ -0,0 +1,70 @@ +// TC: O(1) +// SC: O(1) +function reverseBits(n: number): number { + let stack: number[] = []; + + while (stack.length < 32) { + stack.push(n % 2); + n = Math.floor(n / 2); + } + + let output: number = 0; + let scale: number = 1; + + while (stack.length > 0) { + output += stack.pop()! * scale; + scale *= 2; + } + + return output; +} + +// TC: O(1) +// SC: O(1) +/* +function reverseBits(n: number): number { + let result = 0; + + for (let i = 0; i < 32; i++) { + let bit = n & 1; + result = (result << 1) | bit; + n = n >>> 1; + } + + return result >>> 0; +} +*/ + +/* +n & 1 +- get last bit +- equivalent to n % 2 for non-negative integer + +n << 1 +- left shift (multiply by 2) + +n >>> 1 +- Unsigned right shift (divide by 2) +- ignores sign + +n >>> 0 +- no shift, just cast to unsigned + +const signed = -1; // Binary: 11111111111111111111111111111111 +const unsigned = signed >>> 0; // 4294967295 + +JavaScript/TypeScript only has one number type — a 64-bit float. itwise operations use 32-bit signed integers. + To return a 32-bit unsigned integer, use >>> 0 on the result. + + 🔧 Bitwise Operations in JavaScript — Summary + 1. Bitwise operations in JavaScript (&, |, ^, ~, <<, >>, >>>) are always performed on 32-bit signed integers. + + 2. Internally: + - JavaScript converts your number into a 32-bit signed integer + - Performs the bitwise operation + - Then converts it back into a regular 64-bit number (JavaScript's only number type) + + 3. If you need the result as a 32-bit unsigned integer (like for LeetCode problems dealing with uint32): + - Use >>> 0 at the end of your result + - This forces the result to be treated as an unsigned 32-bit integer +*/ From 4b08997045e859cb438958e7cf52b3e0f477eaf5 Mon Sep 17 00:00:00 2001 From: Jeehay28 Date: Tue, 20 May 2025 13:56:50 +0900 Subject: [PATCH 2/3] Add longest-repeating-character-replacement solution in TS --- .../Jeehay28.ts | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 longest-repeating-character-replacement/Jeehay28.ts diff --git a/longest-repeating-character-replacement/Jeehay28.ts b/longest-repeating-character-replacement/Jeehay28.ts new file mode 100644 index 000000000..13c81ac6f --- /dev/null +++ b/longest-repeating-character-replacement/Jeehay28.ts @@ -0,0 +1,27 @@ +// TC: O(n) +// SC: O(1) +function characterReplacement(s: string, k: number): number { + const freqMap = new Map(); + let left = 0; + let maxFreqCnt = 0; + let result = 0; + + for (let right = 0; right < s.length; right++) { + const ch = s[right]; + freqMap.set(ch, (freqMap.get(ch)! | 0) + 1); + maxFreqCnt = Math.max(maxFreqCnt, freqMap.get(ch)!); + + while (right - left + 1 - maxFreqCnt > k) { + // Shrink the sliding window by moving the left pointer to the right. + // As we move left, decrease the frequency count of the character being excluded from the window. + const ch = s[left]; + freqMap.set(ch, freqMap.get(ch)! - 1); + left++; + } + + result = Math.max(result, right - left + 1); + } + + return result; +} + From 55568752a576ce3387460f572ffacb85993908d4 Mon Sep 17 00:00:00 2001 From: Jeehay28 Date: Wed, 21 May 2025 15:41:03 +0900 Subject: [PATCH 3/3] Add clone-graph solution in TS --- clone-graph/Jeehay28.ts | 67 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 clone-graph/Jeehay28.ts diff --git a/clone-graph/Jeehay28.ts b/clone-graph/Jeehay28.ts new file mode 100644 index 000000000..166916026 --- /dev/null +++ b/clone-graph/Jeehay28.ts @@ -0,0 +1,67 @@ +class _Node { + val: number; + neighbors: _Node[]; + + constructor(val?: number, neighbors?: _Node[]) { + this.val = val === undefined ? 0 : val; + this.neighbors = neighbors === undefined ? [] : neighbors; + } +} + +// TC: O(V + E), where V is the number of vertices and E is the number of edges +// SC: O(V + E) +function cloneGraph(node: _Node | null): _Node | null { + // 1: [2, 4] + // 2: [1, 3] + // 3: [2, 4] + // 4: [1, 3] + + const clones = new Map<_Node, _Node>(); + // original Node: cloned Node + + if (!node) return null; + + const dfs = (node: _Node) => { + if (clones.has(node)) { + return clones.get(node); + } + + const clone = new _Node(node.val); + clones.set(node, clone); + + for (const nei of node.neighbors) { + clone.neighbors.push(dfs(nei)!); + } + + return clone; + }; + + return dfs(node)!; +} + + +// TC: O(V + E) +// SC: O(V + E) +// function cloneGraph(node: _Node | null): _Node | null { +// if (!node) return null; + +// const clone: _Node = new _Node(node.val); +// const clones = new Map<_Node, _Node>(); +// clones.set(node, clone); +// const queue: _Node[] = [node]; // BFS -> use queue + +// while (queue.length > 0) { +// const node = queue.shift()!; +// for (const nei of node.neighbors) { +// if (!clones.has(nei)) { +// clones.set(nei, new _Node(nei.val)); +// queue.push(nei); +// } +// clones.get(node)!.neighbors.push(clones.get(nei)!); +// } +// } + +// return clone; +// } + +