Updates from code review

pertrai1 · pertrai1 · commit 6da05a27883f · 2023-11-02T16:26:00.000-04:00
diff --git a/Dynamic-Programming/Abbreviation.js b/Dynamic-Programming/Abbreviation.js
@@ -1,46 +1,47 @@
 /**
  * @description
- * Given two strings, `a` and `b`, determine if it's possible to make `a` equal
- * to `b` You can perform the following operations on the string `a`:
- * 1. Capitalize zero or more of `a`'s lowercase letters.
- * 2. Delete all the remaining lowercase letters in `a`.
+ * Given two strings, `source` and `target`, determine if it's possible to make `source` equal
+ * to `target` You can perform the following operations on the string `source`:
+ * 1. Capitalize zero or more of `source`'s lowercase letters.
+ * 2. Delete all the remaining lowercase letters in `source`.
  *
- * ### Algorithm
- * The idea is in the problem statement itself: iterate through characters of
- * string `a` and `b` (for character indexes `i` and `j` respectively):
- * 1. If `a[i]` and `b[j]` are equal, then move to next position
- * 2. If `a[i]` is lowercase of `b[j]`, then explore two possibilities:
- * a) Capitalize `a[i]` or
- * b) Skip `a[i]`
- * 3. If the `a[i]` is not uppercase, just discard that character, else return
- * `false`
+ * Time Complexity: (O(|source|*|target|)) where `|source|` => length of string `source`
  *
- * Time Complexity: (O(|a|*|b|)) where `|a|` => length of string `a`
- *
- * @param {String} a
- * @param {String} b
- * @returns {Boolean}
+ * @param {String} source - The string to be transformed.
+ * @param {String} target - The string we want to transform `source` into.
+ * @returns {Boolean} - Whether the transformation is possible.
  * @see https://www.hackerrank.com/challenges/abbr/problem - Related problem on HackerRank.
  */
-export const abbreviation = (a, b) => {
-  const n = a.length
-  const m = b.length
+export const isAbbreviation = (source, target) => {
+  const sourceLength = source.length
+  const targetLength = target.length
 
-  let dp = Array.from({length: n + 1}, () => Array(m + 1).fill(false))
-  dp[0][0] = true
+  // Initialize a table to keep track of possible abbreviations
+  let canAbbreviate = Array.from({ length: sourceLength + 1 }, () =>
+    Array(targetLength + 1).fill(false)
+  )
+  // Empty strings are trivially abbreviatable
+  canAbbreviate[0][0] = true
 
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j <= m; j++) {
-      if (dp[i][j]) {
-        if (j < m && a[i].toUpperCase() === b[j]) {
-          dp[i + 1][j + 1] = true
+  for (let sourceIndex = 0; sourceIndex < sourceLength; sourceIndex++) {
+    for (let targetIndex = 0; targetIndex <= targetLength; targetIndex++) {
+      if (canAbbreviate[sourceIndex][targetIndex]) {
+        // If characters at the current position are equal, move to the next position in both strings.
+        if (
+          targetIndex < targetLength &&
+          source[sourceIndex].toUpperCase() === target[targetIndex]
+        ) {
+          canAbbreviate[sourceIndex + 1][targetIndex + 1] = true
         }
-        if (a[i] === a[i].toLowerCase()) {
-          dp[i + 1][j] = true
+        // If the current character in `source` is lowercase, explore two possibilities:
+        // a) Capitalize it (which is akin to "using" it in `source` to match `target`), or
+        // b) Skip it (effectively deleting it from `source`).
+        if (source[sourceIndex] === source[sourceIndex].toLowerCase()) {
+          canAbbreviate[sourceIndex + 1][targetIndex] = true
         }
       }
     }
   }
 
-  return dp[n][m]
-}
+  return canAbbreviate[sourceLength][targetLength]
+}
diff --git a/Dynamic-Programming/tests/Abbreviation.test.js b/Dynamic-Programming/tests/Abbreviation.test.js
@@ -1,20 +1,30 @@
-import { abbreviation } from '../Abbreviation.js'
+import { isAbbreviation } from '../Abbreviation.js'
 
-describe('Abbreviation', () => {
-  test('it can abbreviate string a to b', () => {
-    expect(abbreviation('', '')).toBe(true)
-    expect(abbreviation('a', '')).toBe(true)
-    expect(abbreviation('', 'A')).toBe(false)
-    expect(abbreviation('a', 'A')).toBe(true)
-    expect(abbreviation('abcDE', 'ABCDE')).toBe(true)
-    expect(abbreviation('ABcDE', 'ABCDE')).toBe(true)
-    expect(abbreviation('abcde', 'ABCDE')).toBe(true)
-    expect(abbreviation('abcde', 'ABC')).toBe(true)
-    expect(abbreviation('a', 'ABC')).toBe(false)
-    expect(abbreviation('abcXYdefghijKLmnopqrs', 'XYKL')).toBe(true)
-    expect(abbreviation('aBcXYdefghijKLmnOpqrs', 'XYKLOP')).toBe(false)
-    expect(abbreviation('abc123', 'ABC')).toBe(true)
-    expect(abbreviation('abc123', 'ABC123')).toBe(true)
-    expect(abbreviation('abc!@#def', 'ABC')).toBe(true)
+const expectPositive = (word, abbr) =>
+  expect(isAbbreviation(word, abbr)).toBe(true)
+const expectNegative = (word, abbr) =>
+  expect(isAbbreviation(word, abbr)).toBe(false)
+
+describe('Abbreviation - Positive Tests', () => {
+  test('it should correctly abbreviate or transform the source string to match the target string', () => {
+    expectPositive('', '')
+    expectPositive('a', '')
+    expectPositive('a', 'A')
+    expectPositive('abcDE', 'ABCDE')
+    expectPositive('ABcDE', 'ABCDE')
+    expectPositive('abcde', 'ABCDE')
+    expectPositive('abcde', 'ABC')
+    expectPositive('abcXYdefghijKLmnopqrs', 'XYKL')
+    expectPositive('abc123', 'ABC')
+    expectPositive('abc123', 'ABC123')
+    expectPositive('abc!@#def', 'ABC')
+  })
+})
+
+describe('Abbreviation - Negative Tests', () => {
+  test('it should fail to abbreviate or transform the source string when it is not possible to match the target string', () => {
+    expectNegative('', 'A')
+    expectNegative('a', 'ABC')
+    expectNegative('aBcXYdefghijKLmnOpqrs', 'XYKLOP')
   })
-})
+})
