抄袭可耻，尊重原创

抄袭者的博客主页链接：MISAYAONE_OD机试 Py/Java/JS合集（A卷+B卷）,华为OD机试（JAVA）真题（A卷+B卷）,华为OD机试（Python）真题（A卷+B卷）-CSDN博客

这个博主一直在抄袭我的内容，年初的时候已经私聊警告过了，但是对方并没有回应，后面举报了才稍微收敛一点，

最近一段时间由于工作问题，一直没有关注过他，直到一些考友提醒，才发现他又开始抄袭了

早上上班的时候举报了一些，实在太多了，手都举报疼了。

下面展示一些博客代码，请大家帮忙看看是不是抄袭：

例子一（Java）

原创代码（伏城之外）

华为OD机试 - 最佳的出牌方法（Java & JS & Python）_伏城之外的博客-CSDN博客

import java.util.Scanner;
 
public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println(getResult(sc.nextLine()));
  }
 
  public static int getResult(String cards) {
    // 数组索引是牌面分数, 数组元素是牌面数量, 其中 0 索引不用
    int[] card_count = new int[14];
 
    // 统计各种牌的数量
    for (int i = 0; i < cards.length(); i++) {
      char card = cards.charAt(i);
 
      // 1-9输入为数字1-9，10输入为数字0，JQK输入为大写字母JQK
      // 1-9 牌面分数就是 1-9, 0的牌面分数是 10, J=11,Q=12,K=13, 可以发现牌面分数是连续的，可以和card_count数组的索引对应起来
      if (card == '0') card_count[10]++;
      else if (card == 'J') card_count[11]++;
      else if (card == 'Q') card_count[12]++;
      else if (card == 'K') card_count[13]++;
      else card_count[card - '0']++;
    }
 
    return getMaxScore(card_count);
  }
 
  // 获取牌的最大得分
  public static int getMaxScore(int[] card_count) {
    // 记录最大得分
    int score = 0;
 
    // 找顺子, 可能找出一副顺子后，剩余牌还能找出顺子，因此需要while循环找
    while (true) {
      // 五张连续牌 要是组成顺子 的增值分数 > 0, 则可以尝试组成顺子, 否则各论各的得分更高
      int maxProfit = 0;
 
      // 顺子的起始位置, card_count[0]是无用的，因此l=0表示没有顺子
      int l = 0;
 
      // 顺子起始位置只能是1~9, 因为12345是最先顺子, 90JQK是最后顺子
      for (int i = 1; i <= 9; i++) {
        // 组成顺子可得的增值分数
        int profit = getProfitForShunZi(card_count, i);
 
        // 一轮只找一个顺子，且需要找增值分数最大的那个顺子
        if (profit > maxProfit) {
          // 记录最优顺子的增值分数
          maxProfit = profit;
          // 记录最优顺子的起始位置
          l = i;
        }
      }
 
      // 如果本轮没有找到顺子, 则结束找顺子
      if (l == 0) break;
 
      // 找到顺子，则加入顺子分数，并从card_count中去掉顺子占用的牌
      for (int i = l; i <= l + 4; i++) {
        score += i * 2; // 顺子每张牌得分*2
        card_count[i]--;
      }
    }
 
    // 找完所有顺子后, 剩余牌各论各的得分
    for (int i = 1; i <= 13; i++) {
      score += getScore(card_count, i);
    }
 
    return score;
  }
 
  // 五张连续牌组成顺子 可获得的 增值分数
  public static int getProfitForShunZi(int[] card_count, int l) {
    int profit = 0;
 
    for (int i = l; i <= l + 4; i++) {
      // 如果给定l,r区间无法组成顺子, 则没有好处
      if (card_count[i] == 0) return Integer.MIN_VALUE;
 
      switch (card_count[i]) {
        case 1:
          profit += i; // 单张 成为顺子一部分，则增值分数 i
          break;
        case 2:
          profit -= i; // 对子 拆出一张给顺子, 剩余一张变成单张，则增值分数 -i
          break;
        case 4:
          profit -= i * 4; // 炸弹 拆出一张给顺子，剩余三张变成三张，则增值分数 -4i
          break;
      }
    }
 
    return profit;
  }
 
  // 各论各的得分
  public static int getScore(int[] card_count, int i) {
    int score = 0;
 
    switch (card_count[i]) {
      case 1:
        score += i; // 单张得分： i
        break;
      case 2:
      case 3:
        score += i * card_count[i] * 2; // 对子、三张 得分：i * 牌数量 * 2
        break;
      case 4:
        score += i * card_count[i] * 3; // 炸弹得分：i * 牌数量 * 3
        break;
    }
 
    return score;
  }
}

