- DeleteOperationForTwoStrings

- MinimumASCIIDeleteSumForTwoStrings

Signed-off-by: Gopal S Akshintala <[email protected]>

Author: overfullstack

ds-algo/src/main/java/practice/HIndex.java

@@ -4,30 +4,30 @@
 
 /** [274. H-Index](https://leetcode.com/problems/h-index) */
 public class HIndex {
-  public int hIndex(int[] citations) {
-    var buckets = new int[citations.length + 1];
-    for (var citation : citations) {
-      // ! Any with more than citations length fall into nth extra bucket
-      if (citation > citations.length) { // ! or `buckets.length - 1`
-        buckets[buckets.length - 1]++;
-      } else {
-        buckets[citation]++;
-      }
-    }
-    var paperCount = 0;
-    for (var i = buckets.length - 1; i >= 0; i--) { // ! Iterating backwards
-      paperCount += buckets[i];
-      // ! All citations above `i` are cited more than `i` times
-      if (paperCount >= i) {
-        return i;
-      }
-    }
-    return 0;
-  }
+	public int hIndex(int[] citations) {
+		var buckets = new int[citations.length + 1];
+		for (var citation : citations) {
+			// ! Any with more than citations length fall into nth extra bucket
+			if (citation > citations.length) { // ! or `buckets.length - 1`
+				buckets[buckets.length - 1]++;
+			} else {
+				buckets[citation]++;
+			}
+		}
+		var paperCount = 0;
+		for (var i = buckets.length - 1; i >= 0; i--) { // ! Iterating backwards
+			paperCount += buckets[i];
+			// ! All citations above `i` are cited more than `i` times
+			if (paperCount >= i) {
+				return i;
+			}
+		}
+		return 0;
+	}
 
-  static void main() {
-    var l = new HIndex();
-    System.out.println(l.hIndex(new int[] {3, 0, 6, 1, 5})); // 3
-    System.out.println(l.hIndex(new int[] {1, 3, 1})); // 1
-  }
+	static void main() {
+		var l = new HIndex();
+		System.out.println(l.hIndex(new int[] {3, 0, 6, 1, 5})); // 3
+		System.out.println(l.hIndex(new int[] {1, 3, 1})); // 1
+	}
 }

ds-algo/src/main/java/practice/LemonadeChange.java

@@ -4,33 +4,33 @@
 
 /** [860. Lemonade Change](https://leetcode.com/problems/lemonade-change/) */
 public class LemonadeChange {
-  public boolean lemonadeChange(int[] bills) {
-    var five = 0;
-    var ten = 0;
-    for (var bill : bills) {
-      if (bill == 5) {
-        five++;
-      } else if (bill == 10) {
-        five--;
-        ten++;
-      } else {
-        if (ten > 0) {
-          ten--;
-          five--;
-        } else {
-          five -= 3;
-        }
-      }
-      if (five < 0) {
-        return false;
-      }
-    }
-    return true;
-  }
+	public boolean lemonadeChange(int[] bills) {
+		var five = 0;
+		var ten = 0;
+		for (var bill : bills) {
+			if (bill == 5) {
+				five++;
+			} else if (bill == 10) {
+				five--;
+				ten++;
+			} else {
+				if (ten > 0) {
+					ten--;
+					five--;
+				} else {
+					five -= 3;
+				}
+			}
+			if (five < 0) {
+				return false;
+			}
+		}
+		return true;
+	}
 
-  static void main() {
-    var l = new LemonadeChange();
-    System.out.println(l.lemonadeChange(new int[] {5, 5, 5, 10, 20})); // true
-    System.out.println(l.lemonadeChange(new int[] {5, 5, 10, 10, 20})); // false
-  }
+	static void main() {
+		var l = new LemonadeChange();
+		System.out.println(l.lemonadeChange(new int[] {5, 5, 5, 10, 20})); // true
+		System.out.println(l.lemonadeChange(new int[] {5, 5, 10, 10, 20})); // false
+	}
 }

