std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0;

std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0;

std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0; std::string S, T; // 原始字符串S和目标字符串T std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化 // anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误） // luck: S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) { // 检查字符组合类型 if (S[i] == '1' && T[i] == '0') { anger++; // 统计需要纠正的错误 } else if (S[i] == '0' && T[i] == '0') { luck++; // 统计无需修改的匹配位置 } // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理 }

// 输出结果：错误数量 和 无需修改的幸运位置数量 std::cout << anger << " " << luck << std::endl;

return 0;

#include #include

int main() { int n; // 字符串长度 std::cin >> n; // 输入字符串长度

std::string S, T; // 原始字符串S和目标字符串T
std::cin >> S >> T; // 读取两个字符串

int anger = 0, luck = 0; // 计数器初始化
// anger: S中为'1'且T中为'0'的位置数量（通常表示需要修复的错误）
// luck:  S和T同时为'0'的位置数量（通常表示无需修改的幸运位置）

for (int i = 0; i < n; ++i) {
    // 检查字符组合类型
    if (S[i] == '1' && T[i] == '0') {
        anger++; // 统计需要纠正的错误
    } else if (S[i] == '0' && T[i] == '0') {
        luck++;  // 统计无需修改的匹配位置
    }
    // 其他组合情况（如S=0/T=1 或 S=1/T=1）无需处理
}

// 输出结果：错误数量 和 无需修改的幸运位置数量
std::cout << anger << " " << luck << std::endl;

return 0;

} 以下是注释

本题要求根据两个二进制字符串 $S$ 和 $T$ 计算生气程度和侥幸程度。可以通过遍历两个字符串，根据每个位置的字符值进行相应的统计。遍历字符串 $S$ 和 $T$ 的每个位置 $i$：如果 (S[i]) 为 1 且 (T[i]) 为 $0$，说明老师抽查到了未完成的作业，生气程度 $anger$ 加 $1$。如果 (S[i]) 为 $0$ 且 (T[i]) 为 $0$，说明老师未抽查且学生未完成作业，侥幸程度 $luck$ 加 $1$。输出生气程度和侥幸程度。

#include <iostream>
#include <string>

int main() {
    int n;
    std::cin >> n;

    std::string S, T;
    std::cin >> S >> T;

    int anger = 0, luck = 0;
    for (int i = 0; i < n; ++i) {
        if (S[i] == '1' && T[i] == '0') {
            anger++;
        } else if (S[i] == '0' && T[i] == '0') {
            luck++;
        }
    }

    std::cout << anger << " " << luck << std::endl;

    return 0;
}