Add 1413 solution

Author: lidongjies

src/problem/p1146_snapshot_array.rs

@@ -0,0 +1,85 @@
+/**
+ * [1146] Snapshot Array
+ *
+ * Implement a SnapshotArray that supports the following interface:
+ * 
+ * 	SnapshotArray(int length) initializes an array-like data structure with the given length. Initially, each element equals 0.
+ * 	void set(index, val) sets the element at the given index to be equal to val.
+ * 	int snap() takes a snapshot of the array and returns the snap_id: the total number of times we called snap() minus 1.
+ * 	int get(index, snap_id) returns the value at the given index, at the time we took the snapshot with the given snap_id
+ * 
+ *  
+ * Example 1:
+ * 
+ * Input: ["SnapshotArray","set","snap","set","get"]
+ * [[3],[0,5],[],[0,6],[0,0]]
+ * Output: [null,null,0,null,5]
+ * Explanation: 
+ * SnapshotArray snapshotArr = new SnapshotArray(3); // set the length to be 3
+ * snapshotArr.set(0,5);  // Set array[0] = 5
+ * snapshotArr.snap();  // Take a snapshot, return snap_id = 0
+ * snapshotArr.set(0,6);
+ * snapshotArr.get(0,0);  // Get the value of array[0] with snap_id = 0, return 5
+ *  
+ * Constraints:
+ * 
+ * 	1 <= length <= 5 * 10^4
+ * 	0 <= index < length
+ * 	0 <= val <= 10^9
+ * 	0 <= snap_id < (the total number of times we call snap())
+ * 	At most 5 * 10^4 calls will be made to set, snap, and get.
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/snapshot-array/
+// discuss: https://leetcode.com/problems/snapshot-array/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+struct SnapshotArray {
+        false
+    }
+
+
+/** 
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl SnapshotArray {
+
+    fn new(length: i32) -> Self {
+        
+    }
+    
+    fn set(&self, index: i32, val: i32) {
+        
+    }
+    
+    fn snap(&self) -> i32 {
+        
+    }
+    
+    fn get(&self, index: i32, snap_id: i32) -> i32 {
+        
+    }
+}
+
+/**
+ * Your SnapshotArray object will be instantiated and called as such:
+ * let obj = SnapshotArray::new(length);
+ * obj.set(index, val);
+ * let ret_2: i32 = obj.snap();
+ * let ret_3: i32 = obj.get(index, snap_id);
+ */
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1146() {
+    }
+}

src/problem/p1624_largest_substring_between_two_equal_characters.rs