ds-algo/src/main/java/practice/ThreeSum.java

@@ -11,9 +11,9 @@ public List<List<Integer>> threeSum(int[] nums) {
 		var result = new ArrayList<List<Integer>>();
 		for (var left1 = 0; left1 < nums.length; left1++) {
 			if (left1 == 0 || nums[left1] != nums[left1 - 1]) {
-        // ! init left2, right in the inner loop
+				// ! init left2, right in the inner loop
 				var left2 = left1 + 1;
-				var right = nums.length - 1; 
+				var right = nums.length - 1;
 				while (left2 < right) {
 					var sum = nums[left1] + nums[left2] + nums[right];
 					if (sum > 0) {
@@ -22,9 +22,9 @@ public List<List<Integer>> threeSum(int[] nums) {
 						left2++;
 					} else {
 						result.add(Arrays.asList(nums[left1], nums[left2], nums[right]));
-            do {
-              left2++;
-            } while (nums[left2] == nums[left2 - 1] && left2 < right);
+						do {
+							left2++;
+						} while (nums[left2] == nums[left2 - 1] && left2 < right);
 					}
 				}
 			}

ds-algo/src/main/java/practice/ValidTriangleNumber.java

@@ -2,37 +2,35 @@
 
 /* 26 Oct 2025 12:14 */
 
-import java.util.Arrays;
-
 import static java.lang.IO.println;
 
-/**
- * [611. Valid Triangle Number](https://leetcode.com/problems/valid-triangle-number/)
- */
+import java.util.Arrays;
+
+/** [611. Valid Triangle Number](https://leetcode.com/problems/valid-triangle-number/) */
 public class ValidTriangleNumber {
-  public int triangleNumber(int[] nums) {
-    Arrays.sort(nums);
-    var count = 0;
-    // ! Fix the largest side (right) and find pairs of smaller sides
-    for (var right = nums.length - 1; right >= 2; right--) {
-      var left1 = 0;
-      var left2 = right - 1;
-      while (left1 < left2) {
-        if (nums[left1] + nums[left2] > nums[right]) {
-          // ! All elements between left1 and left2 form valid triangles with left2 and right
-          count += left2 - left1;
-          left2--;
-        } else {
-          left1++;
-        }
-      }
-    }
-    return count;
-  }
+	public int triangleNumber(int[] nums) {
+		Arrays.sort(nums);
+		var count = 0;
+		// ! Fix the largest side (right) and find pairs of smaller sides
+		for (var right = nums.length - 1; right >= 2; right--) {
+			var left1 = 0;
+			var left2 = right - 1;
+			while (left1 < left2) {
+				if (nums[left1] + nums[left2] > nums[right]) {
+					// ! All elements between left1 and left2 form valid triangles with left2 and right
+					count += left2 - left1;
+					left2--;
+				} else {
+					left1++;
+				}
+			}
+		}
+		return count;
+	}
 
-  static void main() {
-    var obj = new ValidTriangleNumber();
-    println(obj.triangleNumber(new int[] {2, 2, 3, 4})); // 3
-    println(obj.triangleNumber(new int[] {4, 2, 3, 4})); // 4
-  }
+	static void main() {
+		var obj = new ValidTriangleNumber();
+		println(obj.triangleNumber(new int[] {2, 2, 3, 4})); // 3
+		println(obj.triangleNumber(new int[] {4, 2, 3, 4})); // 4
+	}
 }

ds-algo/src/main/java/practice/dp/CombinationSum4.java

@@ -9,7 +9,7 @@ public int combinationSum4(int[] nums, int target) {
 		dp[0] = 1;
 		for (var sum = 1; sum <= target; sum++) {
 			for (var num : nums) {
-        // ! Borrow from all previous sums, to add up to combinations
+				// ! Borrow from all previous sums, to add up to combinations
 				if (num <= sum) {
 					dp[sum] += dp[sum - num];
 				}

ds-algo/src/main/java/practice/dp/DeleteAndEarn.java

@@ -4,27 +4,25 @@
 
 import static java.lang.IO.println;
 
-/**
- * [740. Delete and Earn](https://leetcode.com/problems/delete-and-earn/)
- */
+/** [740. Delete and Earn](https://leetcode.com/problems/delete-and-earn/) */
 public class DeleteAndEarn {
-  public int deleteAndEarn(int[] nums) {
-    var buckets = new int[1 + (int) Math.pow(10, 4)];
-    for (var num : nums) {
-      buckets[num] += num;
-    }
-    var dp = new int[buckets.length];
-    dp[0] = 0; // ! or buckets[0], which is 0
-    dp[1] = buckets[1]; // ! No need of `maxOf` as it's either 0 or positive
-    for (var i = 2; i < dp.length; i++) {
-      dp[i] = Math.max(dp[i - 1], buckets[i] + dp[i - 2]);
-    }
-    return dp[dp.length - 1];
-  }
+	public int deleteAndEarn(int[] nums) {
+		var buckets = new int[1 + (int) Math.pow(10, 4)];
+		for (var num : nums) {
+			buckets[num] += num;
+		}
+		var dp = new int[buckets.length];
+		dp[0] = 0; // ! or buckets[0], which is 0
+		dp[1] = buckets[1]; // ! No need of `maxOf` as it's either 0 or positive
+		for (var i = 2; i < dp.length; i++) {
+			dp[i] = Math.max(dp[i - 1], buckets[i] + dp[i - 2]);
+		}
+		return dp[dp.length - 1];
+	}
 
-  static void main() {
-    var obj = new DeleteAndEarn();
-    println(obj.deleteAndEarn(new int[] {3, 4, 2})); // 6
-    println(obj.deleteAndEarn(new int[] {2, 2, 3, 3, 3, 4})); // 9
-  }
+	static void main() {
+		var obj = new DeleteAndEarn();
+		println(obj.deleteAndEarn(new int[] {3, 4, 2})); // 6
+		println(obj.deleteAndEarn(new int[] {2, 2, 3, 3, 3, 4})); // 9
+	}
 }

ds-algo/src/main/java/practice/dp/DeleteOperationForTwoStrings.java

@@ -0,0 +1,33 @@
+package practice.dp;
+
+/* 26 Oct 2025 16:29 */
+
+public class DeleteOperationForTwoStrings {
+	public int minDistance(String word1, String word2) {
+		var commonSubsequenceLen = longestCommonSubsequence(word1, word2);
+		// ! Delete all the letters except the common ones
+		return word1.length() + word2.length() - 2 * commonSubsequenceLen;
+	}
+
+	private static int longestCommonSubsequence(String word1, String word2) {
+		var table = new int[word1.length() + 1][word2.length() + 1];
+		for (var i = 0; i <= word1.length(); i++) {
+			for (var j = 0; j <= word2.length(); j++) {
+				if (i == 0 || j == 0) {
+					table[i][j] = 0;
+				} else if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
+					table[i][j] = 1 + table[i - 1][j - 1];
+				} else {
+					table[i][j] = Math.max(table[i - 1][j], table[i][j - 1]);
+				}
+			}
+		}
+		return table[word1.length()][word2.length()];
+	}
+
+	static void main() {
+		var obj = new DeleteOperationForTwoStrings();
+		System.out.println(obj.minDistance("sea", "eat")); // 2
+		System.out.println(obj.minDistance("leetcode", "etco")); // 4
+	}
+}

ds-algo/src/main/java/practice/dp/LongestCommonSubsequence.java

@@ -0,0 +1,34 @@
+package practice.dp;
+
+/* Created by gakshintala on 6/11/16. */
+
+/** [1143. Longest Common Subsequence](https://leetcode.com/problems/longest-common-subsequence/) */
+public class LongestCommonSubsequence {
+	public int longestCommonSubsequence(String text1, String text2) {
+		var table = new int[text1.length() + 1][text2.length() + 1];
+		for (var i = 0; i <= text1.length(); i++) {
+			for (var j = 0; j <= text2.length(); j++) {
+				if (i == 0 || j == 0) { // One of the strings is empty, so nothing in common
+					table[i][j] = 0;
+				} else {
+					// if char matches
+					if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
+						table[i][j] = 1 + table[i - 1][j - 1];
+					} else { // Unlike substring, the match streak is not broken; we continue to build up
+						// max of length if char not present in `a`, char not present in `b`
+						// No `+1` as no match
+						table[i][j] = Math.max(table[i - 1][j], table[i][j - 1]);
+					}
+				}
+			}
+		}
+		return table[text1.length()][text2.length()];
+	}
+
+	static void main() {
+		var obj = new LongestCommonSubsequence();
+		System.out.println(obj.longestCommonSubsequence("abcde", "ace")); // 3
+		System.out.println(obj.longestCommonSubsequence("abc", "abc")); // 3
+		System.out.println(obj.longestCommonSubsequence("abc", "def")); // 0
+	}
+}

ds-algo/src/main/java/practice/dp/MinimumASCIIDeleteSumForTwoStrings.java

@@ -0,0 +1,38 @@
+package practice.dp;
+
+/* 26 Oct 2025 17:19 */
+
+/**
+ * [712. Minimum ASCII Delete Sum for Two
+ * Strings](https://leetcode.com/problems/minimum-ascii-delete-sum-for-two-strings/)
+ */
+public class MinimumASCIIDeleteSumForTwoStrings {
+	public int minimumDeleteSum(String s1, String s2) {
+		var commonSubsequenceCost = commonSubsequenceCost(s1, s2);
+		var s1Cost = s1.chars().sum();
+		var s2Cost = s2.chars().sum();
+		return s1Cost + s2Cost - 2 * commonSubsequenceCost;
+	}
+
+	private static int commonSubsequenceCost(String s1, String s2) {
+		var dp = new int[s1.length() + 1][s2.length() + 1];
+		for (var i = 0; i <= s1.length(); i++) {
+			for (var j = 0; j <= s2.length(); j++) {
+				if (i == 0 || j == 0) {
+					dp[i][j] = 0;
+				} else if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
+					dp[i][j] = s1.charAt(i - 1) + dp[i - 1][j - 1];
+				} else {
+					dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+				}
+			}
+		}
+		return dp[s1.length()][s2.length()];
+	}
+
+	static void main() {
+		var obj = new MinimumASCIIDeleteSumForTwoStrings();
+		System.out.println(obj.minimumDeleteSum("sea", "eat")); // 231
+		System.out.println(obj.minimumDeleteSum("delete", "leet")); // 403
+	}
+}

ds-algo/src/main/kotlin/leetcode/dp/HouseRobber.kt

@@ -9,9 +9,9 @@ fun robBottomUp(nums: IntArray): Int {
   dp[0] = nums[0]
   dp[1] = maxOf(nums[0], nums[1])
   for (i in 2..nums.lastIndex) {
-    dp[i] = maxOf(dp[i-1], nums[i] + dp[i - 2])
+    dp[i] = maxOf(dp[i - 1], nums[i] + dp[i - 2])
   }
-  return dp.last();
+  return dp.last()
 }
 
 fun robTopDown(nums: IntArray, idx: Int = 0, memo: IntArray = IntArray(nums.size) { -1 }): Int =
@@ -38,8 +38,8 @@ fun rob(nums: IntArray): Int {
 
 fun main() {
   println(robBottomUp(intArrayOf(1, 2, 3, 1))) // 4
-  println(robBottomUp(intArrayOf(2,7,9,3,1))) // 12
-  
+  println(robBottomUp(intArrayOf(2, 7, 9, 3, 1))) // 12
+
   println(robTopDown(intArrayOf(1, 2, 3, 1))) // 4
-  println(robTopDown(intArrayOf(2,7,9,3,1))) // 12
+  println(robTopDown(intArrayOf(2, 7, 9, 3, 1))) // 12
 }