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; 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;