mirror of
https://github.com/krahets/hello-algo.git
synced 2026-07-09 05:56:06 +00:00
Translate all code to English (#1836)
* Review the EN heading format. * Fix pythontutor headings. * Fix pythontutor headings. * bug fixes * Fix headings in **/summary.md * Revisit the CN-to-EN translation for Python code using Claude-4.5 * Revisit the CN-to-EN translation for Java code using Claude-4.5 * Revisit the CN-to-EN translation for Cpp code using Claude-4.5. * Fix the dictionary. * Fix cpp code translation for the multipart strings. * Translate Go code to English. * Update workflows to test EN code. * Add EN translation for C. * Add EN translation for CSharp. * Add EN translation for Swift. * Trigger the CI check. * Revert. * Update en/hash_map.md * Add the EN version of Dart code. * Add the EN version of Kotlin code. * Add missing code files. * Add the EN version of JavaScript code. * Add the EN version of TypeScript code. * Fix the workflows. * Add the EN version of Ruby code. * Add the EN version of Rust code. * Update the CI check for the English version code. * Update Python CI check. * Fix cmakelists for en/C code. * Fix Ruby comments
This commit is contained in:
Yudong Jin
@@ -6,7 +6,7 @@
|
||||
|
||||
#include "../utils/common.hpp"
|
||||
|
||||
/* Backtracking algorithm: n queens */
|
||||
/* Backtracking algorithm: N queens */
|
||||
void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vector<string>>> &res, vector<bool> &cols,
|
||||
vector<bool> &diags1, vector<bool> &diags2) {
|
||||
// When all rows are placed, record the solution
|
||||
@@ -16,30 +16,30 @@ void backtrack(int row, int n, vector<vector<string>> &state, vector<vector<vect
|
||||
}
|
||||
// Traverse all columns
|
||||
for (int col = 0; col < n; col++) {
|
||||
// Calculate the main and minor diagonals corresponding to the cell
|
||||
// Calculate the main diagonal and anti-diagonal corresponding to this cell
|
||||
int diag1 = row - col + n - 1;
|
||||
int diag2 = row + col;
|
||||
// Pruning: do not allow queens on the column, main diagonal, or minor diagonal of the cell
|
||||
// Pruning: do not allow queens to exist in the column, main diagonal, and anti-diagonal of this cell
|
||||
if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
|
||||
// Attempt: place the queen in the cell
|
||||
// Attempt: place the queen in this cell
|
||||
state[row][col] = "Q";
|
||||
cols[col] = diags1[diag1] = diags2[diag2] = true;
|
||||
// Place the next row
|
||||
backtrack(row + 1, n, state, res, cols, diags1, diags2);
|
||||
// Retract: restore the cell to an empty spot
|
||||
// Backtrack: restore this cell to an empty cell
|
||||
state[row][col] = "#";
|
||||
cols[col] = diags1[diag1] = diags2[diag2] = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Solve n queens */
|
||||
/* Solve N queens */
|
||||
vector<vector<vector<string>>> nQueens(int n) {
|
||||
// Initialize an n*n size chessboard, where 'Q' represents the queen and '#' represents an empty spot
|
||||
// Initialize an n*n chessboard, where 'Q' represents a queen and '#' represents an empty cell
|
||||
vector<vector<string>> state(n, vector<string>(n, "#"));
|
||||
vector<bool> cols(n, false); // Record columns with queens
|
||||
vector<bool> diags1(2 * n - 1, false); // Record main diagonals with queens
|
||||
vector<bool> diags2(2 * n - 1, false); // Record minor diagonals with queens
|
||||
vector<bool> cols(n, false); // Record whether there is a queen in the column
|
||||
vector<bool> diags1(2 * n - 1, false); // Record whether there is a queen on the main diagonal
|
||||
vector<bool> diags2(2 * n - 1, false); // Record whether there is a queen on the anti-diagonal
|
||||
vector<vector<vector<string>>> res;
|
||||
|
||||
backtrack(0, n, state, res, cols, diags1, diags2);
|
||||
@@ -52,8 +52,8 @@ int main() {
|
||||
int n = 4;
|
||||
vector<vector<vector<string>>> res = nQueens(n);
|
||||
|
||||
cout << "Input the dimensions of the chessboard as " << n << endl;
|
||||
cout << "Total number of queen placement solutions = " << res.size() << endl;
|
||||
cout << "Input board size is " << n << endl;
|
||||
cout << "Total queen placement solutions: " << res.size() << endl;
|
||||
for (const vector<vector<string>> &state : res) {
|
||||
cout << "--------------------" << endl;
|
||||
for (const vector<string> &row : state) {
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
#include "../utils/common.hpp"
|
||||
|
||||
/* Backtracking algorithm: Permutation I */
|
||||
/* Backtracking algorithm: Permutations I */
|
||||
void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
|
||||
// When the state length equals the number of elements, record the solution
|
||||
if (state.size() == choices.size()) {
|
||||
@@ -18,19 +18,19 @@ void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &sel
|
||||
int choice = choices[i];
|
||||
// Pruning: do not allow repeated selection of elements
|
||||
if (!selected[i]) {
|
||||
// Attempt: make a choice, update the state
|
||||
// Attempt: make choice, update state
|
||||
selected[i] = true;
|
||||
state.push_back(choice);
|
||||
// Proceed to the next round of selection
|
||||
backtrack(state, choices, selected, res);
|
||||
// Retract: undo the choice, restore to the previous state
|
||||
// Backtrack: undo choice, restore to previous state
|
||||
selected[i] = false;
|
||||
state.pop_back();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Permutation I */
|
||||
/* Permutations I */
|
||||
vector<vector<int>> permutationsI(vector<int> nums) {
|
||||
vector<int> state;
|
||||
vector<bool> selected(nums.size(), false);
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
#include "../utils/common.hpp"
|
||||
|
||||
/* Backtracking algorithm: Permutation II */
|
||||
/* Backtracking algorithm: Permutations II */
|
||||
void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &selected, vector<vector<int>> &res) {
|
||||
// When the state length equals the number of elements, record the solution
|
||||
if (state.size() == choices.size()) {
|
||||
@@ -19,20 +19,20 @@ void backtrack(vector<int> &state, const vector<int> &choices, vector<bool> &sel
|
||||
int choice = choices[i];
|
||||
// Pruning: do not allow repeated selection of elements and do not allow repeated selection of equal elements
|
||||
if (!selected[i] && duplicated.find(choice) == duplicated.end()) {
|
||||
// Attempt: make a choice, update the state
|
||||
duplicated.emplace(choice); // Record selected element values
|
||||
// Attempt: make choice, update state
|
||||
duplicated.emplace(choice); // Record the selected element value
|
||||
selected[i] = true;
|
||||
state.push_back(choice);
|
||||
// Proceed to the next round of selection
|
||||
backtrack(state, choices, selected, res);
|
||||
// Retract: undo the choice, restore to the previous state
|
||||
// Backtrack: undo choice, restore to previous state
|
||||
selected[i] = false;
|
||||
state.pop_back();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Permutation II */
|
||||
/* Permutations II */
|
||||
vector<vector<int>> permutationsII(vector<int> nums) {
|
||||
vector<int> state;
|
||||
vector<bool> selected(nums.size(), false);
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
|
||||
vector<TreeNode *> res;
|
||||
|
||||
/* Pre-order traversal: Example one */
|
||||
/* Preorder traversal: Example 1 */
|
||||
void preOrder(TreeNode *root) {
|
||||
if (root == nullptr) {
|
||||
return;
|
||||
@@ -27,7 +27,7 @@ int main() {
|
||||
cout << "\nInitialize binary tree" << endl;
|
||||
printTree(root);
|
||||
|
||||
// Pre-order traversal
|
||||
// Preorder traversal
|
||||
preOrder(root);
|
||||
|
||||
cout << "\nOutput all nodes with value 7" << endl;
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
vector<TreeNode *> path;
|
||||
vector<vector<TreeNode *>> res;
|
||||
|
||||
/* Pre-order traversal: Example two */
|
||||
/* Preorder traversal: Example 2 */
|
||||
void preOrder(TreeNode *root) {
|
||||
if (root == nullptr) {
|
||||
return;
|
||||
@@ -22,7 +22,7 @@ void preOrder(TreeNode *root) {
|
||||
}
|
||||
preOrder(root->left);
|
||||
preOrder(root->right);
|
||||
// Retract
|
||||
// Backtrack
|
||||
path.pop_back();
|
||||
}
|
||||
|
||||
@@ -32,10 +32,10 @@ int main() {
|
||||
cout << "\nInitialize binary tree" << endl;
|
||||
printTree(root);
|
||||
|
||||
// Pre-order traversal
|
||||
// Preorder traversal
|
||||
preOrder(root);
|
||||
|
||||
cout << "\nOutput all root-to-node 7 paths" << endl;
|
||||
cout << "\nOutput all paths from root node to node 7" << endl;
|
||||
for (vector<TreeNode *> &path : res) {
|
||||
vector<int> vals;
|
||||
for (TreeNode *node : path) {
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
vector<TreeNode *> path;
|
||||
vector<vector<TreeNode *>> res;
|
||||
|
||||
/* Pre-order traversal: Example three */
|
||||
/* Preorder traversal: Example 3 */
|
||||
void preOrder(TreeNode *root) {
|
||||
// Pruning
|
||||
if (root == nullptr || root->val == 3) {
|
||||
@@ -23,7 +23,7 @@ void preOrder(TreeNode *root) {
|
||||
}
|
||||
preOrder(root->left);
|
||||
preOrder(root->right);
|
||||
// Retract
|
||||
// Backtrack
|
||||
path.pop_back();
|
||||
}
|
||||
|
||||
@@ -33,10 +33,10 @@ int main() {
|
||||
cout << "\nInitialize binary tree" << endl;
|
||||
printTree(root);
|
||||
|
||||
// Pre-order traversal
|
||||
// Preorder traversal
|
||||
preOrder(root);
|
||||
|
||||
cout << "\nOutput all root-to-node 7 paths, requiring paths not to include nodes with value 3" << endl;
|
||||
cout << "\nOutput all paths from root node to node 7, requiring paths do not include nodes with value 3" << endl;
|
||||
for (vector<TreeNode *> &path : res) {
|
||||
vector<int> vals;
|
||||
for (TreeNode *node : path) {
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
#include "../utils/common.hpp"
|
||||
|
||||
/* Determine if the current state is a solution */
|
||||
/* Check if the current state is a solution */
|
||||
bool isSolution(vector<TreeNode *> &state) {
|
||||
return !state.empty() && state.back()->val == 7;
|
||||
}
|
||||
@@ -16,7 +16,7 @@ void recordSolution(vector<TreeNode *> &state, vector<vector<TreeNode *>> &res)
|
||||
res.push_back(state);
|
||||
}
|
||||
|
||||
/* Determine if the choice is legal under the current state */
|
||||
/* Check if the choice is valid under the current state */
|
||||
bool isValid(vector<TreeNode *> &state, TreeNode *choice) {
|
||||
return choice != nullptr && choice->val != 3;
|
||||
}
|
||||
@@ -31,23 +31,23 @@ void undoChoice(vector<TreeNode *> &state, TreeNode *choice) {
|
||||
state.pop_back();
|
||||
}
|
||||
|
||||
/* Backtracking algorithm: Example three */
|
||||
/* Backtracking algorithm: Example 3 */
|
||||
void backtrack(vector<TreeNode *> &state, vector<TreeNode *> &choices, vector<vector<TreeNode *>> &res) {
|
||||
// Check if it's a solution
|
||||
// Check if it is a solution
|
||||
if (isSolution(state)) {
|
||||
// Record solution
|
||||
recordSolution(state, res);
|
||||
}
|
||||
// Traverse all choices
|
||||
for (TreeNode *choice : choices) {
|
||||
// Pruning: check if the choice is legal
|
||||
// Pruning: check if the choice is valid
|
||||
if (isValid(state, choice)) {
|
||||
// Attempt: make a choice, update the state
|
||||
// Attempt: make choice, update state
|
||||
makeChoice(state, choice);
|
||||
// Proceed to the next round of selection
|
||||
vector<TreeNode *> nextChoices{choice->left, choice->right};
|
||||
backtrack(state, nextChoices, res);
|
||||
// Retract: undo the choice, restore to the previous state
|
||||
// Backtrack: undo choice, restore to previous state
|
||||
undoChoice(state, choice);
|
||||
}
|
||||
}
|
||||
@@ -65,7 +65,7 @@ int main() {
|
||||
vector<vector<TreeNode *>> res;
|
||||
backtrack(state, choices, res);
|
||||
|
||||
cout << "\nOutput all root-to-node 7 paths, requiring paths not to include nodes with value 3" << endl;
|
||||
cout << "\nOutput all paths from root node to node 7, requiring paths do not include nodes with value 3" << endl;
|
||||
for (vector<TreeNode *> &path : res) {
|
||||
vector<int> vals;
|
||||
for (TreeNode *node : path) {
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
#include "../utils/common.hpp"
|
||||
|
||||
/* Backtracking algorithm: Subset Sum I */
|
||||
/* Backtracking algorithm: Subset sum I */
|
||||
void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
|
||||
// When the subset sum equals target, record the solution
|
||||
if (target == 0) {
|
||||
@@ -14,23 +14,23 @@ void backtrack(vector<int> &state, int target, vector<int> &choices, int start,
|
||||
return;
|
||||
}
|
||||
// Traverse all choices
|
||||
// Pruning two: start traversing from start to avoid generating duplicate subsets
|
||||
// Pruning 2: start traversing from start to avoid generating duplicate subsets
|
||||
for (int i = start; i < choices.size(); i++) {
|
||||
// Pruning one: if the subset sum exceeds target, end the loop immediately
|
||||
// Pruning 1: if the subset sum exceeds target, end the loop directly
|
||||
// This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target
|
||||
if (target - choices[i] < 0) {
|
||||
break;
|
||||
}
|
||||
// Attempt: make a choice, update target, start
|
||||
// Attempt: make choice, update target, start
|
||||
state.push_back(choices[i]);
|
||||
// Proceed to the next round of selection
|
||||
backtrack(state, target - choices[i], choices, i, res);
|
||||
// Retract: undo the choice, restore to the previous state
|
||||
// Backtrack: undo choice, restore to previous state
|
||||
state.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
/* Solve Subset Sum I */
|
||||
/* Solve subset sum I */
|
||||
vector<vector<int>> subsetSumI(vector<int> &nums, int target) {
|
||||
vector<int> state; // State (subset)
|
||||
sort(nums.begin(), nums.end()); // Sort nums
|
||||
@@ -50,7 +50,7 @@ int main() {
|
||||
cout << "Input array nums = ";
|
||||
printVector(nums);
|
||||
cout << "target = " << target << endl;
|
||||
cout << "All subsets summing to " << target << "is" << endl;
|
||||
cout << "All subsets with sum equal to " << target << " are res = " << endl;
|
||||
printVectorMatrix(res);
|
||||
|
||||
return 0;
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
#include "../utils/common.hpp"
|
||||
|
||||
/* Backtracking algorithm: Subset Sum I */
|
||||
/* Backtracking algorithm: Subset sum I */
|
||||
void backtrack(vector<int> &state, int target, int total, vector<int> &choices, vector<vector<int>> &res) {
|
||||
// When the subset sum equals target, record the solution
|
||||
if (total == target) {
|
||||
@@ -15,20 +15,20 @@ void backtrack(vector<int> &state, int target, int total, vector<int> &choices,
|
||||
}
|
||||
// Traverse all choices
|
||||
for (size_t i = 0; i < choices.size(); i++) {
|
||||
// Pruning: if the subset sum exceeds target, skip that choice
|
||||
// Pruning: if the subset sum exceeds target, skip this choice
|
||||
if (total + choices[i] > target) {
|
||||
continue;
|
||||
}
|
||||
// Attempt: make a choice, update elements and total
|
||||
// Attempt: make choice, update element sum total
|
||||
state.push_back(choices[i]);
|
||||
// Proceed to the next round of selection
|
||||
backtrack(state, target, total + choices[i], choices, res);
|
||||
// Retract: undo the choice, restore to the previous state
|
||||
// Backtrack: undo choice, restore to previous state
|
||||
state.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
/* Solve Subset Sum I (including duplicate subsets) */
|
||||
/* Solve subset sum I (including duplicate subsets) */
|
||||
vector<vector<int>> subsetSumINaive(vector<int> &nums, int target) {
|
||||
vector<int> state; // State (subset)
|
||||
int total = 0; // Subset sum
|
||||
@@ -47,7 +47,7 @@ int main() {
|
||||
cout << "Input array nums = ";
|
||||
printVector(nums);
|
||||
cout << "target = " << target << endl;
|
||||
cout << "All subsets summing to " << target << "is" << endl;
|
||||
cout << "All subsets with sum equal to " << target << " are res = " << endl;
|
||||
printVectorMatrix(res);
|
||||
|
||||
return 0;
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
|
||||
#include "../utils/common.hpp"
|
||||
|
||||
/* Backtracking algorithm: Subset Sum II */
|
||||
/* Backtracking algorithm: Subset sum II */
|
||||
void backtrack(vector<int> &state, int target, vector<int> &choices, int start, vector<vector<int>> &res) {
|
||||
// When the subset sum equals target, record the solution
|
||||
if (target == 0) {
|
||||
@@ -14,28 +14,28 @@ void backtrack(vector<int> &state, int target, vector<int> &choices, int start,
|
||||
return;
|
||||
}
|
||||
// Traverse all choices
|
||||
// Pruning two: start traversing from start to avoid generating duplicate subsets
|
||||
// Pruning three: start traversing from start to avoid repeatedly selecting the same element
|
||||
// Pruning 2: start traversing from start to avoid generating duplicate subsets
|
||||
// Pruning 3: start traversing from start to avoid repeatedly selecting the same element
|
||||
for (int i = start; i < choices.size(); i++) {
|
||||
// Pruning one: if the subset sum exceeds target, end the loop immediately
|
||||
// Pruning 1: if the subset sum exceeds target, end the loop directly
|
||||
// This is because the array is sorted, and later elements are larger, so the subset sum will definitely exceed target
|
||||
if (target - choices[i] < 0) {
|
||||
break;
|
||||
}
|
||||
// Pruning four: if the element equals the left element, it indicates that the search branch is repeated, skip it
|
||||
// Pruning 4: if this element equals the left element, it means this search branch is duplicate, skip it directly
|
||||
if (i > start && choices[i] == choices[i - 1]) {
|
||||
continue;
|
||||
}
|
||||
// Attempt: make a choice, update target, start
|
||||
// Attempt: make choice, update target, start
|
||||
state.push_back(choices[i]);
|
||||
// Proceed to the next round of selection
|
||||
backtrack(state, target - choices[i], choices, i + 1, res);
|
||||
// Retract: undo the choice, restore to the previous state
|
||||
// Backtrack: undo choice, restore to previous state
|
||||
state.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
/* Solve Subset Sum II */
|
||||
/* Solve subset sum II */
|
||||
vector<vector<int>> subsetSumII(vector<int> &nums, int target) {
|
||||
vector<int> state; // State (subset)
|
||||
sort(nums.begin(), nums.end()); // Sort nums
|
||||
@@ -55,7 +55,7 @@ int main() {
|
||||
cout << "Input array nums = ";
|
||||
printVector(nums);
|
||||
cout << "target = " << target << endl;
|
||||
cout << "All subsets summing to " << target << "is" << endl;
|
||||
cout << "All subsets with sum equal to " << target << " are res = " << endl;
|
||||
printVectorMatrix(res);
|
||||
|
||||
return 0;
|
||||
|
||||
Reference in New Issue
Block a user