ADHOC: More solutions (#194)

Author: retiman

src/array/maximum-swap.ts

@@ -0,0 +1,75 @@
+// DIFFICULTY: MEDIUM
+//
+// You are given an integer num. You can swap two digits at most once to get the maximum valued number.
+//
+// Return the maximum valued number you can get.
+//
+// See {@link https://leetcode.com/problems/maximum-swap/}
+export { maximumSwap };
+
+// SOLUTION:
+//
+// The simple idea of swapping the largest number with the first digit doesn't always work.  It works a lot of the time,
+// but a couple of cases mess up this algorithm:
+//
+// - 98368 would stay 98368; we need to swap the 3 and 8 to get 98863.
+// - 1993 could become 9193, but we need to swap the 1 and other 9 to get 9913.
+//
+// The way to think about this is:
+//
+// 1. Find the FIRST digit that can be made bigger (larger digits appear later).
+// 2. Swap it with the LAST occurrence of the largest digit.
+//
+// COMPLEXITY:
+//
+// The time complexity is O(n) where n is the number of digits.  We iterate through the digits once to create our array
+// and map.  We iterate through the digits a second time to find the swap point.  There is a nested loop, but the inner
+// loop is bounded by the 10 digits, so it doesn't cause O(n^2) time complexity.
+//
+// The space complexity is O(n) because we store an array and map of the digits.
+function maximumSwap(num: number): number {
+  // First convert the number to an array of digits.
+  const digits = num.toString().split('').map(Number);
+
+  // Create a map of the last seen index of each digit.  Use this to find out the last occurrence of any digit.
+  type Digit = number;
+  type LastSeen = number;
+  const map = new Map<Digit, LastSeen>();
+  for (let i = 0; i < digits.length; i++) {
+    const digit = digits[i];
+    map.set(digit, i);
+  }
+
+  // Find the first digit that can be made bigger by iterating through the digits list.
+  for (let i = 0; i < digits.length; i++) {
+    const smaller = digits[i];
+
+    // Find a larger digit to swap the smaller digit with.  To do so, start at 9 and iterate downwards until we find a
+    // digit that is larger, and appears later in the number.
+    for (let larger = 9; larger >= 0; larger--) {
+      // Skip the digit if it's not larger.
+      if (larger <= smaller) {
+        break;
+      }
+
+      // Skip the digit if it doesn't appear at all.
+      if (!map.has(larger)) {
+        continue;
+      }
+
+      // Skip the digit if it appears before the smaller digit.
+      const j = map.get(larger)!;
+      if (j <= i) {
+        continue;
+      }
+
+      // Success!  We have found the largest digit that occurs as late as possible!  Swap the digits and return the
+      // number.
+      [digits[i], digits[j]] = [digits[j], digits[i]];
+      return Number(digits.join(''));
+    }
+  }
+
+  // We made no swaps, so just return the number as is.
+  return num;
+}

src/prefix-sum/continuous-subarray-sum.ts

@@ -0,0 +1,95 @@
+// DIFFICULTY: MEDIUM
+//
+// Given an integer array nums and an integer k, return true if nums has a good subarray or false otherwise.
+//
+// A good subarray is a subarray where:
+//
+// - its length is at least two, and
+// - the sum of the elements of the subarray is a multiple of k.
+//
+// Note that:
+//
+// - A subarray is a contiguous part of the array.
+// - An integer x is a multiple of k if there exists an integer n such that x = n * k. 0 is always a multiple of k.
+//
+// See {@link https://leetcode.com/problems/continuous-subarray-sum/}
+export { checkSubarraySum };
+
+// SOLUTION:
+//
+// The brute force solution is to calculate the sum of all subarrays of length 2 or more and check if it's a multiple of
+// of k.  To do so, compute the prefix sum of the array and use it to calculate the sum of the subarray from [i, j].
+//
+// A subarray sum from [i, j] can be calculated as prefixSum[j] - prefixSum[i] + nums[i].  We can check each subarray
+// sum to see if it's a multiple of k and return true if we find one.  It is; however, O(n^2) to calculate subarray
+// sums in this way.  Unfortunately, this will exceed the runtime limit for large arrays in LeetCode.
+//
+// To get a better solution we have to note that:
+//
+// sum[i, j] = prefixSum[j] - prefixSum[i] + nums[i]
+// sum[i, j] = prefixSum[j] - prefixSum[i - 1]
+//
+// This is because the sum[i, j] is inclusive, and subtracting prefixSum[i] subtracts out nums[i].  That's why we either
+// have to add it back in or use i - 1 as the index instead.  Afterwards, we can look at the sum modulo k:
+//
+// sum[i, j] (mod k) = (prefixSum[j] - prefixSum[i - 1]) (mod k)
+//
+// If we want sum[i, j] % k === 0, then we should write:
+//
+// (prefixSum[j] - prefixSum[i - 1]) (mod k) = 0
+// prefixSum[j] (mod k) = prefixSum[i - 1] (mod k)
+//
+// In other words, if prefixSums at positions (i - 1) and j have the same remainder modulo k, then the subarray sum from
+// [i, j] has remainder 0 modulo k.
+//
+// COMPLEXITY:
+//
+// Time complexity is O(n^2) because we are doing an outer and inner loop on the prefix sum array.
+//
+// Space complexity is O(n) because we are storing the prefix sum array.
+function checkSubarraySum(nums: number[], k: number): boolean {
+  // Use a map of remainders to positions to store the prefix sum remainders, so we can check later if we have seen any
+  // remainders that are the same modulo k.
+  type Remainder = number;
+  type Index = number;
+  const remainders = new Map<Remainder, Index>();
+
+  // Maintain a running prefix sum as we loop through the array.
+  let prefixSum = 0;
+  for (let i = 0; i < nums.length; i++) {
+    prefixSum += nums[i];
+    let remainder = prefixSum % k;
+
+    // It might be the case that the remainder is negative, just as a quirk of how JavaScript handles the modulo
+    // operator.
+    //
+    // For example, -5 % 3 = -2.  But this is wrong because -2 is not congruent to -5 modulo 3.  Instead:
+    //
+    // -5 (mod 3) = -5 + 3 (mod 3) = -2 (mod 3) = -2 + 3 (mod 3) = 1 (mod 3)
+    //
+    // That is, we want -5 % 3 = 1 instead.  To fix this, we half to add the modulus to the remainder if it's negative.
+    if (remainder < 0) {
+      remainder += k;
+    }
+
+    // It's possible that the prefix sum already is a multiple of k.  And it's possible that the remainder 0 isn't in
+    // the remainders map yet.  In this case, just check if we have a subarray of length 2 or more.
+    if (remainder === 0 && i >= 1) {
+      return true;
+    }
+
+    // If this is a previously seen remainder, we can check if we have a "good" subarray.
+    if (remainders.has(remainder)) {
+      const j = remainders.get(remainder)!;
+      if (Math.abs(i - j) >= 2) {
+        return true;
+      }
+    }
+    // If we're seeing this remainder for the first time, store it in the map.
+    else {
+      remainders.set(remainder, i);
+    }
+  }
+
+  return false;
+}

src/string/longest-palindromic-substring.ts

@@ -0,0 +1,81 @@
+// DIFFICULTY: MEDIUM
+//
+// Given a string s, return the longest palindromic substring in s.
+//
+// See {@link https://leetcode.com/problems/longest-palindromic-substring/}
+export { longestPalindrome };
+
+// SOLUTION:
+//
+// The naive solution is to iterate through each character, then treat that character as the center of a palindrome,
+// expanding outwards to check if the characters match.
+//
+// Note that for each character, we have to do two checks:
+//
+// 1. Check if there's a palindrome centered at i, for odd length palindromes.
+// 2. Check if there's a palindrome centered at i and i + 1, for even length palindromes.
+//
+// There is a dynamic programming solution that can solve this problem in O(n^2) time and O(n^2) space.
+//
+// There is a more sophisticated algorithm called Manacher's algorithm that can solve this problem in O(n) time, but
+// it's pretty complicated.
+//
+// COMPLEXITY:
+//
+// Each checkPalindrome() call is O(n) where n is the length of the string.  We call this function twice for each
+// character in the string, so the total time complexity is O(n^2).
+//
+// The space complexity is O(1) because we only use a constant amount of space.
+function longestPalindrome(s: string): string {
+  let start = 0;
+  let maxLength = 0;
+
+  function checkPalindrome(left: number, right: number) {
+    let matched = false;
+
+    // Expand the left and right pointers outwards from the center.
+    while (left >= 0 && right < s.length) {
+      // If the characters match, expand the pointers.
+      if (s[left] === s[right]) {
+        left--;
+        right++;
+        matched = true;
+      }
+      // Otherwise, break out of the loop.
+      else {
+        break;
+      }
+    }
+
+    // If we didn't match any characters, then there's no need to update the length of the longest palindrome.
+    if (!matched) {
+      return;
+    }
+
+    // When the while loop ends, s[left] !== s[right], which means they don't match.  Adjust them back to a valid
+    // position.  If they didn't match, then there's no need to
+    left++;
+    right--;
+
+    // The length of the palindrome we have is bounded by [left, right] inclusive.  To get the length of this range,
+    // we need to do right - left + 1.
+    const length = right - left + 1;
+    if (right - left + 1 > maxLength) {
+      start = left;
+      maxLength = length;
+    }
+  }
+
+  if (s.length === 0) {
+    return '';
+  }
+
+  for (let i = 0; i < s.length; i++) {
+    // Check if there's a palindrome centered at i.
+    checkPalindrome(i, i);
+    // Check if there's a palindrome centered at i and i + 1.
+    checkPalindrome(i, i + 1); // Even-length palindrome
+  }
+
+  return s.substring(start, start + maxLength);
+}

test/array/maximum-swap.test.ts

@@ -0,0 +1,15 @@
+import { maximumSwap } from '../../src/array/maximum-swap';
+
+describe('maximum swap', () => {
+  test('maximumSwap - test case 1', () => {
+    expect(maximumSwap(2736)).toEqual(7236);
+  });
+
+  test('maximumSwap - test case 2', () => {
+    expect(maximumSwap(1993)).toEqual(9913);
+  });
+
+  test('maximumSwap - test case 1', () => {
+    expect(maximumSwap(98368)).toEqual(98863);
+  });
+});

test/prefix-sum/continuous-subarray-sum.test.ts

@@ -0,0 +1,15 @@
+import { checkSubarraySum } from '../../src/prefix-sum/continuous-subarray-sum';
+
+describe('continuous subarray sum', () => {
+  test('checkSubarraySum - test case 1', () => {
+    expect(checkSubarraySum([23, 2, 4, 6, 7], 6)).toBe(true);
+  });
+
+  test('checkSubarraySum - test case 2', () => {
+    expect(checkSubarraySum([1, 1], 2)).toBe(true);
+  });
+
+  test('checkSubarraySum - test case 3', () => {
+    expect(checkSubarraySum([-10, 10], 1)).toBe(true);
+  });
+});

test/tree/longest-palindromic-substring.test.ts

@@ -0,0 +1,7 @@
+import { longestPalindrome } from '../../src/string/longest-palindromic-substring';
+
+describe('longest palindromic substring', () => {
+  test('longestPalindrome - test case 1', () => {
+    expect(longestPalindrome('babad')).toEqual('bab');
+  });
+});