ID: 448

传统题

3000ms

256MiB

尝试: 60

已通过: 18

难度: 6

上传者:

算法大师

标签>

E卷

华为OD机试E卷 - 不等式是否满足约束并输出最大差（Java & Python& JS & C++ & C ）

https://blog.csdn.net/banxia_frontend/article/details/142032178

题目描述

给定一组不等式，判断是否成立并输出不等式的最大差(输出浮点数的整数部分)

要求:

不等式系数为 double类型，是一个二维数组
不等式的变量为 int类型，是一维数组;
不等式的目标值为 double类型，是一维数组
不等式约束为字符串数组，只能是:“>”,“>=”,“<”,“<=”,“=”，

例如，不等式组:

 a11x1 + a12x2 + a13x3 + a14x4 + a15x5 <= b1; 
 a21x1 + a22x2 + a23x3 + a24x4 + a25x5 <= b2; 
 a31x1 + a32x2 + a33x3 + a34x4 + a35x5 <= b3;

最大差 = max{(a11x1+a12x2+a13x3+a14x4+a15x5-b1),(a21x1+a22x2+a23x3+a24x4+ a25x5-b2),(a31x1+a32x2+a33x3+a34x4+a35x5-b3)},

类型为整数(输出浮点数的整数部分)

输入描述

a11,a12,a13,a14,a15,a21,a22,a23,a24,a25, a31,a32,a33,a34,a35,x1,x2,x3,x4,x5,b1,b2,b3,<=,<=,<=

不等式组系数(double类型):

a11,a12,a13,a14,a15

a21,a22,a23,a24,a25

a31,a32,a33,a34,a35
不等式变量(int类型):x1,x2,x3,x4,x5
不等式目标值(double类型):b1,b2,b3
不等式约束(字符串类型):<=,<=,<=

输出描述

true或者 false，最大差

示例1

输入

2.3,3,5.6,7,6;11,3,8.6,25,1;0.3,9,5.3,66,7.8;1,3,2,7,5;340,670,80.6;<=,<=,<=

输出

false 458

说明

示例2

输入

2.36,3,6,7.1,6;1,30,8.6,2.5,21;0.3,69,5.3,6.6,7.8;1,13,2,17,5;340,67,300.6;<=,>=,<=

输出

false 758

说明

解题思路

题目解读

题目要求你根据一组不等式判断其是否成立，并计算这些不等式中左边表达式和目标值之间的最大差值。具体来说，每个不等式都包含如下内容：

不等式系数：一个二维数组，表示每个变量的系数。
不等式的变量：一个一维数组，表示每个变量的值。
不等式的目标值：一个一维数组，表示每个不等式右边的目标值。
不等式约束：一个字符串数组，表示不等式的关系，只能是 ">", ">=", "<", "<=", "=" 其中之一。

输入和输出示例

示例 1

输入：

2.3,3,5.6,7.6;11,3,8.6,25,1;0.3,9,5.3,66,7.8;1,3,2,7,5;340,670,80.6;<=,<=,<=

输出：

false 458

说明：

不等式系数：
- 第一行：2.3, 3, 5.6, 7.6
- 第二行：11, 3, 8.6, 25, 1
- 第三行：0.3, 9, 5.3, 66, 7.8
变量：x1=1, x2=3, x3=2, x4=7, x5=5
目标值：b1=340, b2=670, b3=80.6
不等式关系：<=, <=, <=

对应的三个不等式为：
- $2.3x_1 + 3x_2 + 5.6x_3 + 7.6x_4 + 11x_5 \leq 340$
- $11x_1 + 3x_2 + 8.6x_3 + 25x_4 + 1x_5 \leq 670$
- $0.3x_1 + 9x_2 + 5.3x_3 + 66x_4 + 7.8x_5 \leq 80.6$
计算每个不等式的左侧表达式，判断是否成立，并计算差值：
- 第一个不等式的左侧值大于340，不成立。
- 计算差值，并输出最大差值的整数部分（458）。
最后输出 false 和最大差值 458。

