0 0 0 0
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

128
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

129 130 129 130
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

-2
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

def closest_to_median(img):
    # 初始化最优的调整值和最小差值
    best_k = None
    min_diff = float('inf')

    # 遍历可能的调整值k，范围是[-127, 128]
    for k in range(-127, 129):
        # 调整像素值，确保结果在[0, 255]范围内
        adjusted_img = [max(0, min(255, p + k)) for p in img]

        # 计算调整后的像素值的平均值
        avg_val = sum(adjusted_img) / len(img)

        # 计算平均值与目标128的绝对差值
        diff = abs(avg_val - 128)

        # 如果当前调整后的差值更小，或者在差值相等时k更小，则更新最优解
        if diff < min_diff or (diff == min_diff and (best_k is None or k < best_k)):
            min_diff = diff
            best_k = k

    # 返回最优调整值
    return best_k

# 读取像素值作为输入
pixels = list(map(int, input().split()))

# 输出计算出的最优调整值
print(closest_to_median(pixels))

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 读取输入的像素值，以空格分隔
        String str = sc.nextLine();
        int[] pixels = Arrays.stream(str.split(" ")).mapToInt(Integer::parseInt).toArray();

        // 输出最优的调整值 k
        System.out.println(findBestK(pixels));
    }

    // 找到使调整后平均值最接近128的最佳k值
    public static int findBestK(int[] pixels) {
        int left = -127, right = 128; // 搜索范围
        int bestK = 0;               // 记录当前最佳的k值
        double bestDiff = Double.MAX_VALUE; // 当前最小的与128的差异

        // 二分搜索
        while (left <= right) {
            int mid = (left + right) / 2; // 计算中间值k
            double currentAvg = calculateAvg(pixels, mid); // 计算调整后的平均值

            // 计算当前调整值与目标128的绝对差
            double diff = Math.abs(currentAvg - 128);

            // 更新最优k值，如果差值更小，或者在差值相等时k更小
            if (diff < bestDiff || (diff == bestDiff && mid < bestK)) {
                bestDiff = diff;
                bestK = mid;
            }

            // 根据调整后的平均值与128的大小关系调整搜索范围
            if (currentAvg < 128) {
                left = mid + 1; // 平均值小于128，增加k
            } else {
                right = mid - 1; // 平均值大于等于128，减小k
            }
        }

        return bestK; // 返回最佳k值
    }

    // 计算调整后的平均值
    public static double calculateAvg(int[] pixels, int k) {
        double sum = 0;

        // 遍历所有像素值，进行调整并计算总和
        for (int pixel : pixels) {
            int newVal = Math.max(0, Math.min(pixel + k, 255)); // 确保调整后的值在[0, 255]范围内
            sum += newVal;
        }

        // 返回调整后的平均值
        return sum / pixels.length;
    }
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61

C++解法

• 解题思路

更新中
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
1

C解法

• 解题思路

更新中
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
1

JS解法

• 解题思路

• 目标： 找到一个调整值 k，使调整后的数组中所有像素值的平均值尽可能接近 128。
  像素值调整规则：
  每个像素值 arr[i] 被调整为 newVal = Math.min(255, Math.max(0, arr[i] + k))，确保调整后的像素值在 [0, 255] 范围内。
  搜索范围：
  使用二分搜索在 [-127, 128] 范围内寻找最优的调整值 k。
  优化准则：
  目标是让调整后数组的平均值与128的绝对差值最小。
  如果差值相等，选择较小的 k。
  二分搜索过程：
  计算当前中间值 mid 的调整后平均值与128的差异。
  根据与128的关系调整搜索范围。
  最终返回：
  找到的最优调整值 k。

const readline = require("readline");

// 创建命令行接口，监听输入
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

// 监听每行输入
rl.on("line", (line) => {
  // 将输入的字符串转为整数数组
  const arr = line.split(" ").map(Number);

  // 调用函数计算最优调整值k并输出
  console.log(findOptimalK(arr));
});

// 主函数：找到最优的调整值k
function findOptimalK(arr) {
  let left = -127, right = 128; // 二分搜索范围
  let bestK = 0, bestDiff = Infinity; // 最优k值和当前最小差值

  // 二分搜索
  while (left <= right) {
    let mid = Math.floor((left + right) / 2); // 计算当前中间值
    const diffMid = calculateDiff(arr, mid); // 当前k对应的绝对差

    // 如果当前差值更小，更新最优k值；如果差值相等，选择较小的k
    if (diffMid < bestDiff) {
      bestDiff = diffMid;
      bestK = mid;
    } else if (diffMid === bestDiff) {
      bestK = Math.min(bestK, mid);
    }

    // 调整搜索范围，根据左右相邻差值大小进行移动
    if (calculateDiff(arr, mid - 1) < diffMid) {
      right = mid - 1;
    } else {
      left = mid + 1;
    }
  }

  return bestK; // 返回最优k值
}

// 辅助函数：计算调整后与128的绝对差
function calculateDiff(arr, k) {
  let sum = 0;

  // 遍历数组，对每个像素值进行调整
  for (let i = 0; i < arr.length; i++) {
    let newVal = arr[i] + k; // 调整像素值
    newVal = newVal < 0 ? 0 : newVal > 255 ? 255 : newVal; // 确保调整后的值在[0, 255]范围内
    sum += newVal; // 累加调整后的像素值
  }

  // 返回调整后平均值与128的绝对差
  return Math.abs(sum / arr.length - 128);
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

注意：

如果发现代码有用例覆盖不到的情况，欢迎反馈！会在第一时间修正，更新。
解题不易，如对您有帮助，欢迎点赞/收藏

发表评论

登录后才能发表评论和回复 注册

/ 登录

提交评论

评论记录：

未查询到任何数据！

回复评论：

×

关闭 提交评论