Added tasks 783, 784.

Author: javadev

src/main/java/g0701_0800/s0783_minimum_distance_between_bst_nodes/Solution.java

@@ -0,0 +1,40 @@
+package g0701_0800.s0783_minimum_distance_between_bst_nodes;
+
+// #Easy #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree #Binary_Search_Tree
+
+import com_github_leetcode.TreeNode;
+
+/*
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    private int prev = -1;
+    private int min = Integer.MAX_VALUE;
+
+    public int minDiffInBST(TreeNode root) {
+        if (root == null) {
+            return min;
+        }
+        minDiffInBST(root.left);
+        if (prev == -1) {
+            prev = root.val;
+        } else {
+            min = Math.min(min, Math.abs(root.val - prev));
+            prev = root.val;
+        }
+        minDiffInBST(root.right);
+        return min;
+    }
+}

src/main/java/g0701_0800/s0783_minimum_distance_between_bst_nodes/readme.md

@@ -0,0 +1,28 @@
+783\. Minimum Distance Between BST Nodes
+
+Easy
+
+Given the `root` of a Binary Search Tree (BST), return _the minimum difference between the values of any two different nodes in the tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/05/bst1.jpg)
+
+**Input:** root = [4,2,6,1,3]
+
+**Output:** 1 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/05/bst2.jpg)
+
+**Input:** root = [1,0,48,null,null,12,49]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[2, 100]`.
+*   <code>0 <= Node.val <= 10<sup>5</sup></code>
+
+**Note:** This question is the same as 530: [https://leetcode.com/problems/minimum-absolute-difference-in-bst/](https://leetcode.com/problems/minimum-absolute-difference-in-bst/)

src/main/java/g0701_0800/s0784_letter_case_permutation/Solution.java

@@ -0,0 +1,33 @@
+package g0701_0800.s0784_letter_case_permutation;
+
+// #Medium #String #Bit_Manipulation #Backtracking
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    private List<String> ans = new ArrayList<>();
+
+    public List<String> letterCasePermutation(String s) {
+        helper(s, 0, "");
+        return ans;
+    }
+
+    public void helper(String s, int curr, String temp) {
+        if (curr == s.length()) {
+            ans.add(temp);
+            return;
+        }
+        if (Character.isDigit(s.charAt(curr))) {
+            helper(s, curr + 1, temp + s.substring(curr, curr + 1));
+        } else {
+            if (Character.isLowerCase(s.charAt(curr))) {
+                helper(s, curr + 1, temp + s.substring(curr, curr + 1));
+                helper(s, curr + 1, temp + (s.substring(curr, curr + 1)).toUpperCase());
+            } else {
+                helper(s, curr + 1, temp + s.substring(curr, curr + 1));
+                helper(s, curr + 1, temp + (s.substring(curr, curr + 1)).toLowerCase());
+            }
+        }
+    }
+}

src/main/java/g0701_0800/s0784_letter_case_permutation/readme.md

@@ -0,0 +1,24 @@
+784\. Letter Case Permutation
+
+Medium
+
+Given a string `s`, you can transform every letter individually to be lowercase or uppercase to create another string.
+
+Return _a list of all possible strings we could create_. Return the output in **any order**.
+
+**Example 1:**
+
+**Input:** s = "a1b2"
+
+**Output:** ["a1b2","a1B2","A1b2","A1B2"] 
+
+**Example 2:**
+
+**Input:** s = "3z4"
+
+**Output:** ["3z4","3Z4"] 
+
+**Constraints:**
+
+*   `1 <= s.length <= 12`
+*   `s` consists of lowercase English letters, uppercase English letters, and digits.

src/test/java/g0701_0800/s0783_minimum_distance_between_bst_nodes/SolutionTest.java

@@ -0,0 +1,20 @@
+package g0701_0800.s0783_minimum_distance_between_bst_nodes;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com_github_leetcode.TreeUtils;
+import java.util.Arrays;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void minDiffInBST() {
+        assertThat(
+                new Solution()
+                        .minDiffInBST(
+                                TreeUtils.constructBinaryTree(
+                                        Arrays.asList(4, 2, 6, 1, 3, null, null))),
+                equalTo(1));
+    }
+}

src/test/java/g0701_0800/s0784_letter_case_permutation/SolutionTest.java

@@ -0,0 +1,22 @@
+package g0701_0800.s0784_letter_case_permutation;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void letterCasePermutation() {
+        assertThat(
+                new Solution().letterCasePermutation("a1b2"),
+                equalTo(Arrays.asList("a1b2", "a1B2", "A1b2", "A1B2")));
+    }
+
+    @Test
+    void letterCasePermutation2() {
+        assertThat(
+                new Solution().letterCasePermutation("3z4"), equalTo(Arrays.asList("3z4", "3Z4")));
+    }
+}