E卷-(100分)简单的自动曝光

简单的自动曝光

问题描述

给定一个长度为 的整数数组 ，表示一张图像的像素值，每个像素值的范围是 的整数。现在需要给每个像素值加上一个整数 （可以是负数），得到新的图像 ，使得 中所有像素的平均值最接近中位值 128。请计算并输出这个整数 。

输入格式

一行 个整数，用空格分隔，表示原图像 的像素值。

输出格式

一个整数 。

样例输入

样例 1

0 0 0 0

样例 2

129 130 129 130

样例输出

样例 1

128

样例 2

-2

样例解释

样例 1

原图像的四个像素值都为 0，加上 128 后，新图像的所有像素值变为 128，平均值正好是 128。

样例 2

当 时，新图像为 128 129 128 129，平均值为 128.5。 当 时，新图像为 127 128 127 128，平均值为 127.5。 两种情况下，127.5 更接近 128，且 -2 小于 -1，所以输出 -2。

数据范围

• 
• 如果有多个整数 都满足条件，输出较小的那个 。
• 新图像的像素值会自动截取到 范围。当新像素值 时，其值会更改为 0；当新像素值 时，其值会更改为 255。

题解

这道题目的核心是找到一个整数 ，使得加上 后的新图像像素平均值最接近 128。

解题思路如下：

1. 读取输入的像素值数组。
2. 遍历可能的 值范围（-128 到 128）。
3. 对于每个 ，计算新图像的平均值。
4. 找出使平均值最接近 128 的 。

关键点在于处理像素值的边界情况。当新像素值小于 0 时，要将其设为 0；大于 255 时，要将其设为 255。这可以通过 max(0, min(255, val + i)) 来实现。

• Python

# 读取输入
v = list(map(int, input().split()))
n = len(v)

res = float('inf')  # 初始化结果为无穷大
k = 0  # 初始化 k 为 0

# 遍历可能的 k 值
for i in range(-128, 129):
    su = 0
    # 计算新图像的像素和
    for val in v:
        su += max(0, min(255, val + i))
    # 计算平均值与 128 的差距
    t = abs(su / n - 128)
    # 更新结果
    if t < res:
        res = t
        k = i

# 输出结果
print(k)

• C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX_N 100

int main() {
    int v[MAX_N];
    int n = 0;
    int x;

    // 读取输入
    while (scanf("%d", &x) == 1) {
        v[n++] = x;
    }

    double res = 1e9;
    int k = 0;

    // 遍历可能的 k 值
    for (int i = -128; i <= 128; i++) {
        int su = 0;
        // 计算新图像的像素和
        for (int j = 0; j < n; j++) {
            int val = v[j] + i;
            su += (val < 0) ? 0 : (val > 255) ? 255 : val;
        }
        // 计算平均值与 128 的差距
        double t = fabs((double)su / n - 128);
        // 更新结果
        if (t < res) {
            res = t;
            k = i;
        }
    }

    // 输出结果
    printf("%d\n", k);

    return 0;
}

• Javascript

const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.on('line', (line) => {
    // 读取输入
    const v = line.split(' ').map(Number);
    const n = v.length;

    let res = Infinity;
    let k = 0;

    // 遍历可能的 k 值
    for (let i = -128; i <= 128; i++) {
        let su = 0;
        // 计算新图像的像素和
        for (const val of v) {
            su += Math.max(0, Math.min(255, val + i));
        }
        // 计算平均值与 128 的差距
        const t = Math.abs(su / n - 128);
        // 更新结果
        if (t < res) {
            res = t;
            k = i;
        }
    }

    // 输出结果
    console.log(k);
    rl.close();
});

• Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] input = scanner.nextLine().split(" ");
        int[] v = new int[input.length];
        
        // 读取输入
        for (int i = 0; i < input.length; i++) {
            v[i] = Integer.parseInt(input[i]);
        }
        
        int n = v.length;
        double res = Double.MAX_VALUE;
        int k = 0;

        // 遍历可能的 k 值
        for (int i = -128; i <= 128; i++) {
            int su = 0;
            // 计算新图像的像素和
            for (int val : v) {
                su += Math.max(0, Math.min(255, val + i));
            }
            // 计算平均值与 128 的差距
            double t = Math.abs((double) su / n - 128);
            // 更新结果
            if (t < res) {
                res = t;
                k = i;
            }
        }

        // 输出结果
        System.out.println(k);
        scanner.close();
    }
}

• Cpp

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

int main() {
    int x;
    vector<int> v;
    
    // 读取输入
    while (cin >> x) {
        v.push_back(x);
    }
    
    int n = v.size();
    double res = 1e9;
    int k = 0;
    
    // 遍历可能的 k 值
    for (int i = -128; i <= 128; i++) {
        int su = 0;
        // 计算新图像的像素和
        for (int& val : v) {
            su += max(0, min(255, val + i));
        }
        // 计算平均值与 128 的差距
        double t = abs(su * 1.0 / n - 128);
        // 更新结果
        if (t < res) {
            res = t;
            k = i;
        }
    }
    
    // 输出结果
    cout << k << "\n";
    return 0;
}