@@ -0,0 +1,53 @@
+/**
+ * [1624] Largest Substring Between Two Equal Characters
+ *
+ * Given a string s, return the length of the longest substring between two equal characters, excluding the two characters. If there is no such substring return -1.
+ * A substring is a contiguous sequence of characters within a string.
+ *  
+ * Example 1:
+ * 
+ * Input: s = "aa"
+ * Output: 0
+ * Explanation: The optimal substring here is an empty substring between the two 'a's.
+ * Example 2:
+ * 
+ * Input: s = "abca"
+ * Output: 2
+ * Explanation: The optimal substring here is "bc".
+ * 
+ * Example 3:
+ * 
+ * Input: s = "cbzxy"
+ * Output: -1
+ * Explanation: There are no characters that appear twice in s.
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	1 <= s.length <= 300
+ * 	s contains only lowercase English letters.
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/largest-substring-between-two-equal-characters/
+// discuss: https://leetcode.com/problems/largest-substring-between-two-equal-characters/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn max_length_between_equal_characters(s: String) -> i32 {
+        0
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1624() {
+    }
+}

src/problem/p1681_minimum_incompatibility.rs

@@ -0,0 +1,59 @@
+/**
+ * [1681] Minimum Incompatibility
+ *
+ * You are given an integer array nums​​​ and an integer k. You are asked to distribute this array into k subsets of equal size such that there are no two equal elements in the same subset.
+ * A subset's incompatibility is the difference between the maximum and minimum elements in that array.
+ * Return the minimum possible sum of incompatibilities of the k subsets after distributing the array optimally, or return -1 if it is not possible.
+ * A subset is a group integers that appear in the array with no particular order.
+ *  
+ * Example 1:
+ * 
+ * Input: nums = [1,2,1,4], k = 2
+ * Output: 4
+ * Explanation: The optimal distribution of subsets is [1,2] and [1,4].
+ * The incompatibility is (2-1) + (4-1) = 4.
+ * Note that [1,1] and [2,4] would result in a smaller sum, but the first subset contains 2 equal elements.
+ * Example 2:
+ * 
+ * Input: nums = [6,3,8,1,3,1,2,2], k = 4
+ * Output: 6
+ * Explanation: The optimal distribution of subsets is [1,2], [2,3], [6,8], and [1,3].
+ * The incompatibility is (2-1) + (3-2) + (8-6) + (3-1) = 6.
+ * 
+ * Example 3:
+ * 
+ * Input: nums = [5,3,3,6,3,3], k = 3
+ * Output: -1
+ * Explanation: It is impossible to distribute nums into 3 subsets where no two elements are equal in the same subset.
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	1 <= k <= nums.length <= 16
+ * 	nums.length is divisible by k
+ * 	1 <= nums[i] <= nums.length
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/minimum-incompatibility/
+// discuss: https://leetcode.com/problems/minimum-incompatibility/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn minimum_incompatibility(nums: Vec<i32>, k: i32) -> i32 {
+        0
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1681() {
+    }
+}

src/problem/p1930_unique_length_3_palindromic_subsequences.rs

@@ -0,0 +1,66 @@
+/**
+ * [1930] Unique Length-3 Palindromic Subsequences
+ *
+ * Given a string s, return the number of unique palindromes of length three that are a subsequence of s.
+ * Note that even if there are multiple ways to obtain the same subsequence, it is still only counted once.
+ * A palindrome is a string that reads the same forwards and backwards.
+ * A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.
+ * 
+ * 	For example, "ace" is a subsequence of "<u>a</u>b<u>c</u>d<u>e</u>".
+ * 
+ *  
+ * Example 1:
+ * 
+ * Input: s = "aabca"
+ * Output: 3
+ * Explanation: The 3 palindromic subsequences of length 3 are:
+ * - "aba" (subsequence of "<u>a</u>a<u>b</u>c<u>a</u>")
+ * - "aaa" (subsequence of "<u>aa</u>bc<u>a</u>")
+ * - "aca" (subsequence of "<u>a</u>ab<u>ca</u>")
+ * 
+ * Example 2:
+ * 
+ * Input: s = "adc"
+ * Output: 0
+ * Explanation: There are no palindromic subsequences of length 3 in "adc".
+ * 
+ * Example 3:
+ * 
+ * Input: s = "bbcbaba"
+ * Output: 4
+ * Explanation: The 4 palindromic subsequences of length 3 are:
+ * - "bbb" (subsequence of "<u>bb</u>c<u>b</u>aba")
+ * - "bcb" (subsequence of "<u>b</u>b<u>cb</u>aba")
+ * - "bab" (subsequence of "<u>b</u>bcb<u>ab</u>a")
+ * - "aba" (subsequence of "bbcb<u>aba</u>")
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	3 <= s.length <= 10^5
+ * 	s consists of only lowercase English letters.
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/unique-length-3-palindromic-subsequences/
+// discuss: https://leetcode.com/problems/unique-length-3-palindromic-subsequences/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn count_palindromic_subsequence(s: String) -> i32 {
+        0
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_1930() {
+    }
+}

src/problem/p2042_check_if_numbers_are_ascending_in_a_sentence.rs

@@ -0,0 +1,64 @@
+/**
+ * [2042] Check if Numbers Are Ascending in a Sentence
+ *
+ * A sentence is a list of tokens separated by a single space with no leading or trailing spaces. Every token is either a positive number consisting of digits 0-9 with no leading zeros, or a word consisting of lowercase English letters.
+ * 
+ * 	For example, "a puppy has 2 eyes 4 legs" is a sentence with seven tokens: "2" and "4" are numbers and the other tokens such as "puppy" are words.
+ * 
+ * Given a string s representing a sentence, you need to check if all the numbers in s are strictly increasing from left to right (i.e., other than the last number, each number is strictly smaller than the number on its right in s).
+ * Return true if so, or false otherwise.
+ *  
+ * Example 1:
+ * <img alt="example-1" src="https://assets.leetcode.com/uploads/2021/09/30/example1.png" style="width: 637px; height: 48px;" />
+ * Input: s = "1 box has 3 blue 4 red 6 green and 12 yellow marbles"
+ * Output: true
+ * Explanation: The numbers in s are: 1, 3, 4, 6, 12.
+ * They are strictly increasing from left to right: 1 < 3 < 4 < 6 < 12.
+ * 
+ * Example 2:
+ * 
+ * Input: s = "hello world 5 x 5"
+ * Output: false
+ * Explanation: The numbers in s are: <u>5</u>, <u>5</u>. They are not strictly increasing.
+ * 
+ * Example 3:
+ * <img alt="example-3" src="https://assets.leetcode.com/uploads/2021/09/30/example3.png" style="width: 794px; height: 48px;" />
+ * Input: s = "sunset is at 7 51 pm overnight lows will be in the low 50 and 60 s"
+ * Output: false
+ * Explanation: The numbers in s are: 7, <u>51</u>, <u>50</u>, 60. They are not strictly increasing.
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	3 <= s.length <= 200
+ * 	s consists of lowercase English letters, spaces, and digits from 0 to 9, inclusive.
+ * 	The number of tokens in s is between 2 and 100, inclusive.
+ * 	The tokens in s are separated by a single space.
+ * 	There are at least two numbers in s.
+ * 	Each number in s is a positive number less than 100, with no leading zeros.
+ * 	s contains no leading or trailing spaces.
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/check-if-numbers-are-ascending-in-a-sentence/
+// discuss: https://leetcode.com/problems/check-if-numbers-are-ascending-in-a-sentence/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn are_numbers_ascending(s: String) -> bool {
+        false
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_2042() {
+    }
+}

src/problem/p2206_divide_array_into_equal_pairs.rs

@@ -0,0 +1,57 @@
+/**
+ * [2206] Divide Array Into Equal Pairs
+ *
+ * You are given an integer array nums consisting of 2 * n integers.
+ * You need to divide nums into n pairs such that:
+ * 
+ * 	Each element belongs to exactly one pair.
+ * 	The elements present in a pair are equal.
+ * 
+ * Return true if nums can be divided into n pairs, otherwise return false.
+ *  
+ * Example 1:
+ * 
+ * Input: nums = [3,2,3,2,2,2]
+ * Output: true
+ * Explanation: 
+ * There are 6 elements in nums, so they should be divided into 6 / 2 = 3 pairs.
+ * If nums is divided into the pairs (2, 2), (3, 3), and (2, 2), it will satisfy all the conditions.
+ * 
+ * Example 2:
+ * 
+ * Input: nums = [1,2,3,4]
+ * Output: false
+ * Explanation: 
+ * There is no way to divide nums into 4 / 2 = 2 pairs such that the pairs satisfy every condition.
+ * 
+ *  
+ * Constraints:
+ * 
+ * 	nums.length == 2 * n
+ * 	1 <= n <= 500
+ * 	1 <= nums[i] <= 500
+ * 
+ */
+pub struct Solution {}
+
+// problem: https://leetcode.com/problems/divide-array-into-equal-pairs/
+// discuss: https://leetcode.com/problems/divide-array-into-equal-pairs/discuss/?currentPage=1&orderBy=most_votes&query=
+
+// submission codes start here
+
+impl Solution {
+    pub fn divide_array(nums: Vec<i32>) -> bool {
+        false
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_2206() {
+    }
+}