抄袭代码（MISAYAONE）

2023华为od机试真题B卷【最佳的出牌方法】Java 实现_MISAYAONE的博客-CSDN博客

import java.util.Scanner;

public class Main {
  public static int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

  public static void main(String[] args) {
    // 处理输入
    Scanner in = new Scanner(System.in);
    String cards = in.nextLine();
    // 数组模拟hashmap
    int[] card_count = new int[14];

    // 统计各种牌的数量
    for (int i = 0; i < cards.length(); i++) {
      char card = cards.charAt(i);
      if (card == '0') card_count[10]++;
      else if (card == 'J') card_count[11]++;
      else if (card == 'Q') card_count[12]++;
      else if (card == 'K') card_count[13]++;
      else card_count[card - '0']++;
    }

    int score = 0;

    // 找顺子
    while (true) {
      int maxextraScore = 0;

      int start_pos = 0;

      for (int i = 1; i <= 9; i++) {
        int extraScore = getextraScoreForShunZi(card_count, i);

        // 一轮只找一个顺子，且需要找增值分数最大的那个顺子
        if (extraScore > maxextraScore) {
          maxextraScore = extraScore;
          // 记录最优顺子的起始位置
          start_pos = i;
        }
      }

      // 没有找到顺子
      if (start_pos == 0) break;

      for (int i = start_pos; i <= start_pos + 4; i++) {
        score += i * 2;
        card_count[i]--;
      }
    }

    for (int i = 1; i <= 13; i++) {
      score += getScore(card_count, i);
    }

    System.out.println(score);
    return;
  }

  public static int getextraScoreForShunZi(int[] card_count, int l) {
    int extraScore = 0;

    for (int i = l; i <= l + 4; i++) {
      if (card_count[i] == 0) {
        return Integer.MIN_VALUE;
      }

      switch (card_count[i]) {
        case 1:
          extraScore += i; // 单张 成为顺子一部分，则增值分数 i
          break;
        case 2:
          extraScore -= i; // 对子 拆出一张给顺子, 剩余一张变成单张，则增值分数 -i
          break;
        case 4:
          extraScore -= i * 4; // 炸弹 拆出一张给顺子，剩余三张变成三张，则增值分数 -4i
          break;
      }
    }

    return extraScore;
  }

  public static int getScore(int[] card_count, int i) {
    int score = 0;

    switch (card_count[i]) {
      case 1:
        score += i; // 单张得分： i
        break;
      case 2:
      case 3:
        score += i * card_count[i] * 2; // 对子、三张 得分：i * 牌数量 * 2
        break;
      case 4:
        score += i * card_count[i] * 3; // 炸弹得分：i * 牌数量 * 3
        break;
    }

    return score;
  }
}

例子二（Java）

原创代码（伏城之外）

华为OD机试 - 购物（Java & JS & Python）_伏城之外的博客-CSDN博客

import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Scanner;
 
public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
 
    int n = sc.nextInt();
    int k = sc.nextInt();
 
    int[] nums = new int[n];
    for (int j = 0; j < n; j++) {
      nums[j] = sc.nextInt();
    }
 
    getResult(n, k, nums);
  }
 
  static class CombineModel {
    int curSum; // 当前组合之和
    int nextIdx; // 将要被加入当前组合的新元素索引位置
 
    public CombineModel(int curSum, int nextIdx) {
      this.curSum = curSum;
      this.nextIdx = nextIdx;
    }
  }
 
  public static void getResult(int n, int m, int[] nums) {
    Arrays.sort(nums);
 
    // 对于一个组合模型，其”将要产生的新组合“之和越小，则优先级越高
    // curSum + nums[nextIdx] 为 ”将要产生的新组合“之和
    PriorityQueue<CombineModel> pq =
        new PriorityQueue<>((a, b) -> a.curSum + nums[a.nextIdx] - (b.curSum + nums[b.nextIdx]));
 
    // 空组合的和为0, 将要加入的新元素是nums[0], 即索引0的元素，其将要产生的新组合之和为 0 + nums[0]
    CombineModel c = new CombineModel(0, 0);
 
    for (int i = 1; i <= m; i++) {
      // 打印第 i 小组合
      System.out.println(c.curSum + nums[c.nextIdx]);
 
      // c是当前最小组合模型，最小的组合模型指的是将要产生的新组合之和在对应轮次中最小
      // 如果当前组合模型c还有可合入的下一个元素，即c.nextIdx + 1 < n, 则说明可以基于当前组合模型产生一个新组合
      if (c.nextIdx + 1 < n) {
        // 基于当前组合模型产生的新组合，也是本轮最小的组合，即第 i 小组合
        pq.offer(new CombineModel(c.curSum + nums[c.nextIdx], c.nextIdx + 1));
 
        // 当前组合需要更新nextIdx后，重新加入优先队列
        c.nextIdx += 1;
        pq.offer(c);
      }
 
      // 取出优先队列中最小组合（注意这里的最小，指的是基于当前组合，将要产生的新组合之和最小）
      c = pq.poll();
    }
  }
}

