Java 查找两维数组中给出的候选分数的最大分数或最大平均分数

问题：考生可以根据自己的意愿多次参加入学考试。最后考虑所有尝试的平均分数。给我一份分数表。找到得分最高[平均分]的候选人

String scores[][] = {{"Ram","155"}, 
                    {"Shyam","145"},
                    {"Ram","156"},
                    {"Balram","159"},
                    {"Balram","150"},
                    {"Ram","135"},
                    {"Mira","156"},
                    {"Mira","152"},
                    {"Shyam","155"}};

---

分数以二维数组形式给出，如上所述。需要有效解决此问题的建议。

减少时间和空间复杂性的原因是什么？我坚信简洁性和可维护性比性能更重要

既然您标记了，我可以建议您使用以下方法

Map<Object, Double> scoreMap = Arrays.stream(scores)
        .collect(
            Collectors.groupingBy(i -> i[0], 
            Collectors.averagingInt(i -> Integer.parseInt(i[1])
        )));

String winner = scoreMap.entrySet().stream()
    .max(Comparator.comparingDouble(e -> e.getValue()))
    .get().getKey().toString();

Map scoreMap=Arrays.stream（分数）
.收集(
Collectors.groupingBy（i->i[0]，
收集器.averagint（i->Integer.parseInt（i[1]）
)));
字符串winner=scoreMap.entrySet（）.stream（）
.max（Comparator.comparingDouble（e->e.getValue（））
.get（）.getKey（）.toString（）；

---

感谢@AndyTurner提供的

.max（..）

参数建议。

降低时间和空间复杂性的原因是什么？我坚信简洁性和可维护性比性能更重要

既然您标记了，我可以建议您使用以下方法

Map<Object, Double> scoreMap = Arrays.stream(scores)
        .collect(
            Collectors.groupingBy(i -> i[0], 
            Collectors.averagingInt(i -> Integer.parseInt(i[1])
        )));

String winner = scoreMap.entrySet().stream()
    .max(Comparator.comparingDouble(e -> e.getValue()))
    .get().getKey().toString();

Map scoreMap=Arrays.stream（分数）
.收集(
Collectors.groupingBy（i->i[0]，
收集器.averagint（i->Integer.parseInt（i[1]）
)));
字符串winner=scoreMap.entrySet（）.stream（）
.max（Comparator.comparingDouble（e->e.getValue（））
.get（）.getKey（）.toString（）；

---

感谢@AndyTurner提供的

.max（..）

参数建议。

为了降低时间复杂度，您可以使用特定集合：

public static String findMaxScore(String[][] scores) {
    final class Candidate implements Comparable<Candidate> {

        private final String name;
        private int scoreSum;
        private int attempts;

        public Candidate(String name) {
            this.name = name;
        }

        public void score(int score) {
            scoreSum += score;
            attempts++;
        }

        public double avg() {
            return (double)scoreSum / attempts;
        }

        @Override
        public int compareTo(Candidate candidate) {
            return Double.compare(candidate.avg(), avg());
        }
    }

    Map<String, Candidate> map = new HashMap<>();

    for (String[] data : scores) {
        map.putIfAbsent(data[0], new Candidate(data[0]));
        map.get(data[0]).score(Integer.parseInt(data[1]));
    }

    return new TreeSet<>(map.values()).iterator().next().name;
}

公共静态字符串findMaxScore（字符串[][]分数）{
最后一个班的候选者实现了可比性{
私有最终字符串名；
私人积分和；
私人int尝试；
公共候选（字符串名称）{
this.name=名称；
}
公共无效分数（整数分数）{
分数总和+=分数；
尝试++；
}
公共双平均值（）{
返回（双倍）记分和/尝试次数；
}
@凌驾
公共int比较（候选）{
返回Double.compare（candidate.avg（），avg（））；
}
}
Map Map=newhashmap（）；
for（字符串[]数据：分数）{
map.putIfAbsent（数据[0]，新候选（数据[0]）；
map.get（数据[0]）.score（Integer.parseInt（数据[1]）；
}
返回新树集（map.values（））.iterator（）.next（）.name；
}

为了降低时间复杂度，您可以使用特定集合：

public static String findMaxScore(String[][] scores) {
    final class Candidate implements Comparable<Candidate> {

        private final String name;
        private int scoreSum;
        private int attempts;

        public Candidate(String name) {
            this.name = name;
        }

        public void score(int score) {
            scoreSum += score;
            attempts++;
        }

        public double avg() {
            return (double)scoreSum / attempts;
        }

        @Override
        public int compareTo(Candidate candidate) {
            return Double.compare(candidate.avg(), avg());
        }
    }

    Map<String, Candidate> map = new HashMap<>();

    for (String[] data : scores) {
        map.putIfAbsent(data[0], new Candidate(data[0]));
        map.get(data[0]).score(Integer.parseInt(data[1]));
    }

    return new TreeSet<>(map.values()).iterator().next().name;
}

