20250218 finished.

src/problem/mod.rs

@@ -490,3 +490,5 @@ mod p1552_magnetic_force_between_two_balls;
 mod p1706_where_will_the_ball_fall;
 
 mod p1299_replace_elements_with_greatest_element_on_right_side;
+
+mod p2080_range_frequency_queries;

src/problem/p2080_range_frequency_queries.rs

@@ -0,0 +1,85 @@
+/**
+ * [2080] Range Frequency Queries
+ */
+pub struct Solution {}
+
+// submission codes start here
+use std::collections::HashMap;
+
+struct RangeFreqQuery {
+    frequency_map: HashMap<i32, Vec<usize>>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl RangeFreqQuery {
+    fn new(arr: Vec<i32>) -> Self {
+        let mut frequency_map = HashMap::new();
+
+        for (i, v) in arr.into_iter().enumerate() {
+            let entry = frequency_map.entry(v).or_insert(vec![]);
+            entry.push(i);
+        }
+
+        Self { frequency_map }
+    }
+
+    fn query(&self, left: i32, right: i32, value: i32) -> i32 {
+        let (left, right) = (left as usize, right as usize);
+
+        if let Some(index) = self.frequency_map.get(&value) {
+            let l = index.binary_search(&left);
+            let r = index.binary_search(&right);
+
+            let result = match l {
+                Ok(l_ok) => match r {
+                    Ok(r_ok) => r_ok - l_ok + 1,
+                    Err(r_err) => r_err - l_ok,
+                },
+                Err(l_err) => match r {
+                    Ok(r_ok) => r_ok - l_err + 1,
+                    Err(r_err) => r_err - l_err,
+                },
+            };
+
+            result as i32
+        } else {
+            0
+        }
+    }
+}
+
+/**
+ * Your RangeFreqQuery object will be instantiated and called as such:
+ * let obj = RangeFreqQuery::new(arr);
+ * let ret_1: i32 = obj.query(left, right, value);
+ */
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_2080() {
+        let query = RangeFreqQuery::new(vec![12, 33, 4, 56, 22, 2, 34, 33, 22, 12, 34, 56]);
+
+        assert_eq!(1, query.query(1, 2, 4));
+        assert_eq!(2, query.query(0, 11, 33));
+
+        let query = RangeFreqQuery::new(vec![2, 2, 1, 2, 2]);
+
+        // [2]
+        assert_eq!(1, query.query(2, 4, 1));
+        assert_eq!(1, query.query(1, 3, 1));
+        assert_eq!(1, query.query(0, 2, 1));
+
+        let query = RangeFreqQuery::new(vec![1, 1, 1, 2, 2]);
+
+        // [0, 1, 2]
+        assert_eq!(1, query.query(2, 2, 1));
+    }
+}