数字分组求偶数和

1.问题描述

问题描述

小M面对一组从 1 到 9 的数字，这些数字被分成多个小组，并从每个小组中选择一个数字组成一个新的数。目标是使得这个新数的各位数字之和为偶数。任务是计算出有多少种不同的分组和选择方法可以达到这一目标。

• numbers: 一个由多个整数字符串组成的列表，每个字符串可以视为一个数字组。小M需要从每个数字组中选择一个数字。

例如对于[123, 456, 789]，14个符合条件的数为：147 149 158 167 169 248 257 259 268 347 349 358 367 369。

---

测试样例

样例1：

输入：numbers = [123, 456, 789]
输出：14

样例2：

输入：numbers = [123456789]
输出：4

样例3：

输入：numbers = [14329, 7568]
输出：10

2.思路与题解

问题理解

你需要从每个数字组中选择一个数字，使得这些数字的和为偶数。问题的核心在于如何判断一个数的和是否为偶数。

数据结构选择

• 输入是一个整数数组，每个整数可以转换为字符串来处理。
• 你需要遍历每个数字组，并从每个组中选择一个数字。

算法步骤

1. 转换输入：将整数数组转换为字符串数组，以便于处理每个数字组中的单个数字。
2. 递归遍历：使用递归函数来遍历每个数字组，并从每个组中选择一个数字。
3. 和的判断：在递归过程中，累加当前选择的数字，并在递归的终止条件处判断累加和是否为偶数。
4. 计数：如果累加和为偶数，则计数加一。

2.4代码框架

Java

public class Main {
    public static int solution(int[] numbers) {
        // 将整数数组转换为字符串数组
        String[] numStrings = new String[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            numStrings[i] = String.valueOf(numbers[i]);
        }
        
        // 调用递归函数进行计算
        return countEvenSumCombinations(numStrings, 0, 0);
    }

    // 递归函数，用于计算符合条件的组合数
    private static int countEvenSumCombinations(String[] numStrings, int index, int currentSum) {
        // 如果已经遍历完所有数字组
        if (index == numStrings.length) {
            // 检查当前和是否为偶数
            if (currentSum % 2 == 0) {
                return 1;
            } else {
                return 0;
            }
        }

        int count = 0;
        // 遍历当前数字组中的每个数字
        for (char digit : numStrings[index].toCharArray()) {
            // 将字符转换为数字
            int num = digit - '0';
            // 递归调用，选择下一个数字组
            count += countEvenSumCombinations(numStrings, index + 1, currentSum + num);
        }

        return count;
    }

    public static void main(String[] args) {
        // 测试用例
        System.out.println(solution(new int[]{123, 456, 789}) == 14);
        System.out.println(solution(new int[]{123456789}) == 4);
        System.out.println(solution(new int[]{14329, 7568}) == 10);
    }
}

C++

#include <iostream>
#include <vector>
#include <string>

int solution(std::vector<int> numbers) {
    int count = 0;
    
    // 遍历每个数字组
    for (int num : numbers) {
        std::string numStr = std::to_string(num);
        // 遍历数字组中的每个数字
        for (char digit : numStr) {
            // 计算和
            int sum = 0;
            // 计算各位数字之和
            // 判断和是否为偶数
            if (sum % 2 == 0) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    // You can add more test cases here
    std::cout << (solution({123, 456, 789}) == 14) << std::endl;
    std::cout << (solution({123456789}) == 4) << std::endl;
    std::cout << (solution({14329, 7568}) == 10) << std::endl;
    return 0;
}

Python

def solution(numbers):
    def is_even_sum(digits):
        # 检查一组数字的和是否为偶数
        return sum(digits) % 2 == 0

    def count_even_sum_combinations(index, current_digits):
        # 如果已经遍历完所有数字组
        if index == len(numbers):
            # 检查当前组合的和是否为偶数
            if is_even_sum(current_digits):
                return 1
            return 0
        
        count = 0
        # 遍历当前数字组中的每个数字
        for digit in str(numbers[index]):
            # 选择当前数字并递归处理下一个数字组
            count += count_even_sum_combinations(index + 1, current_digits + [int(digit)])
        
        return count

    # 从第一个数字组开始递归计算
    return count_even_sum_combinations(0, [])

if __name__ == "__main__":
    # 你可以添加更多测试用例
    print(solution([123, 456, 789]) == 14)
    print(solution([123456789]) == 4)
    print(solution([14329, 7568]) == 10)

Golang

package main

import "fmt"

func solution(numbers []int) int {
    // 辅助函数，用于判断一个数是否为偶数
    isEven := func(num int) bool {
        return num%2 == 0
    }

    // 递归函数，用于遍历所有可能的选择
    var dfs func(index int, currentSum int) int
    dfs = func(index int, currentSum int) int {
        // 如果已经遍历完所有数字组
        if index == len(numbers) {
            // 检查当前和是否为偶数
            if isEven(currentSum) {
                return 1
            }
            return 0
        }

        count := 0
        // 将当前数字组转换为字符串
        numStr := fmt.Sprintf("%d", numbers[index])
        // 遍历当前数字组中的每个数字
        for i := 0; i < len(numStr); i++ {
            // 将字符转换为数字
            digit := int(numStr[i] - '0')
            // 递归处理下一个数字组
            count += dfs(index+1, currentSum+digit)
        }
        return count
    }

    // 从第一个数字组开始递归
    return dfs(0, 0)
}

func main() {
    // 你可以添加更多测试用例
    fmt.Println(solution([]int{123, 456, 789}) == 14)
    fmt.Println(solution([]int{123456789}) == 4)
    fmt.Println(solution([]int{14329, 7568}) == 10)
}

2.5一些疑难的代码解释

1. 递归函数的设计：确保递归函数能够正确地遍历每个数字组，并累加当前选择的数字。
2. 和的判断：在递归的终止条件处，判断累加和是否为偶数。
3. 计数：如果累加和为偶数，则计数加一。

3.欢迎大佬们关注或莅临本渣的一些个人website

gitee： https://gitee.com/xiao-chenago
github：https://github.com/cool-icu0
语雀：https://www.yuque.com/icu0
csdn：https://cool-icu.blog.csdn.net/