抄袭代码（MISAYAONE）

2023华为机试真题B卷 Java 实现【购物】_MISAYAONE的博客-CSDN博客

import java.util.Scanner;
import java.util.*;
 
public class Main { 
    static class Node {
        int now_sum; // 当前和
        int next_idx; // 下一个元素位置
    
        public Node(int now_sum, int next_idx) {
            this.now_sum = now_sum;
            this.next_idx = next_idx;
        }
    }
    public static void main(String[] args) { 
        //处理输入
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
    
        int[] nums = new int[n];
        for (int j = 0; j < n; j++) {
            nums[j] = in.nextInt();
        }
 
        //这一步排序时必须的
        Arrays.sort(nums);
 
        PriorityQueue<Node> pq =
            new PriorityQueue<>((a, b) -> a.now_sum + nums[a.next_idx] - (b.now_sum + nums[b.next_idx]));
    
        // 初始化时和为0, 下一个元素的索引值是0
        Node c = new Node(0, 0);
    
        for (int i = 1; i <= m; i++) {
            System.out.println(c.now_sum + nums[c.next_idx]);
    
            if (c.next_idx + 1 < n) {
                pq.offer(new Node(c.now_sum + nums[c.next_idx], c.next_idx + 1));
        
                // 更新索引并重新入队列
                c.next_idx += 1;
                pq.offer(c);
            }
    
            c = pq.poll();
        }
    
    
    }
}

例子三（JS）

原创代码（伏城之外）

华为OD机试 - 竖直四子棋（Java & JS & Python）_竖直四子棋】竖直四子棋的棋盘是竖立起来的,双方轮流选择棋盘的一列下子,棋子因重_伏城之外的博客-CSDN博客

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");
 
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
 
const lines = [];
rl.on("line", (line) => {
  lines.push(line);
 
  if (lines.length === 2) {
    const [n, m] = lines[0].split(" ").map(Number);
    const cols = lines[1].split(" ").map(Number);
 
    console.log(gameResult(n, m, cols));
    lines.length = 0;
  }
});
 
/**
 * @param {*} n 宽，矩阵列数
 * @param {*} m 高，矩阵行数
 * @param {*} cols
 */
function gameResult(n, m, cols) {
  const r = m; // 矩阵行数
  const c = n; // 矩阵列数
 
  // 构造棋盘，注意棋盘长宽都+1了，方便后面棋子获取
  const matrix = new Array(r + 1).fill(0).map(() => new Array(c + 1).fill(0));
 
  // 这里i对应第几步，由于题目是从第1步开始算，而这里 i 从0开始算，因此最终返回要i+1
  for (let i = 0; i < cols.length; i++) {
    // cols[i]代表第 i 步下在第几列
    if (cols[i] < 1 || cols[i] > c) return `${i + 1},error`;
 
    // player落子颜色：1代表红色，2代表蓝色
    let player = i % 2 === 0 ? 1 : 2;
 
    // 落子逻辑
    let x = r;
    let y = cols[i];
    while (matrix[x][y] > 0) {
      x--; // 如果当前列底部有棋子，则需要往上查找
      if (x < 1) return `${i + 1},error`; // 如果当前列已经放满棋子，则报错
    }
    matrix[x][y] = player; // 如果当前列底部没有棋子，则可以放入
 
    // i >= 6，即第七步及之后落子时，才可能产生四连击
    if (i >= 6 && isFour(x, y, player, matrix, r, c)) {
      return `${i + 1},${player == 1 ? "red" : "blue"}`;
    }
  }
 
  // 双方都没有获胜
  return "0,draw";
}
 
