计算1到100中偶数的和，计算1到100中奇数的平均数，使用while完成

计算1到100中偶数的和，计算1到100中奇数的平均数，使用while完成。

以下是代码：

even_sum = 0
odd_sum = 0
odd_count = 0
i = 1

while i <= 100:
    if i % 2 == 0:
        even_sum += i
    else:
        odd_sum += i
        odd_count += 1
    i += 1

odd_avg = odd_sum / odd_count

print("1到100中偶数的和为：", even_sum)
print("1到100中奇数的平均数为：", odd_avg)

输出结果为：

1到100中偶数的和为： 2550
1到100中奇数的平均数为： 50.0

相关问题

有两个线程，线程一的工作任务是计算0-100中偶数的累加和，线程二的任务是计算0-100中奇数的累加和，主线程main需要完成0-100的累加和的任务，main中不允许自行计算0-100的累加和，需要合理调用相应功能的线程完成它的任务。使用java

在Java中，可以使用`ExecutorService`和`Callable`或`Future`来实现这种场景。这里我们可以创建两个线程池，每个线程池对应一个线程执行计算。下面是一个简单的示例：

import java.util.concurrent.*;

public class SumCalculator {
    private static ExecutorService executor = Executors.newFixedThreadPool(2); // 创建固定大小的线程池

    public static void main(String[] args) {
        Future<Integer> evenSumTask = submitEvenNumbers();
        Future<Integer> oddSumTask = submitOddNumbers();

        try {
            int totalSum = evenSumTask.get() + oddSumTask.get(); // 等待两个结果都获取到
            System.out.println("Total sum of 0-100 is: " + totalSum);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown(); // 关闭线程池
        }
    }

    private static Future<Integer> submitEvenNumbers() {
        return executor.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <= 100; i += 2) {
                    sum += i;
                }
                return sum;
            }
        });
    }

    private static Future<Integer> submitOddNumbers() {
        return executor.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 100; i += 2) {
                    sum += i;
                }
                return sum;
            }
        });
    }
}

在这个例子中，`submitEvenNumbers()` 和 `submitOddNumbers()` 分别提交了计算偶数和奇数累加和的任务。`main` 线程通过`get()`方法阻塞地等待两个`Future`的结果，最后将它们相加得到总和。

有两个线程，线程一的工作任务是计算0-100中偶数的累加和，线程二任务是计算0-100中奇数的累加和，主线程main需要完成0-100的累加和的任务，main中不允许自行计算0-100的累加和，需要合理调用相应功能的线程完成它的任务，用Java代码完成

在Java中，你可以使用`ExecutorService`和`Callable`接口来实现这个需求，因为`Callable`允许异步计算并返回结果。首先，创建两个实现了`Callable<Long>`的类，分别处理偶数和奇数的累加。然后，用`Future`获取计算结果。

import java.util.concurrent.*;

public class SumCalculator implements Callable<Long> {
    private final int start;
    private final int end;

    public SumCalculator(int start, int end) {
        this.start = start;
        this.end = end;
        if (start % 2 == 0) {
            // 如果起始值是偶数，那么它应该被包含在内
            this.end--;
        }
    }

    @Override
    public Long call() throws Exception {
        long sum = 0;
        for (int i = start; i <= end; i += 2) { // 只对偶数或奇数累加
            sum += i;
        }
        return sum;
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2); // 创建一个固定大小的线程池

        Future<Long> evenSumTask = executor.submit(new SumCalculator(0, 50)); // 计算0-50的偶数累加和
        Future<Long> oddSumTask = executor.submit(new SumCalculator(1, 99)); // 计算0-99的奇数累加和，忽略100

        try {
            long totalSum = evenSumTask.get() + oddSumTask.get(); // 获取结果并相加
            System.out.println("Total sum from 0 to 100 is: " + totalSum);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown(); // 关闭线程池
        }
    }
}

在这个例子中，`main`线程不会直接计算累加和，而是将任务提交给线程池，让每个线程独立地计算它们负责的部分。当所有任务完成后，主线程会合并计算结果。注意，如果想要计算100也被包含在内的奇数和，你需要稍微调整`SumCalculator`类。