Java

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

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

        // 读入不等式
        String[][] arr = Arrays.stream(sc.nextLine().split(";"))
                .map(s -> s.split(","))
                .toArray(String[][]::new);

        // 将不等式系数转换为 Double 类型的二维数组
        Double[][] matrix = new Double[3][5];
        for (int i = 0; i < 3; i++) {
            matrix[i] = Arrays.stream(arr[i])
                    .map(Double::parseDouble)
                    .toArray(Double[]::new);
        }

        // 将不等式的变量转换为 Double 类型的一维数组
        Double[] x = Arrays.stream(arr[3])
                .map(Double::parseDouble)
                .toArray(Double[]::new);

        // 将不等式的目标值转换为 Double 类型的一维数组
        Double[] b = Arrays.stream(arr[4])
                .map(Double::parseDouble)
                .toArray(Double[]::new);

        // 将不等式约束转换为字符串数组
        String[] y = arr[5];

        // 计算每个不等式的差值
        double[] diffs = new double[3];
        boolean flag = true; // 判断所有不等式是否成立
        for (int i = 0; i < 3; i++) {
            // 计算左侧值
            double leftValue = dotProduct(matrix[i], x);
            // 计算差值
            diffs[i] = leftValue - b[i];
            // 检查当前不等式是否成立
            if (!compareWithZero(diffs[i], y[i])) {
                flag = false;
            }
        }

        // 计算最大差值
        double maxDiff = Arrays.stream(diffs).max().orElse(0.0);

        // 输出结果
        System.out.println(flag + " " + (int) Math.floor(maxDiff));
    }

    // 计算两个一维数组的点积
    public static double dotProduct(Double[] a, Double[] b) {
        double result = 0.0;
        for (int i = 0; i < a.length; i++) {
            result += a[i] * b[i];
        }
        return result;
    }

    // 根据不等式约束判断一个数是否满足条件
    public static boolean compareWithZero(double val, String constraint) {
        switch (constraint) {
            case ">":
                return val > 0;
            case ">=":
                return val >= 0;
            case "<":
                return val < 0;
            case "<=":
                return val <= 0;
            case "=":
                return Math.abs(val) < 1e-6; // 处理浮点数精度
            default:
                return false;
        }
    }
}

Python

import numpy as np

def dot_product(a, b):
    # 计算两个一维数组的点积
    return sum(ai * bi for ai, bi in zip(a, b))

def compare_with_zero(val, constraint):
    # 根据不等式约束判断一个数是否满足条件
    if constraint == ">":
        return val > 0
    elif constraint == ">=":
        return val >= 0
    elif constraint == "<":
        return val < 0
    elif constraint == "<=":
        return val <= 0
    elif constraint == "=":
        return abs(val) < 1e-6  # 浮点数精度处理
    return False

# 读取输入
input_data = input()

# 解析输入
arr = [s.split(",") for s in input_data.split(";")]

# 将不等式系数转换为二维数组
matrix = np.array(arr[:3], dtype=float)

# 将变量值转换为一维数组
x = np.array(arr[3], dtype=float)

# 将目标值转换为一维数组
b = np.array(arr[4], dtype=float)

# 将不等式符号转换为列表
y = arr[5]

# 计算每个不等式的差值
diffs = []
flag = True  # 判断所有不等式是否成立
for i in range(3):
    # 计算左侧的点积值
    left_value = dot_product(matrix[i], x)
    # 计算差值
    diff = left_value - b[i]
    diffs.append(diff)
    # 判断当前不等式是否成立
    if not compare_with_zero(diff, y[i]):
        flag = False

# 计算最大差值
max_diff = max(diffs)

# 输出结果，将 True 和 False 转换为小写
print(f"{str(flag).lower()} {int(max_diff)}")

JavaScript

// 计算两个一维数组的点积
function dotProduct(a, b) {
    let result = 0.0;
    for (let i = 0; i < a.length; i++) {
        result += a[i] * b[i];
    }
    return result;
}

// 根据不等式约束判断一个数是否满足条件
function compareWithZero(val, constraint) {
    switch (constraint) {
        case ">":
            return val > 0;
        case ">=":
            return val >= 0;
        case "<":
            return val < 0;
        case "<=":
            return val <= 0;
        case "=":
            return Math.abs(val) < 1e-6; // 处理浮点数精度
        default:
            return false;
    }
}

