Hackrank 统计十日通(第一天) 平均值, 中位数, 众数

译自 Day 0: Mean, Median, and Mode
mean 平均值

一个集合里所有整数(数?)的平均值,这是计算一个集合平均值的基本公式
![][mean]
[mean]:https://wikimedia.org/api/rest_v1/media/math/render/svg/c7740a0aa91314dbf006e8583ce6f61585e3aab6
xi就是集合中第i个元素.

中位数 Median
一个集合的中间点的值, 使集合中小于它的值和大于它的值一样多. 对于一个有着奇数个元素的集合, 集合排序后最中间的元素就是中位数, 对于偶数个元素的集合, 中位数是集合排序后最中间两个元素的平均值(两数相加除以2).

众数 Mode
在一个集合中,出现频率最高的数, 例如集合{1,1,1,2,2,3,4,4}中, 众数是1, 因为1出现了3次而其他元素的出现次数小于3. 相对的, 集合{1,2,3,4}就是多众数的, 因为每个元素的出现次数都不超过1次, 所以每个元素都是这个集合合法的众数.

有效数字和标量 Precision and Scale
有效数字 Precision 指一个数字中去除前后的零后, 余下有多少位.例如:

123.45 有效数字是5个, 1,2,3,4,5.
0.012345 有效数字是5个, 1,2,3,4,5.
120.45 有效数字是5个, 1,2,0,4,5.
0.012305 有效数字是5个, 1,2,3,0,5.

标度 scale 指小数点后有多少位, 例如
123.45 标度是2

题目输入

第一行,一个整数N,表示后面输入数组的元素个数
第二行, 包含了N个整数x的数组, 用逗号分隔
其中 10 <= N <= 2500
对每个整数x, 有0 < x < 105

求输出
三行,第一行求平均值,标度为1, 例如(12.3, 7.0)
第二行求中位数,标度为1
第三行求众数,如果有多个众数,求最小的那个.

scala

object Solution {
        import java.util.Scanner
        def main(args: Array[String]) {
            val scan: Scanner = new Scanner(System.in)
            try {
                val n: Int = scan.nextInt
                val array: Array[Long] = Array.ofDim(n)
                for (i <- 0 until n) array(i) = scan.nextLong
                println("%.1f".format(array.sum.toFloat / array.length)) //mean

                val sorted = array.sorted
                println("%.1f".format({ //median
                    if (sorted.length % 2 == 1) sorted(sorted.length / 2).toFloat
                    else (sorted(sorted.length / 2 - 1) + sorted(sorted.length / 2)) / 2f
                }))

                val groups: Map[Long, Array[Long]] = array.groupBy(e => e) //mode
                println(groups.toArray.map(g => (g._1, g._2.length)).groupBy(_._2).maxBy(_._1)._2.min._1)
            } finally {
                scan.close
            }
        }
    }

python

def main():
    n = int(input())
    array = [int(s) for s in input().split(" ")]

    _sum = sum(array)
    print("{0:.1f}".format(_sum / n))

    _len: int = len(array)
    half: int = int(_len / 2)
    _sorted: List[int] = sorted(array)
    median: float = _sorted[half]
    if _len % 2 == 0:
        median = (_sorted[half - 1] + median) / 2
    print("{0:.1f}".format(median))

    d: Dict[int, int] = dict([(k, 0) for k in array])
    for e in array:
        d[e] += 1

    _d: Dict[int, List[int]] = dict([(c, []) for c in d.values()])
    for k, c in d.items():
        _d[c].append(k)

    print(min(_d[max(_d.keys())]))


if __name__ == '__main__':
    main()

java

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Solution {

    public static void main(String[] args) {
        try (Scanner sc = new Scanner(System.in)) {
            IntStream is = IntStream.range(0, sc.nextInt()).map(i -> Integer.valueOf(sc.nextInt()));
            int[] array = is.toArray();
            System.out.printf("%.1f\n", IntStream.of(array).average().getAsDouble());

            int mid = array.length / 2;
            Arrays.sort(array);
            float median = (array[mid] + (array.length % 2 != 0 ? array[mid] : array[mid - 1])) / 2f;
            System.out.printf("%.1f\n", median);

            Map<Integer, Long> elementAndCounts = IntStream.of(array).mapToObj(Integer::valueOf).collect(Collectors.groupingBy(i -> i, Collectors.counting()));
            Optional<Map.Entry<Integer, Long>> max = elementAndCounts.entrySet().stream().max((e1, e2) -> (e1.getValue() == e2.getValue()) ? Comparator.<Integer>reverseOrder().compare(e1.getKey(), e2.getKey()) : Comparator.<Long>naturalOrder().compare(e1.getValue(), e2.getValue()));
            System.out.println(max.get().getKey());
        }
    }
}

推荐阅读更多精彩内容