【备战秋招】每日一题:4月1日美团春招（二批）第二题:题面+题目思路 + C++/python/js/Go/java带注释

2023大厂笔试模拟练习网站（含题解）

www.codefun2000.com
最近我们一直在将收集到的各种大厂笔试的解题思路还原成题目并制作数据，挂载到我们的OJ上，供大家学习交流，体会笔试难度。现已录入200+道互联网大厂模拟练习题，还在极速更新中。欢迎关注公众号“塔子哥学算法”获取最新消息。
在这里插入图片描述
提交链接:

https://codefun2000.com/p/P1138

为了更好的阅读体检，可以查看OJ上的题解。进入提交链接，点击右边菜单栏的"查看塔子哥的题解"

题目内容

塔子哥是一名数学老师，他正在为他的学生们准备一道有趣的数学题目。他想让他的学生们通过这道题目来锻炼他们的计算能力和创造力。这道题目是由塔子哥自己设计的，他希望通过这道题目来激发学生们对数学的兴趣和热情。题目如下：

塔子哥写下了一排 $n$ 个数( $\leq 2$ )，依次用加号连接。

例如，塔子哥可能写下了如下的式子1+4+7+4+2+3+1共7个数以及6个加号。

假设塔子哥每次选择一个加号，将它改变成加减乘除中的一个(每次操作不对产生任何影响)，问题是需要计算整个式子的后续操作产生影响。

现在，他想让你来帮助他验证一下这道题目的正确性，以便他可以在课堂上向他的学生们展示这道题目。

输入描述

第一行一个整数 $n$ 。

接下来一行 $n$ 个整数 $a_{1}, a_{2},……,a_{n}$ 依次表示塔子哥初始写下的连加算式中的每一个数。

接下来一个整数 $m$ ，表示塔子哥做了 $m$ 次算数训练

接下来 $2 m$ 个以空格分开数字和符号 $t_{1},o_{1}, t_{2}, o_{2}，……，t_{m}, o_{m}$ ，其中 $t_{i}$ 为数字， $o_{i}$ 是’+‘,’-‘,’*‘,’/'(即加减乘除，不含引号)中的一个符号，表示第i次操作选定第 $t_{i}$ 个加号，将其改变为了 $o_{i}$ 。

对于所有的的数据 $\leq N \leq 50000， 1 \leq M \leq 50000 ,1 \leq a_{i} \leq 500,1 \leq t_{i} < N, o_{i} \epsilon (+,-,*,/)$

输出描述

输出行m个整数，分别表示每次操作答案，结果四舍五入到第一位小数。

样例 $1$

输入

5
1 2 4 2 5
3
1 - 2 * 4 /

输出

10.0 16.0 7.4

样例解释
第一次操作后算数式为1-2+4+2+5 = 10.0

第二次操作后算数式为1+2*4+2+5 = 16.0

第三次操作后算数式为1+2+4+2/5 - 7.4

值得注意的是，每次操作都认为对初始的全加号式子(此处为1+2+4+2+5)进行操作，操作之间互不影响。

题目思路

思路:模拟

比较简单的一道题。先求一遍初始的总和。由于每次操作独立 ，所以每次先减去 $+$ 的贡献，然后新增新符号的贡献。输出即可。

但是这题的Go语言全军覆没。塔子哥不太熟悉Go语言。大家知道这题为什么Go没有输出,可以向塔子哥反馈!!

类似题目推荐

很签到的题目。几乎不涉及到算法。这里就不提供类似题目推荐了。

代码

C++

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
double a[maxn];
int main (){
    int n;
    cin >> n;
    // s 代表初始的总和
    double s = 0;
    for (int i = 1 ; i <= n ; i++){
        cin >> a[i];
        s += a[i];
    }
    int m;
    cin >> m;
    cout.precision(1);
    cout << fixed;
    // 处理m次操作
    for (int i = 1 ; i <= m; i++){
        int x;
        char y;
        double t = s;
        cin >> x >> y;
        // + 就直接 忽略
        if (y == '+') ;
        // - , 总和 -= 2 * a[x]
        else if (y == '-') s -= 2 * a[x + 1];
        else if (y == '*'){
            // 减去原先的贡献
            s -= a[x] + a[x + 1];
            // 加上现在的贡献
            s += a[x] * a[x + 1];
        }else {
            // 减去原先的贡献
            s -= a[x] + a[x + 1];
            // 加上现在的贡献
            s += a[x] / a[x + 1];
        }
        cout << s;
        if (i != 2 * m) cout << " ";
        else cout << endl;
        // 还原
        s = t;
    }
    return 0;
}

python

import sys

n = int(input())  # 从标准输入中读入一个整数n
a = list(map(float, input().split()))  # 从标准输入中读入n个浮点数，分别存入数组a[]

s = sum(a)  # 计算这n个数的总和

m = int(input())  # 从标准输入中读入一个整数m，表示待处理的操作数