// 主程序
const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.on("line", (input) => {
    // 解析输入
    const arr = input.split(";").map(s => s.split(","));
    
    // 将不等式系数转换为二维数组
    const matrix = arr.slice(0, 3).map(row => row.map(Number));
    
    // 将变量值转换为一维数组
    const x = arr[3].map(Number);
    
    // 将目标值转换为一维数组
    const b = arr[4].map(Number);
    
    // 将不等式符号转换为数组
    const y = arr[5];
    
    // 计算每个不等式的差值
    let diffs = [];
    let flag = true; // 判断所有不等式是否成立
    for (let i = 0; i < 3; i++) {
        // 计算左侧的点积值
        const leftValue = dotProduct(matrix[i], x);
        // 计算差值
        const diff = leftValue - b[i];
        diffs.push(diff);
        // 判断当前不等式是否成立
        if (!compareWithZero(diff, y[i])) {
            flag = false;
        }
    }
    
    // 计算最大差值
    const maxDiff = Math.max(...diffs);
    
    // 输出结果
    console.log(`${flag} ${Math.floor(maxDiff)}`);
    rl.close();
});

C++

#include <iostream>
#include <vector>
#include <sstream>
#include <cmath>
#include <algorithm>
using namespace std;

// 计算两个一维数组的点积
double dotProduct(const vector<double>& a, const vector<double>& b) {
    double result = 0.0;
    for (size_t i = 0; i < a.size(); i++) {
        result += a[i] * b[i];
    }
    return result;
}

// 根据不等式约束判断一个数是否满足条件
bool compareWithZero(double val, const string& constraint) {
    if (constraint == ">") return val > 0;
    if (constraint == ">=") return val >= 0;
    if (constraint == "<") return val < 0;
    if (constraint == "<=") return val <= 0;
    if (constraint == "=") return fabs(val) < 1e-6; // 浮点数精度处理
    return false;
}

int main() {
    string input;
    getline(cin, input);

    // 解析输入
    vector<vector<string>> arr;
    stringstream ss(input);
    string segment;
    while (getline(ss, segment, ';')) {
        vector<string> row;
        stringstream rowStream(segment);
        string value;
        while (getline(rowStream, value, ',')) {
            row.push_back(value);
        }
        arr.push_back(row);
    }

    // 将不等式系数转换为二维数组
    vector<vector<double>> matrix(3, vector<double>(5));
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 5; j++) {
            matrix[i][j] = stod(arr[i][j]);
        }
    }

    // 将变量值转换为一维数组
    vector<double> x(5);
    for (int i = 0; i < 5; i++) {
        x[i] = stod(arr[3][i]);
    }

    // 将目标值转换为一维数组
    vector<double> b(3);
    for (int i = 0; i < 3; i++) {
        b[i] = stod(arr[4][i]);
    }

    // 将不等式符号转换为字符串数组
    vector<string> y = arr[5];

    // 计算每个不等式的差值
    vector<double> diffs(3);
    bool flag = true; // 判断所有不等式是否成立
    for (int i = 0; i < 3; i++) {
        double leftValue = dotProduct(matrix[i], x);
        diffs[i] = leftValue - b[i];
        if (!compareWithZero(diffs[i], y[i])) {
            flag = false;
        }
    }

    // 计算最大差值
    double maxDiff = *max_element(diffs.begin(), diffs.end());

    // 输出结果，将 flag 转为小写 true 或 false
    cout << (flag ? "true" : "false") << " " << (int)floor(maxDiff) << endl;

    return 0;
}

C语言

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

// 计算两个一维数组的点积
double dotProduct(double* a, double* b, int size) {
    double result = 0.0;
    for (int i = 0; i < size; i++) {
        result += a[i] * b[i];
    }
    return result;
}

// 根据不等式约束判断一个数是否满足条件
bool compareWithZero(double val, char* constraint) {
    if (strcmp(constraint, ">") == 0) return val > 0;
    if (strcmp(constraint, ">=") == 0) return val >= 0;
    if (strcmp(constraint, "<") == 0) return val < 0;
    if (strcmp(constraint, "<=") == 0) return val <= 0;
    if (strcmp(constraint, "=") == 0) return fabs(val) < 1e-6; // 浮点数精度处理
    return false;
}

