(D卷,100分)- 最多购买宝石数目（Java & JS & Python & C）

获取题库不需要订阅专栏，可直接私信我进入CSDN领军人物top1博主的华为OD交流圈观看完整题库、最新面试实况、考试报告等内容以及大佬一对一答疑。
题目描述
橱窗里有一排宝石，不同的宝石对应不同的价格，宝石的价格标记为 gems[i]

0 ≤ i < n
n = gems.length
宝石可同时出售0个或多个，如果同时出售多个，则要求出售的宝石编号连续；

例如客户最大购买宝石个数为m，购买的宝石编号必须为：gems[i]，gems[i+1]，…，gems[i+m-1]

0 ≤ i < n
m ≤ n
假设你当前拥有总面值为 value 的钱，请问最多能购买到多少个宝石，如无法购买宝石，则返回0。

输入描述
第一行输入n，参数类型为int，取值范围：[0,10^6]，表示橱窗中宝石的总数量。

之后 n 行分别表示从第0个到第n-1个宝石的价格，即 gems[0] 到 gems[n-1] 的价格，类型为int，取值范围：(0,1000]。

之后一行输入v，类型为int，取值范围：[0,10^9]，表示你拥有的钱。

输出描述
输出int类型的返回值，表示最大可购买的宝石数量。

用例
输入 7
8
4
6
3
1
6
7
10
输出 3
说明
gems = [8,4,6,3,1,6,7], value = 10

最多购买的宝石为gems[2]至gems[4]或者gems[3]至gems[5]

输入 0
1
输出 0
说明 gems = [], value = 1
因为没有宝石，所以返回0
输入 9
6
1
3
1
8
9
3
2
4
15
输出 4
说明 gems = [6, 1, 3, 1, 8, 9, 3, 2, 4], value = 15
最多购买的宝石为gems[0]至gems[3]
输入 9
1
1
1
1
1
1
1
1
1
10
输出 9
说明 gems = [1, 1, 1, 1, 1, 1, 1, 1, 1], value = 10
最多购买的宝石为gems[0]至gems[8]，即全部购买

题目解析
理解题目：题目描述了一个购买宝石的问题，宝石有价格，可以连续购买多个宝石，但要求购买的宝石编号连续。给定总金额，需要找出最多能购买多少个宝石。
关键信息：
宝石的总数量为n，宝石的价格数组为gems，长度为n。
每个宝石的价格gems[i]，其中0 ≤ i < n，且价格范围为(0, 1000]。
总金额为value，取值范围为[0, 10^9]。
购买的宝石必须是连续的，即如果购买从第i个开始的m个宝石，则编号为gems[i]到gems[i+m-1]。
解题思路：
遍历所有可能的连续宝石段，计算每个段的总价格。
如果总价格不超过给定的value，则更新最大可购买的宝石数量。
由于需要最大化宝石数量，遍历过程可以从前到后或从后到前，每次增加一个宝石进行计算，这样可以利用之前计算的结果，减少重复计算。
java算法源码

import java.util.Scanner;  
  
public class GemBuyer {  
    public static void main(String[] args) {  
        Scanner scanner = new Scanner(System.in);  
        int n = scanner.nextInt();  
        int[] gems = new int[n];  
        for (int i = 0; i < n; i++) {  
            gems[i] = scanner.nextInt();  
        }  
        int value = scanner.nextInt();  
        System.out.println(maxGemsToBuy(gems, value));  
    }  
  
    public static int maxGemsToBuy(int[] gems, int value) {  
        int maxGems = 0;  
        int currentSum = 0;  
        for (int gem : gems) {  
            if (currentSum + gem <= value) {  
                currentSum += gem;  
                maxGems++;  
            } else if (gem <= value) {  
                // 重置，以当前宝石为起点开始  
                currentSum = gem;  
                maxGems = 1;  
            }  
        }  
        return maxGems;  
    }  
}

javascript算法源码

const readline = require('readline').createInterface({  
    input: process.stdin,  
    output: process.stdout  
});  
  
readline.on('line', (line) => {  
    if (line === null) {  
        readline.close();  
        return;  
    }  
  
    const n = parseInt(line, 10);  
    const gems = [];  
    for (let i = 0; i < n; i++) {  
        readline.on('line', (price) => {  
            gems.push(parseInt(price, 10));  
            if (gems.length === n) {  
                const value = parseInt(readline.question(), 10);  
                readline.close();  
                console.log(maxGemsToBuy(gems, value));  
            }  
        });  
        readline.prompt();  
        return;  
    }  
    readline.prompt();  
});  
  
function maxGemsToBuy(gems, value) {  
    let maxGems = 0;  
    let currentSum = 0;  
    for (let gem of gems) {  
        if (currentSum + gem <= value) {  
            currentSum += gem;  
            maxGems++;  
        } else if (gem <= value) {  
            currentSum = gem;  
            maxGems = 1;  
        }  
    }  
    return maxGems;  
}  
  
readline.prompt();

python算法源码

def max_gems_to_buy(gems, value):  
    max_gems = 0  
    current_sum = 0  
    for gem in gems:  
        if current_sum + gem <= value:  
            current_sum += gem  
            max_gems += 1  
        elif gem <= value:  
            current_sum = gem  
            max_gems = 1  
    return max_gems  
  
# 读取输入  
n = int(input())  
gems = list(map(int, input().split()))  
value = int(input())  
  
# 输出结果  
print(max_gems_to_buy(gems, value))

C算法源码

#include <stdio.h>  
#include <stdlib.h>  
  
int maxGemsToBuy(int *gems, int n, int value) {  
    int maxGems = 0;  
    int currentSum = 0;  
    for (int i = 0; i < n; i++) {  
        if (currentSum + gems[i] <= value) {  
            currentSum += gems[i];  
            maxGems++;  
        } else if (gems[i] <= value) {  
            currentSum = gems[i];  
            maxGems = 1;  
        }  
    }  
    return maxGems;  
}  
  
int main() {  
    int n;  
    scanf("%d", &n);  
    int *gems = (int *)malloc(n * sizeof(int));  
    if (gems == NULL) {  
        printf("Memory allocation failed\n");  
        return 1;  
    }  
  
    for (int i = 0; i < n; i++) {  
        scanf("%d", &gems[i]);  
    }  
  
    int value;  
    scanf("%d", &value);  
  
    int result = maxGemsToBuy(gems, n, value);  
    printf("%d\n", result);  
  
    free(gems);  
    return 0;  
}