op = input().split()
for i in range(0 , 2 * m, 2):
    x, y = op[i : i + 2]
    x = int(x) - 1  # 将x转换成数组下标（Python下标从0开始）
    t = s  # 记录当前整数和s的和t，以备撤销操作时使用

    # 根据不同的操作符进行操作
    if y == '+':
        pass  # 不需要处理，继续下一步循环
    elif y == '-':
        s -= 2 * a[x + 1]  # 修改一个加号为减号，相当于将加号两边的数取了负，所以需要将s减去新加入的两个数（a[x+1]和-a[x+2]）的和
    elif y == '*':
        s -= a[x] + a[x + 1]  # 修改一个加号为乘号，先将新修改的两个数从s中减去
        s += a[x] * a[x + 1]  # 加新的贡献
    else:
        s -= a[x] + a[x + 1]  # 修改一个加号为除号，先将新修改的两个数从s中减去
        s += a[x] / a[x + 1]  # 加新的贡献

    # 输出结果
    sys.stdout.write('{:.1f}'.format(s))
    if i != 2 * m - 1:
        sys.stdout.write(' ')  # 在输出数字之间加上空格（除了最后一个数字）
    else:
        sys.stdout.write('\n')
    
    s = t  # 修改完一个操作符后，需要将s恢复到操作前的状态t。

Java

java比较特殊，精度计算和其他语言不一样。参考题目讨论区。这里放一个AC的Java代码

import java.text.DecimalFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 读取数组的长度n
        int n = scanner.nextInt();
        int[] number = new int[n + 1];
        // 读取数组中n个元素
        for (int i = 1; i <= n; i++) {
            number[i] = scanner.nextInt();
        }
        
        // 计算前缀和，sum[i]表示number[1]~number[i]的总和
        double[] sum = new double[n + 1];
        for (int i = 1; i <= n; i++) {
            sum[i] = sum[i - 1] + number[i];
        }
        
        // 读取询问的数量m
        int m = scanner.nextInt();
        ArrayList<Double> ans = new ArrayList<>();
        // 处理每个询问
        for (int i = 0; i < m; i++) {
            // 获取询问的位置pos和操作符号ops
            int pos = scanner.nextInt();
            String ops = scanner.next();
            // 计算pos之前的元素总和left和pos之后元素的总和right
            double left = sum[pos - 1];
            double right = sum[n] - sum[pos + 1];
            double temp = 0;
            // 根据操作符计算temp的值
            if (ops.equals("-")) {
                temp = number[pos] - number[pos + 1];
            } else if (ops.equals("+")) {
                temp = number[pos] + number[pos + 1];
            } else if (ops.equals("*")) {
                temp = number[pos] * number[pos + 1];
            } else if (ops.equals("/")) {
                temp = (double) number[pos] / number[pos + 1];
            }
            // 将left、right和temp相加，并将结果添加到ans中
            ans.add(left + right + temp);
        }
        
        // 输出结果
        DecimalFormat decimalFormat = new DecimalFormat("0.0");
        for (int i = 0; i < m; i++) {
            System.out.printf(decimalFormat.format(ans.get(i)));
            System.out.print(" ");
        }
    }
}

Js

process.stdin.resume();
process.stdin.setEncoding('utf-8');
let input = '';
process.stdin.on('data', (data) => {
  input += data;
  return;
});
process.stdin.on('end', () => {
  const lines = input.trim().split('\n');
  let n = parseInt(lines[0].trim());
  let a = lines[1].trim().split(/\s+/).map((v) => parseFloat(v));
  let m = parseInt(lines[2].trim());
  let s = a.reduce((prev, cur) => prev + cur, 0);
  let ans = '';
  let op = lines[3].trim().split(/\s+/);
  for (let i = 0; i < 2 * m; i += 2) {
    var [x, y] = [op[i] , op[i + 1]];
    x -= 1;
    let t = s;
    if (y === '+') {
      // do nothing
    } else if (y === '-') {
      // 减两倍
      s -= 2 * a[x + 1];
    } else if (y === '*') {
      // 减去贡献，加上新贡献
      s -= a[x] + a[x + 1];
      s += a[x] * a[x + 1];
    } else {
      // 减去贡献，加上新贡献
      s -= a[x] + a[x + 1];
      s += a[x] / a[x + 1];
    }
    ans += s.toFixed(1);
    // 保证行末不含空格
    if (i !== 2 * m - 1) ans += ' ';
    // 还原
    s = t;
  }
  console.log(ans);
});

Go

存疑


package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Scan()
    n, _ := strconv.Atoi(scanner.Text())

    a := make([]float64, n)
    scanner.Scan()
    for i, v := range strings.Fields(scanner.Text()) {
        a[i], _ = strconv.ParseFloat(v, 64)
    }

    scanner.Scan()
    _, _ = strconv.Atoi(scanner.Text())

    var s float64
    for _, v := range a {
        s += v
    }

    scanner.Scan()
    ops := strings.Fields(scanner.Text())

    for i := 0; i < len(ops); i += 2 {
        x, _ := strconv.Atoi(ops[i])
        x--
        var y = ops[i+1]

        t := s
        switch y {
        case "+":
            // do nothing
        case "-":
      // 减两倍
            s -= 2 * a[x+1]
        case "*":
      // 减去贡献，加上新贡献
            s -= a[x] + a[x+1]
            s += a[x] * a[x+1]
        case "/":
      // 减去贡献，加上新贡献
            s -= a[x] + a[x+1]
            s += a[x] / a[x+1]
        }

        fmt.Printf("%.1f", s)
        if i != len(ops)-2 {
            fmt.Print(" ")
        } else {
            fmt.Println()
        }

        s = t
    }
}