int main() {
    char input[1000];
    fgets(input, 1000, stdin);

    // 分割输入
    char* segments[6];
    char* token = strtok(input, ";");
    int index = 0;
    while (token) {
        segments[index++] = token;
        token = strtok(NULL, ";");
    }

    // 将不等式系数转换为二维数组
    double matrix[3][5];
    for (int i = 0; i < 3; i++) {
        char* value = strtok(segments[i], ",");
        for (int j = 0; j < 5; j++) {
            matrix[i][j] = atof(value);
            value = strtok(NULL, ",");
        }
    }

    // 将变量值转换为一维数组
    double x[5];
    char* value = strtok(segments[3], ",");
    for (int i = 0; i < 5; i++) {
        x[i] = atof(value);
        value = strtok(NULL, ",");
    }

    // 将目标值转换为一维数组
    double b[3];
    value = strtok(segments[4], ",");
    for (int i = 0; i < 3; i++) {
        b[i] = atof(value);
        value = strtok(NULL, ",");
    }

    // 将不等式符号转换为数组
    char* y[3];
    value = strtok(segments[5], ",");
    for (int i = 0; i < 3; i++) {
        y[i] = value;
        value = strtok(NULL, ",");
    }

    // 计算每个不等式的差值
    double diffs[3];
    bool flag = true; // 判断所有不等式是否成立
    for (int i = 0; i < 3; i++) {
        double leftValue = dotProduct(matrix[i], x, 5);
        diffs[i] = leftValue - b[i];
        if (!compareWithZero(diffs[i], y[i])) {
            flag = false;
        }
    }

    // 计算最大差值
    double maxDiff = diffs[0];
    for (int i = 1; i < 3; i++) {
        if (diffs[i] > maxDiff) {
            maxDiff = diffs[i];
        }
    }

    // 输出结果，将 flag 转为小写 true 或 false
    printf("%s %d\n", flag ? "true" : "false", (int)floor(maxDiff));

    return 0;
}

fengmian

完整用例

用例1

2.3,3,5.6,7,6;11,3,8.6,25,1;0.3,9,5.3,66,7.8;1,3,2,7,5;340,670,80.6;<=,<=,<=

用例2

2.36,3,6,7.1,6;1,30,8.6,2.5,21;0.3,69,5.3,6.6,7.8;1,13,2,17,5;340,67,300.6;<=,>=,<=

用例3

6,12,18,24,30;7,14,21,28,35;8,16,24,32,40;1,2,3,4,5;200,300,400;<=,<=,<=

用例4

1.5,3,4.5,6,7.5;2,4,6,8,10;3,6,9,12,15;1,2,3,4,5;50,100,150;>=,<=,>=

用例5

10,20,30,40,50;60,70,80,90,100;110,120,130,140,150;2,4,6,8,10;1000,2000,3000;>,<=,=

用例6

2.1,3.2,4.3,5.4,6.5;7.6,8.7,9.8,10.9,11.0;12.1,13.2,14.3,15.4,16.5;3,5,7,9,11;150,250,350;<=,<=,<=

用例7

1.1,1.2,1.3,1.4,1.5;2.6,2.7,2.8,2.9,3.0;3.1,3.2,3.3,3.4,3.5;1,2,3,4,5;10,20,30;<=,<=,<=

用例8

5.1,5.2,5.3,5.4,5.5;6.1,6.2,6.3,6.4,6.5;7.1,7.2,7.3,7.4,7.5;2,3,4,5,6;100,200,300;<=,<=,>=

用例9

10,15,20,25,30;35,40,45,50,55;60,65,70,75,80;3,6,9,12,15;1000,2000,3000;>,>,<

用例10

4,8,12,16,20;24,28,32,36,40;44,48,52,56,60;2,4,6,8,10;400,800,1200;<=,<=,=

#C0E49. 为OD机试E卷 - 不等式是否满足约束并输出最大差

为OD机试E卷 - 不等式是否满足约束并输出最大差

华为OD机试E卷 - 不等式是否满足约束并输出最大差（Java & Python& JS & C++ & C ）

最新华为OD机试

题目描述

输入描述

输出描述

示例1

示例2

解题思路

题目解读

输入和输出示例

示例 1

Java

Python

JavaScript

C++

C语言

完整用例

用例1

用例2

用例3

用例4

用例5

用例6

用例7

用例8

用例9

用例10

状态

开发

支持

#C0E49. 为OD机试E卷 - 不等式是否满足约束并输出最大差

为OD机试E卷 - 不等式是否满足约束并输出最大差

华为OD机试E卷 - 不等式是否满足约束并输出最大差（Java & Python& JS & C++ & C ）

最新华为OD机试

题目描述

输入描述

输出描述

示例1

示例2

解题思路

题目解读

输入和输出示例

示例 1

Java

Python

JavaScript

C++

C语言

完整用例

用例1

用例2

用例3

用例4

用例5

用例6

用例7

用例8

用例9

用例10

状态

开发

支持

还没有账户？

登录