Added problems: 1814 - Count Nice Pairs in an Array + Added benchmarking

Author: thegovyadina

Cargo.toml

@@ -4,4 +4,9 @@ version = "0.1.0"
 license = "MIT"
 edition = "2021"
 
-[dependencies]
+[dev-dependencies]
+criterion = "0.7"
+
+[[bench]]
+name = "p1814"
+harness = false

README.md

@@ -58,6 +58,7 @@ Note that this license applies only to my solution code and not to the LeetCode
 | 🟢 1464. [Maximum Product of Two Elements in an Array](https://leetcode.com/problems/maximum-product-of-two-elements-in-an-array/)                                 |         [🦀](src/problems/p1464_maximum_product_of_two_elements_in_an_array.rs)         |                                    |
 | 🟠 1599. [Maximum Profit of Operating a Centennial Wheel](https://leetcode.com/problems/maximum-profit-of-operating-a-centennial-wheel/)                           |       [🦀](src/problems/p1599_maximum_profit_of_operating_a_centennial_wheel.rs)        |                                    |
 | 🟢 1784. [Check if Binary String Has at Most One Segment of Ones](https://leetcode.com/problems/check-if-binary-string-has-at-most-one-segment-of-ones/)           |   [🦀](src/problems/p1784_check_if_binary_string_has_at_most_one_segment_of_ones.rs)    |                                    |
+| 🟠 1814. [Count Nice Pairs in an Array](https://leetcode.com/problems/count-nice-pairs-in-an-array/)                                                               |                [🦀](src/problems/p1814_count_nice_pairs_in_an_array.rs)                 | HashMap                            |
 | 🔴 1866. [Number of Ways to Rearrange Sticks With K Sticks Visible](https://leetcode.com/problems/number-of-ways-to-rearrange-sticks-with-k-sticks-visible/)       |  [🦀](src/problems/p1866_number_of_ways_to_rearrange_sticks_with_k_sticks_visible.rs)   | Dynamic Programming                |
 | 🟢 1876. [Substrings of Size Three with Distinct Characters](https://leetcode.com/problems/substrings-of-size-three-with-distinct-characters/)                     |      [🦀](src/problems/p1876_substrings_of_size_three_with_distinct_characters.rs)      |                                    |
 | 🟢 1974. [Minimum Time to Type Word Using Special Typewriter](https://leetcode.com/problems/minimum-time-to-type-word-using-special-typewriter/)                   |    [🦀](src/problems/p1974_minimimum_time_to_type_word_using_special_typewriter.rs)     |                                    |
@@ -139,3 +140,33 @@ pub mod pNNNN_problem_title;
 4. Add the problem to the [Problems](#problems) table in `README.md`
 5. Run the tests with `cargo test` to make sure everything is working.
 6. Commit your changes.
+
+## Benchmarking
+
+For benchmarking, the `criterion` crate is used.
+
+To add a new benchmark, create a new file in the [/benches/](/benches/) directory and add a new `[[branch]]` section
+in [Cargo.toml](Cargo.toml).
+
+To execute a benchmark, run one of the following commands:
+
+```bash
+# Run all benchmarks
+cargo bench
+
+# Run all benchmarks defined in a specific file
+cargo bench --bench p1814
+```
+
+Also, you can run them more precisely using special syntax. E.g.:
+
+```
+# Run only the benchmark for the specific number 1234
+cargo bench --bench p1814 "loop_based_1234"
+
+# Run all loop-based benchmarks
+cargo bench --bench p1814 "loop_based_.*"
+```
+
+See the [Criterion documentation](https://bheisler.github.io/criterion.rs/book/user_guide/known_limitations.html)
+for more information or run `cargo help bench`.

benches/p1814.rs

@@ -0,0 +1,53 @@
+// benches/p1814
+use criterion::{criterion_group, criterion_main, Criterion};
+use leetcode_rust::problems::p1814_count_nice_pairs_in_an_array::Solution;
+use std::hint::black_box;
+
+fn bench_count_nice_pairs(c: &mut Criterion) {
+    let nums = vec![42, 11, 1, 97];
+
+    c.bench_function("count_nice_pairs", |b| {
+        b.iter(|| Solution::count_nice_pairs(black_box(nums.clone())))
+    });
+}
+
+fn bench_rev_implementations(c: &mut Criterion) {
+    let mut group = c.benchmark_group("rev_implementations");
+
+    // Implementation 1: Loop-based
+    fn rev_loop(mut num: i32) -> i32 {
+        let mut result = 0;
+        while num > 0 {
+            result = result * 10 + num % 10;
+            num /= 10;
+        }
+        result
+    }
+
+    // Implementation 2: String-based
+    fn rev_string(num: i32) -> i32 {
+        num.to_string()
+            .chars()
+            .rev()
+            .collect::<String>()
+            .parse()
+            .unwrap()
+    }
+
+    let test_numbers = [42, 1234, 9876543, 1_000_000_000];
+
+    for &num in &test_numbers {
+        group.bench_function(format!("loop_based_{}", num), |b| {
+            b.iter(|| rev_loop(black_box(num)))
+        });
+
+        group.bench_function(format!("string_based_{}", num), |b| {
+            b.iter(|| rev_string(black_box(num)))
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, bench_count_nice_pairs, bench_rev_implementations);
+criterion_main!(benches);

src/problems/mod.rs

@@ -24,6 +24,7 @@ pub mod p1431_kids_with_the_greatest_number_of_candies;
 pub mod p1464_maximum_product_of_two_elements_in_an_array;
 pub mod p1599_maximum_profit_of_operating_a_centennial_wheel;
 pub mod p1784_check_if_binary_string_has_at_most_one_segment_of_ones;
+pub mod p1814_count_nice_pairs_in_an_array;
 pub mod p1866_number_of_ways_to_rearrange_sticks_with_k_sticks_visible;
 pub mod p1876_substrings_of_size_three_with_distinct_characters;
 pub mod p1974_minimimum_time_to_type_word_using_special_typewriter;

src/problems/p1814_count_nice_pairs_in_an_array.rs

@@ -0,0 +1,66 @@
+//! # LeetCode Problem: 1814 - Count Nice Pairs in an Array
+//!
+//! ## Description
+//!
+//! Difficulty: Medium
+//!
+//! Link: https://leetcode.com/problems/count-nice-pairs-in-an-array/
+//!
+//! ## Complexity Analysis
+//! - Time Complexity: O(n) - We traverse the list containing n elements exactly twice.
+//! - Space Complexity: O(n) - We use a HashMap to store the frequency of each modified number.
+
+pub struct Solution;
+
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn count_nice_pairs(nums: Vec<i32>) -> i32 {
+        const MOD: i64 = 1_000_000_007;
+
+        // For comparison of the loop-based and string-based reverting functions,
+        // see benchmark /benches/p1814_benchmark.rs
+        // You can execute the benchmarks by running `cargo bench`
+        fn rev(mut num: i32) -> i32 {
+            let mut result = 0;
+            while num > 0 {
+                result = result * 10 + num % 10;
+                num /= 10;
+            }
+            result
+        }
+
+        // Count frequencies of differences in one pass
+        let mut diff_counts: HashMap<i32, i64> = HashMap::new();
+        for num in nums {
+            let diff = num - rev(num);
+            *diff_counts.entry(diff).or_insert(0) += 1;
+        }
+        // Calculate combinations: n choose 2 = n * (n - 1) / 2
+        let mut result: i64 = 0;
+        for &count in diff_counts.values() {
+            if count >= 2 {
+                result = (result + (count * (count - 1) / 2)) % MOD;
+            }
+        }
+
+        result as i32
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Solution;
+
+    #[test]
+    fn test_count_nice_pairs() {
+        let test_cases = [(vec![42, 11, 1, 97], 2), (vec![13, 10, 35, 24, 76], 4)];
+        for (idx, (nums, expected)) in test_cases.iter().enumerate() {
+            let result = Solution::count_nice_pairs(nums.clone());
+            assert_eq!(
+                result, *expected,
+                "Test case #{idx}: with input {nums:?}, expected {expected:?}, got {result:?}"
+            );
+        }
+    }
+}