公共静态字符串findMaxScore（字符串[][]分数）{
最后一个班的候选者实现了可比性{
私有最终字符串名；
私人积分和；
私人int尝试；
公共候选（字符串名称）{
this.name=名称；
}
公共无效分数（整数分数）{
分数总和+=分数；
尝试++；
}
公共双平均值（）{
返回（双倍）记分和/尝试次数；
}
@凌驾
公共int比较（候选）{
返回Double.compare（candidate.avg（），avg（））；
}
}
Map Map=newhashmap（）；
for（字符串[]数据：分数）{
map.putIfAbsent（数据[0]，新候选（数据[0]）；
map.get（数据[0]）.score（Integer.parseInt（数据[1]）；
}
返回新树集（map.values（））.iterator（）.next（）.name；
}

公共字符串findmaxAverage（字符串[][]等级）{
如果（等级==null）返回“”；
Map Map=newhashmap（）；
对于（字符串[]等级：等级）{
List mapList=map.get（grade[0]）；
如果（mapList==null）mapList=newarraylist（）；
mapList.add（Integer.valueOf（grade[1]））；
地图放置（等级[0]，地图列表）；
}
双最大平均值=双最小值；
字符串赢家=”；
for（字符串名称：map.nameSet（））{
System.out.println（name+”：“+map.get（name））；
List-mapList=map.get（名称）；
双重平均=getAverage（地图列表）；
如果（平均值>最大平均值）{
最大平均值=平均值；
获胜者=姓名；
}
}
返回赢家；}

公共字符串findmaxAverage（字符串[][]等级）{
如果（等级==null）返回“”；
Map Map=newhashmap（）；
对于（字符串[]等级：等级）{
List mapList=map.get（grade[0]）；
如果（mapList==null）mapList=newarraylist（）；
mapList.add（Integer.valueOf（grade[1]））；
地图放置（等级[0]，地图列表）；
}
双最大平均值=双最小值；
字符串赢家=”；
for（字符串名称：map.nameSet（））{
System.out.println（name+”：“+map.get（name））；
List-mapList=map.get（名称）；
双重平均=getAverage（地图列表）；
如果（平均值>最大平均值）{
最大平均值=平均值；
获胜者=姓名；
}
}
返回赢家；}

同样，通过这种方式，您可以通过

流

Api

import java.util.stream.*;
import java.util.*;
public class Solution {
  public static void main (String[] args) {
    String scores[][] = {{"Bob","80"},{"Charles","85"},{"Rob","70"},{"Bob","100"},{"Charles","75"}};
    

 Map<Object,Double> collectValues = Arrays.stream(scores).collect(Collectors.groupingBy(a->a[0],Collectors.averagingInt(a->Integer.parseInt(a[1]))));

    Map.Entry<Object,Double> MaxMarks = collectValues.entrySet().stream().max((e1,e2)->Double.compare(e1.getValue(), e2.getValue())).get();

    System.out.println(MaxMarks.getKey() + " :: " + MaxMarks.getValue());

}

import java.util.stream.*；
导入java.util.*；
公共类解决方案{
公共静态void main（字符串[]args）{
字符串分数[][]={{“鲍勃”，“80”}，{“查尔斯”，“85”}，{“罗伯”，“70”}，{“鲍勃”，“100”}，{“查尔斯”，“75”}；
Map collectValues=Arrays.stream（scores）.collect（Collectors.groupingBy（a->a[0]，Collectors.averaging（a->Integer.parseInt（a[1]））；
Map.Entry MaxMarks=collectValues.entrySet（）.stream（）.max（（e1，e2）->Double.compare（e1.getValue（），e2.getValue（））.get（）；
System.out.println（MaxMarks.getKey（）+”：“+MaxMarks.getValue（））；
}

同样，通过这种方式，您可以通过

流

Api

import java.util.stream.*;
import java.util.*;
public class Solution {
  public static void main (String[] args) {
    String scores[][] = {{"Bob","80"},{"Charles","85"},{"Rob","70"},{"Bob","100"},{"Charles","75"}};
    

 Map<Object,Double> collectValues = Arrays.stream(scores).collect(Collectors.groupingBy(a->a[0],Collectors.averagingInt(a->Integer.parseInt(a[1]))));

    Map.Entry<Object,Double> MaxMarks = collectValues.entrySet().stream().max((e1,e2)->Double.compare(e1.getValue(), e2.getValue())).get();

    System.out.println(MaxMarks.getKey() + " :: " + MaxMarks.getValue());

}

import java.util.stream.*；
导入java.util.*；
公共类解决方案{
公共静态void main（字符串[]args）{
字符串分数[][]={{“鲍勃”，“80”}，{“查尔斯”，“85”}，{“罗伯”，“70”}，{“鲍勃”，“1