feat(rust): Make the rust functions similarly named as their python counterparts

Author: nikhilmitrax

Diff for: rust/Backtracking/combinations_of_sum_k.rs

@@ -2,12 +2,12 @@ pub fn combinations_of_sum_k(nums: Vec<i32>, target: i32) -> Vec<Vec<i32>> {
     let mut result: Vec<Vec<i32>> = Vec::new();
     let mut combination: Vec<i32> = Vec::new();
 
-    combinations_of_sum_k_impl(&mut combination, 0, &nums, target, &mut result);
+    dfs(&mut combination, 0, &nums, target, &mut result);
 
     result
 }
 
-fn combinations_of_sum_k_impl(
+fn dfs(
     combination: &mut Vec<i32>,
     start_index: usize,
     nums: &Vec<i32>,
@@ -33,7 +33,7 @@ fn combinations_of_sum_k_impl(
         combination.push(nums[i]);
 
         // Recursively explore all paths that branch from this new combination.
-        combinations_of_sum_k_impl(combination, i, nums, target - nums[i], result);
+        dfs(combination, i, nums, target - nums[i], result);
 
         // Backtrack by removing the number we just added.
         combination.pop();

Diff for: rust/Backtracking/find_all_permutations.rs

@@ -3,12 +3,12 @@ pub fn find_all_permutations(nums: Vec<i32>) -> Vec<Vec<i32>> {
     let mut candidate: Vec<i32> = Vec::new();
     let mut used: std::collections::HashSet<i32> = std::collections::HashSet::new();
 
-    find_all_permutations_impl(&nums, &mut candidate, &mut used, &mut result);
+    dfs(&nums, &mut candidate, &mut used, &mut result);
 
     result
 }
 
-fn find_all_permutations_impl(
+fn dfs(
     nums: &Vec<i32>,
     candidate: &mut Vec<i32>,
     used: &mut std::collections::HashSet<i32>,
@@ -27,7 +27,7 @@ fn find_all_permutations_impl(
             used.insert(num);
 
             // Recursively explore all branches using the updated permutation candidate.
-            find_all_permutations_impl(nums, candidate, used, result);
+            dfs(nums, candidate, used, result);
 
             // Backtrack by reversing the changes made.
             candidate.pop();

Diff for: rust/Backtracking/find_all_subsets.rs

@@ -2,12 +2,12 @@ pub fn find_all_subsets(nums: Vec<i32>) -> Vec<Vec<i32>> {
     let mut result: Vec<Vec<i32>> = Vec::new();
     let mut curr_subset: Vec<i32> = Vec::new();
 
-    find_all_subsets_impl(0, &mut curr_subset, &nums, &mut result);
+    backtrack(0, &mut curr_subset, &nums, &mut result);
 
     result
 }
 
-fn find_all_subsets_impl(
+fn backtrack(
     i: usize,
     curr_subset: &mut Vec<i32>,
     nums: &Vec<i32>,
@@ -23,10 +23,10 @@ fn find_all_subsets_impl(
     // Include the current element and recursively explore all paths
     // that branch from this subset.
     curr_subset.push(nums[i]);
-    find_all_subsets_impl(i + 1, curr_subset, nums, result);
+    backtrack(i + 1, curr_subset, nums, result);
 
     // Exclude the current element and recursively explore all paths
     // that branch from this subset.
     curr_subset.pop();
-    find_all_subsets_impl(i + 1, curr_subset, nums, result);
+    backtrack(i + 1, curr_subset, nums, result);
 }

Diff for: rust/Backtracking/n_queens.rs

@@ -4,12 +4,12 @@ pub fn n_queens(n: i32) -> i32 {
     let mut anti_diagonals_set = std::collections::HashSet::new();
     let mut cols_set = std::collections::HashSet::new();
 
-    n_queens_impl(0, &mut diagonals_set, &mut anti_diagonals_set, &mut cols_set, n, &mut result);
+    dfs(0, &mut diagonals_set, &mut anti_diagonals_set, &mut cols_set, n, &mut result);
 
     result
 }
 
-fn n_queens_impl(
+fn dfs(
     r: i32, 
     diagonals_set: &mut std::collections::HashSet<i32>, 
     anti_diagonals_set: &mut std::collections::HashSet<i32>, 
@@ -43,7 +43,7 @@ fn n_queens_impl(
         anti_diagonals_set.insert(curr_anti_diagonal);
 
         // Recursively move to the next row to continue placing queens.
-        n_queens_impl(r + 1, diagonals_set, anti_diagonals_set, cols_set, n, result);
+        dfs(r + 1, diagonals_set, anti_diagonals_set, cols_set, n, result);
 
         // Backtrack by removing the current column, diagonal, and
         // anti-diagonal from the hash sets.

Diff for: rust/Backtracking/phone_keypad_combinations.rs

@@ -19,12 +19,12 @@ pub fn phone_keypad_combinations(digits: String) -> Vec<String> {
     let mut curr_combination: Vec<char> = Vec::new();
 
     let digits_chars: Vec<char> = digits.chars().collect();
-    phone_keypad_combinations_impl(0, &mut curr_combination, &digits_chars, &keypad_map, &mut result);
+    backtrack(0, &mut curr_combination, &digits_chars, &keypad_map, &mut result);
 
     result
 }
 
-fn phone_keypad_combinations_impl(
+fn backtrack(
     i: usize,
     curr_combination: &mut Vec<char>,
     digits: &Vec<char>,
@@ -45,7 +45,7 @@ fn phone_keypad_combinations_impl(
             curr_combination.push(letter);
 
             // Recursively explore all paths that branch from this combination.
-            phone_keypad_combinations_impl(i + 1, curr_combination, digits, keypad_map, result);
+            backtrack(i + 1, curr_combination, digits, keypad_map, result);
 
             // Backtrack by removing the letter we just added.
             curr_combination.pop();