// 上，左，左上，左下
const offsets = [
  [-1, 0],
  [0, -1],
  [-1, -1],
  [-1, 1],
];
 
function isFour(x, y, player, matrix, r, c) {
  for (let [offsetX, offsetY] of offsets) {
    let len = 1;
 
    // 向着某个方向延申判断是否存在相同子
    let x1 = x;
    let y1 = y;
 
    while (true) {
      x1 += offsetX;
      y1 += offsetY;
 
      if (
        x1 >= 1 &&
        x1 <= r &&
        y1 >= 1 &&
        y1 <= c &&
        matrix[x1][y1] === player
      ) {
        len++;
      } else {
        break;
      }
    }
 
    // 向着上面方向的反方向延申判断是否存在相同子（两个相反方向其实处于一条线上）
    let x2 = x;
    let y2 = y;
 
    while (true) {
      x2 -= offsetX;
      y2 -= offsetY;
 
      if (
        x2 >= 1 &&
        x2 <= r &&
        y2 >= 1 &&
        y2 <= c &&
        matrix[x2][y2] === player
      ) {
        len++;
      } else {
        break;
      }
    }
 
    // 如果此线可以形成四子连击，则直接返回true
    if (len == 4) return true;
  }
 
  return false;
}

抄袭代码（MISAYAONE）

2023 华为OD机试真题 JavaScript 实现【竖直四子棋】_MISAYAONE的博客-CSDN博客

let directions = [
  [-1, 0],
  [0, -1],
  [-1, -1],
  [-1, 1],
];
 
function check(x, y, perple, matrix, r, c) {
  for (let [dir1, dir2] of directions) {
    let len = 1;
 
    let x1 = x;
    let y1 = y;
 
    while (true) {
      x1 += dir1;
      y1 += dir2;
 
      if (
        x1 >= 1 &&
        x1 <= r &&
        y1 >= 1 &&
        y1 <= c &&
        matrix[x1][y1] === perple
      ) {
        len++;
      } else {
        break;
      }
    }
 
    let x2 = x;
    let y2 = y;
 
    while (true) {
      x2 -= dir1;
      y2 -= dir2;
 
      if (
        x2 >= 1 &&
        x2 <= r &&
        y2 >= 1 &&
        y2 <= c &&
        matrix[x2][y2] === perple
      ) {
        len++;
      } else {
        break;
      }
    }
 
    if (len == 4) return true;
  }
 
  return false;
}
 
function main(n, m, col_no){
    let r = m;
    let c = n; 
    
    // 构造棋盘
    let matrix = new Array(r + 1).fill(0).map(() => new Array(c + 1).fill(0));
    
    for (let i = 0; i < col_no.length; i++) {
        if (col_no[i] < 1 || col_no[i] > c) {
            console.log(`${i + 1},error`) ;
            return;
        }
    
        // 1代表红色，2代表蓝色
        let perple = i % 2 === 0 ? 1 : 2;
 
        let x = r;
        let y = col_no[i];
        while (matrix[x][y] > 0) {
            x--;
            if (x < 1) {
                console.log(`${i + 1},error`); 
                return
                }
        }
        matrix[x][y] = perple; 
    
        if (i >= 6 && check(x, y, perple, matrix, r, c)) {
            console.log(`${i + 1},${perple == 1 ? "red" : "blue"}`);
            return;
        }
    }
    
    console.log("0,draw");
}
 
main(5, 5,
[1, 1, 2 ,2, 3 ,3 ,4, 4])

例子4（JS）

原创代码（伏城之外）

华为OD机试 - 目录删除（Java & JS & Python）_华为机试删除目录_伏城之外的博客-CSDN博客

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");
 
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
 
const lines = [];
let m;
rl.on("line", (line) => {
  lines.push(line);
 
  if (lines.length === 1) {
    m = parseInt(lines[0]);
  }
 
  if (m && lines.length === m + 2) {
    lines.shift();
    const del = parseInt(lines.pop());
    const arr = lines.map((line) => line.split(" ").map(Number));
 
    console.log(getRemainTreeEle(arr, del));
    lines.length = 0;
  }
});
 
