Solve #275

Author: aylei

src/lib.rs

@@ -213,3 +213,4 @@ mod n0264_ugly_number_ii;
 mod n0268_missing_number;
 mod n0273_integer_to_english_words;
 mod n0274_h_index;
+mod n0275_h_index_ii;

src/n0033_search_in_rotated_sorted_array.rs

@@ -2,66 +2,73 @@
  * [33] Search in Rotated Sorted Array
  *
  * Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
- * 
+ *
  * (i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).
- * 
+ *
  * You are given a target value to search. If found in the array return its index, otherwise return -1.
- * 
+ *
  * You may assume no duplicate exists in the array.
- * 
+ *
  * Your algorithm's runtime complexity must be in the order of O(log n).
- * 
+ *
  * Example 1:
- * 
- * 
+ *
+ *
  * Input: nums = [4,5,6,7,0,1,2], target = 0
  * Output: 4
- * 
- * 
+ *
+ *
  * Example 2:
- * 
- * 
+ *
+ *
  * Input: nums = [4,5,6,7,0,1,2], target = 3
  * Output: -1
- * 
+ *
  */
 pub struct Solution {}
 
 /*
-     \
-        8
-      7   9
-    6       1
-      5   2
-        3 \
- Consider the given array as ring, each time we split the ring and judge which part is the target belong to, then it's ordinary binary search.
- */
+    \
+       8
+     7   9
+   6       1
+     5   2
+       3 \
+Consider the given array as ring, each time we split the ring and judge which part is the target belong to, then it's ordinary binary search.
+*/
 
 // submission codes start here
 
 impl Solution {
     pub fn search(nums: Vec<i32>, target: i32) -> i32 {
         let mut size = nums.len();
-        if size == 0 { return -1 }
+        if size == 0 {
+            return -1;
+        }
         let mut base = 0_usize;
         while size > 1 {
             let half = size / 2;
             let mid = base + half;
-            if nums[mid] == target { return mid as i32 }
+            if nums[mid] == target {
+                return mid as i32;
+            }
             // we split the ring to [base..half] & [half+1..base-1]
             // if target not in [base..half] ring, move base to select another ring
-            if !(((nums[base] < nums[mid]) && (target >= nums[base] && target <= nums[mid])) ||
-                ((nums[base] > nums[mid]) && (target >= nums[base] || target <= nums[mid]))) {
+            if !(((nums[base] < nums[mid]) && (target >= nums[base] && target <= nums[mid]))
+                || ((nums[base] > nums[mid]) && (target >= nums[base] || target <= nums[mid])))
+            {
                 base = mid;
             }
             size -= half;
         }
-        if nums[base] == target { base as i32 } else { -1 }
+        if nums[base] == target {
+            base as i32
+        } else {
+            -1
+        }
     }
 }
 
-
-
 // submission codes end
 
 #[cfg(test)]
@@ -70,10 +77,26 @@ mod tests {
 
     #[test]
     fn test_33() {
-        assert_eq!(Solution::search(vec![7,8,1,2,3,4,5,6], 2), 3);
-        assert_eq!(Solution::search(vec![1004,1005,1006,1007,1008,1009,1010,1011,1012,0,1,2,3,4,5,6,7,8], 0), 9);
-        assert_eq!(Solution::search(vec![1004,1005,1006,1007,1008,1009,1010,1011,1012,0,1,2,3,4,5,6,7,8], 1006), 2);
-        assert_eq!(Solution::search(vec![4,5,6,7,0,1,2], 3), -1);
+        assert_eq!(Solution::search(vec![7, 8, 1, 2, 3, 4, 5, 6], 2), 3);
+        assert_eq!(
+            Solution::search(
+                vec![
+                    1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 0, 1, 2, 3, 4, 5, 6, 7, 8
+                ],
+                0
+            ),
+            9
+        );
+        assert_eq!(
+            Solution::search(
+                vec![
+                    1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 0, 1, 2, 3, 4, 5, 6, 7, 8
+                ],
+                1006
+            ),
+            2
+        );
+        assert_eq!(Solution::search(vec![4, 5, 6, 7, 0, 1, 2], 3), -1);
         assert_eq!(Solution::search(vec![], 3), -1);
     }
 }

src/n0275_h_index_ii.rs

@@ -0,0 +1,67 @@
+/**
+ * [275] H-Index II
+ *
+ * Given an array of citations sorted in ascending order (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.
+ *
+ * According to the <a href="https://en.wikipedia.org/wiki/H-index" target="_blank">definition of h-index on Wikipedia</a>: "A scientist has index h if h of his/her N papers have at least h citations each, and the other N - h papers have no more than h citations each."
+ *
+ * Example:
+ *
+ *
+ * Input: citations = [0,1,3,5,6]
+ * Output: 3
+ * Explanation: [0,1,3,5,6] means the researcher has 5 papers in total and each of them had
+ *              received 0, 1, 3, 5, 6 citations respectively.
+ *              Since the researcher has 3 papers with at least 3 citations each and the remaining
+ *              two with no more than 3 citations each, her h-index is 3.
+ *
+ * Note:
+ *
+ * If there are several possible values for h, the maximum one is taken as the h-index.
+ *
+ * Follow up:
+ *
+ *
+ * 	This is a follow up problem to <a href="/problems/h-index/description/">H-Index</a>, where citations is now guaranteed to be sorted in ascending order.
+ * 	Could you solve it in logarithmic time complexity?
+ *
+ *
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+impl Solution {
+    pub fn h_index(citations: Vec<i32>) -> i32 {
+        if citations.is_empty() { return 0 }
+        let len = citations.len();
+        let (mut low, mut high) = (0_usize, len - 1);
+        while low <= high {
+            let mid = low + (high - low) / 2;
+            if citations[mid] >= (len - mid) as i32 {
+                if mid == 0 { break }
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+        (len - low) as i32
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_275() {
+        assert_eq!(Solution::h_index(vec![]), 0);
+        assert_eq!(Solution::h_index(vec![0]), 0);
+        assert_eq!(Solution::h_index(vec![11, 15]), 2);
+        assert_eq!(Solution::h_index(vec![1]), 1);
+        assert_eq!(Solution::h_index(vec![0,1,3,5,6]), 3);
+        assert_eq!(Solution::h_index(vec![0,4,4,5,6]), 4);
+    }
+}