function getRemainTreeEle(arr, del) {
  let tree = {};
 
  for (let i = 0; i < arr.length; i++) {
    let [child, father] = arr[i];
    tree[father] ? tree[father].push(child) : (tree[father] = [child]);
  }
 
  if (del === 0) return "";
 
  const res = [];
  dfs(tree, 0, del, res);
 
  return res.sort((a, b) => a - b).join(" ");
}
 
function dfs(tree, node, del, res) {
  const children = tree[node];
  if (children)
    for (let i = 0; i < children.length; i++) {
      if (children[i] !== del) {
        res.push(children[i]);
        dfs(tree, children[i], del, res);
      }
    }
}

抄袭代码（MISAYAONE）

2023华为OD机试真题B卷 JavaScript 实现【树形目录删除】_MISAYAONE的博客-CSDN博客

function dfs(tree, node, del, result) {
  let children = tree[node];
  if (children)
    for (let i = 0; i < children.length; i++) {
      if (children[i] !== del) {
        result.push(children[i]);
        dfs(tree, children[i], del, result);
      }
    }
}
 
function main(arr, del){
    let tree = {};
 
    for (let i = 0; i < arr.length; i++) {
        let [child, father] = arr[i];
        tree[father] ? tree[father].push(child) : (tree[father] = [child]);
    }
    
    if (del === 0) {
        console.log("")
        return ;
    }
    
    let result = [];
    dfs(tree, 0, del, result);
 
    
    console.log(result.sort((a, b) => a - b).join(" "));
}
 
main([[8, 6],
[10, 8],
[6, 0],
[20, 8],
[2, 6]],
8)

例子5（Python）

原创代码（伏城之外）

华为OD机试 - 周末爬山（Java & JS & Python）_伏城之外的博客-CSDN博客

# 输入获取
m, n, k = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(m)]
 
offsets = ((-1, 0), (1, 0), (0, -1), (0, 1))
 
 
def bfs(minStepToHeight):
    # 广搜队列
    queue = []
    # 访问记录
    visited = [[False]*n for _ in range(m)]
 
    # 首先是(0,0)位置进入队列，且被标记为访问过
    queue.append((0, 0))
    visited[0][0] = True
 
    # 此时消耗步数为0
    step = 0
 
    while len(queue) > 0:
        # 这里没有用queue.removeFirst来控制广搜，而是使用newQueue来控制广搜，因为这样更方便操作step
        newQueue = []
        step += 1
 
        # 遍历同一层的所有节点
        for x, y in queue:
            lastHeight = matrix[x][y]
 
            # 四个方向位置
            for offsetX, offsetY in offsets:
                newX = x + offsetX
                newY = y + offsetY
 
                # 新位置越界则无法继续广搜
                if newX < 0 or newX >= m or newY < 0 or newY >= n:
                    continue
 
                # 新位置已访问过，则无需重复广搜
                if visited[newX][newY]:
                    continue
 
                curHeight = matrix[newX][newY]
 
                # 前后位置高度差在k以内, 则可以进入新位置
                if abs(curHeight - lastHeight) <= k:
                    visited[newX][newY] = True
 
                    # 如果此时到达新位置高度的步数step更小，则更新对应高度的最小步数
                    if minStepToHeight.get(curHeight) is None or minStepToHeight[curHeight] > step:
                        minStepToHeight[curHeight] = step
 
                    # 新位置加入下一层广搜队列
                    newQueue.append((newX, newY))
 
        queue = newQueue
 
 
# 算法入口
def getResult():
    # key表示山峰高度，value表示到达此山峰高度的最短步数
    minStepToHeight = {}
    # 到达matrix[0][0]高度的山峰，最短步数是0
    minStepToHeight[matrix[0][0]] = 0
 
    # 广搜
    bfs(minStepToHeight)
 
    # 取得最大高度
    maxHeight = max(minStepToHeight.keys())
    # 取得最大高度对应的最短步数
    minStep = minStepToHeight[maxHeight]
 
    return f"{maxHeight} {minStep}"
 
 
# 算法调用
print(getResult())

抄袭代码（MISAYAONE）

2023华为od机试真题B卷【周末爬山】Python 实现_MISAYAONE的博客-CSDN博客

# coding:utf-8
#JSRUN引擎2.0，支持多达30种语言在线运行，全仿真在线交互输入输出。 
import functools
import sys
from collections import Counter, defaultdict
import copy
from itertools import permutations
import re
import math
import sys
from queue import Queue
 
directions = [[-1, 0], [1, 0], [0, -1], [0, 1]]
 
def bfs(step_to_height_map,m,n,k,matrix) :
 
    queue = []
    # 访问记录
    visited = [[False for x in range(n)] for y in range(m)]
 
    queue.append([0,0])
    visited[0][0] = True
 
    step = 0
 
    while (len(queue) > 0) :
        empty_queue = []
        step+=1
    
        for pos in queue:
            x = pos[0]
            y = pos[1]
    
            last_height = matrix[x][y]
    
            # 四个方向位置
            for i in range(4) :
                new_x = x + directions[i][0]
                new_y = y + directions[i][1]
        
                # 越界
                if ((new_x < 0 or new_x >= m or new_y < 0 or new_y >= n) or (visited[new_x][new_y])):
                    continue
        
        
                cur_height = matrix[new_x][new_y]
        
                # 前后位置高度差在k以内, 则可以进入新位置
                if (abs(cur_height - last_height) <= k) :
                    # 标记新位置已访问
                    visited[new_x][new_y] = True
        
                    if (cur_height not in step_to_height_map or step_to_height_map[cur_height] > step) :
                        step_to_height_map[cur_height]= step
                    
        
                    empty_queue.append([new_x, new_y])
        queue = empty_queue
    
 
 
params = [int(x) for x in input().split(" ")]
m = params[0]
n = params[1]
k = params[2]
matrix = []
for i in range(m):
    matrix.append([int(x) for x in input().split(" ")])
# key为高度，value为到此高度的最短步数
step_to_height_map ={}
#初始化
step_to_height_map[matrix[0][0]] = 0
 
bfs(step_to_height_map,m,n,k,matrix)
 
 
max_height = 0
for x in step_to_height_map:
    max_height = max(x, max_height)
 
min_step = step_to_height_map[max_height]
print(str(max_height) + " " + str(min_step))

例子6（Python）

原创代码（伏城之外）

华为OD机试 - 路灯照明问题（Java & JS & Python）_在一条笔直的公路上安装了 n 个路灯,从位置_伏城之外的博客-CSDN博客

# 输入获取
n = int(input())
arr = list(map(int, input().split()))
 
 
# 算法入口
def getResult():
    rans = []
 
    for i in range(n):
        center = i * 100
        rans.append([center - arr[i], center + arr[i]])
 
    # 按起始位置升序，起始位置相同，则继续按结束位置降序
    rans.sort(key=lambda ran: (ran[0], -ran[1]))
 
    ans = 0
 
    t = rans[0][1]  # 上一个区间的结束位置
    for i in range(1, n):
        s, e = rans[i]  # 当前区间的【开始位置，结束位置】
 
        # 有交集
        if t >= s:
            # 合并后的新区间将变为下一轮的上一个区间，t为新区间的结束位置
            t = max(e, t)
        else:
            # 没有交集，则统计区间间隙 s - t
            ans += s - t
            #  当前区间变为下一轮的上一个区间，更新t
            t = e
 
    return ans
 
 
# 算法调用
print(getResult())

抄袭代码（MISAYAONE）

2022华为od机试真题B卷 Python 实现【路灯照明II】_MISAYAONE的博客-CSDN博客

# coding:utf-8
#JSRUN引擎2.0，支持多达30种语言在线运行，全仿真在线交互输入输出。 
import functools
import sys
from collections import Counter, defaultdict
import copy
from itertools import permutations
import re
import math
import sys
from queue import Queue
 
n = int(input())
nums = list(map(int, input().split()))
 
ranges = []
 
for i in range(n):
    center = i * 100
    ranges.append([center - nums[i], center + nums[i]])
 
# 按起始位置升序，起始位置相同，则继续按结束位置降序
ranges.sort(key=lambda ran: (ran[0], -ran[1]))
 
ans = 0
 
t = ranges[0][1] 
for i in range(1, n):
    s, e = ranges[i] 
 
    # 有交集
    if t >= s:
        
        t = max(e, t)
    else:
        # 没有交集
        ans += s - t
        t = e
print(ans)