在 Python 中找到最多人活着的年份

Question

给定一个包含出生和结束年份的人员列表（都在1900 和2000 之间），找出活着的人数最多的年份。

这是我有点蛮力的解决方案：

def most_populated(population, single=True):
    years = dict()
    for person in population:
        for year in xrange(person[0], person[1]):
            if year in years:
                years[year] += 1
            else:
                years[year] = 0
    return max(years, key=years.get) if single else \
           [key for key, val in years.iteritems() if val == max(years.values())]

print most_populated([(1920, 1939), (1911, 1944),
                      (1920, 1955), (1938, 1939)])
print most_populated([(1920, 1939), (1911, 1944),
                      (1920, 1955), (1938, 1939), (1937, 1940)], False)

我正在尝试在Python 中找到解决此问题的更有效方法。两者 - readability 和 efficiency 都很重要。此外，由于某种原因，我的代码不会打印 [1938, 1939] 而它应该打印。

更新

输入是元组的list，其中元组的第一个元素是人出生时的year，tuple 的第二个元素是死亡年份。

更新 2

结束年份（元组的第二部分）和人活着的年份一样重要（所以如果这个人在Sept 1939 死去（我们不关心月份），他实际上在 1939 年还活着，至少一部分）。这应该可以修复结果中缺少的 1939'。

最佳解决方案？

虽然可读性有利于@joran-beasley，但对于更大的输入，@njzk2 提供了最有效的算法。感谢@hannes-ovrén 在IPython notebook on Gist提供分析

Answer 1

我刚刚想到的另一个解决方案：

• 创建 2 个表，birthdates 和 deathdates。
• 在这些表中累积出生日期和死亡日期。
• 浏览这些表格以累积当时在世的人数。

总复杂度为O(n)

实施

from collections import Counter

def most_populated(population, single=True):
    birth = map(lambda x: x[0], population)
    death = map(lambda x: x[1] + 1, population)
    b = Counter(birth)
    d = Counter(death)
    alive = 0
    years = {}
    for year in range(min(birth), max(death) + 1):
        alive = alive + b[year] - d[year]
        years[year] = alive
    return max(years, key=years.get) if single else \
           [key for key, val in years.iteritems() if val == max(years.values())]

更好

from collections import Counter
from itertools import accumulate
import operator

def most_populated(population, single=True):
    delta = Counter(x[0] for x in population)
    delta.subtract(Counter(x[1]+1 for x in population))
    start, end = min(delta.keys()), max(delta.keys())
    years = list(accumulate(delta[year] for year in range(start, end)))
    return max(enumerate(years), key=operator.itemgetter(1))[0] + start if single else \
           [i + start for i, val in enumerate(years) if val == max(years)]

Answer 2

>>> from collections import Counter
>>> from itertools import chain
>>> def most_pop(pop):
...     pop_flat = chain.from_iterable(range(i,j+1) for i,j in pop)
...     return Counter(pop_flat).most_common()
...
>>> most_pop([(1920, 1939), (1911, 1944), (1920, 1955), (1938, 1939)])[0]

Answer 3

我会这样：

• 按出生年份对人员进行排序（unborn 列表）
• 从第一胎开始
  • 将该人放入alive 列表中
  • 使用按死亡日期的插入排序（列表保持排序，因此使用二分搜索）
  • 直到你遇到一个不是那年出生的人
• 然后，从alive 列表中最先死亡的人开始，将其从列表中移除。
• 将alive 列表的大小放入字典中
• 增加年份
• 循环直到unborn 和alive 列表为空

复杂度应该在O((m + n) * log(m))左右（每年只考虑一次，每个人只考虑两次，乘以alive列表中的插入成本）

实施

from bisect import insort

def most_populated(population, single=True):
    years = dict()
    unborn = sorted(population, key=lambda x: -x[0])
    alive = []
    dead = []
    for year in range(unborn[-1][0], max(population, key=lambda x: x[1])[1] + 1):
        while unborn and unborn[-1][0] == year:
            insort(alive, -unborn.pop()[1])
        while alive and alive[-1] == -(year - 1):
            dead.append(-alive.pop())
        years[year] = len(alive)
    return max(years, key=years.get) if single else \
           [key for key, val in years.iteritems() if val == max(years.values())]

Answer 4

我们也可以使用numpy slicing，相当简洁，应该也相当高效：

import numpy as np
from collections import namedtuple

Person = namedtuple('Person', ('birth', 'death'))
people = [Person(1900,2000), Person(1950,1960), Person(1955, 1959)]

START_YEAR = 1900
END_YEAR = 2000
people_alive = np.zeros(END_YEAR - START_YEAR + 1) # Alive each year

for p in people:
    a = p.birth - START_YEAR
    b = p.death - START_YEAR + 1 # include year of death
    people_alive[a:b] += 1

# Find indexes of maximum aliveness and convert to year
most_alive = np.flatnonzero(people_alive == people_alive.max()) + START_YEAR

EDIT 似乎 namedtuple 增加了一些开销，所以为了加快速度，删除 namedtuple 并执行 for birth, death in people: 代替。

Answer 5

1. 只需将出生和死亡年份放入字典即可。如果是出生，则将该值增加 1。反之亦然。
2. 按键对字典进行排序，并通过读取当前存活人数进行迭代。

3. 按照 'maxAlive' 和 'theYear' 获得最高数字的第一年

   years = {} 
   
   for p in people:
       if p.birth in years:
           years[p.birth] += 1
       else:
           years[p.birth] = 1
   
       if p.death in years:
           years[p.death] -= 1
       else:
           years[p.death] = -1
   
   alive = 0
   maxAlive = 0
   theYear = people[0].birth
   for year in sorted(years):
       alive += years[year]
       if alive > maxAlive:
           maxAlive = alive
           theYear = year
   

Answer 6

不导入任何东西，并使用一个类来提高可读性，这是我的解决方案。让我知道你的想法！我还为 getMaxBirthYear 制作了一个单独的函数，以防你在面试中并且有人希望你编写代码而不是使用内置函数（我使用了它们:)）

class Person:
  def __init__(self, birth=None, death=None):
    self.birth=birth
    self.death=death

def getPopulationPeak(people):
  maxBirthYear = getMaxBirthYear(people)
  deltas = getDeltas(people, maxBirthYear)
  currentSum = 0 
  maxSum = 0
  maxYear = 0
  for year in sorted(deltas.keys()):
    currentSum += deltas[year]
    if currentSum > maxSum:
      maxSum = currentSum
      maxYear = year
  return maxYear, maxSum

def getMaxBirthYear(people):
  return max(people, key=lambda x: x.birth).birth

def getDeltas(people, maxBirthYear):
  deltas = dict()
  for person in people:
    if person.birth in deltas.keys():
      deltas[person.birth] += 1
    else:
      deltas[person.birth] = 1
    if person.death + 1 in deltas.keys():
      deltas[person.death + 1] -= 1
    elif person.death + 1 not in deltas.keys() and person.death <= maxBirthYear: # We can skip deaths after the last birth year
      deltas[person.death + 1] = -1
  return deltas

testPeople = [
  Person(1750,1802),
  Person(2000,2010),
  Person(1645,1760),
  Person(1985,2002),
  Person(2000,2050),
  Person(2005,2080),
]

print(getPopulationPeak(testPeople))

Answer 7

这个怎么样：

def max_pop(pop):
    p = 0; max = (0,0)
    for y,i in sorted(chain.from_iterable([((b,1), (d+1,-1)) for b,d in pop])):
        p += i
        if p > max[1]: max=(y,p)
    return max

它不受年份跨度的影响，但在 |pop| 中为 nlogn （除非你推出一个基数排序，在一千年的跨度内约为 10n 并且对于 |pop|>1000 应该更快）。不能两者兼得。一个非常通用的解决方案必须首先扫描并根据测量的年份跨度和 |pop| 决定使用哪种算法。

Answer 8

我的回答

import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class AlogrimVarsta {

    public static void main(String args[]) {

        int startYear = 1890;
        int stopYear = 2000;

        List<Person> listPerson = new LinkedList<>();

        listPerson.add(new Person(1910, 1940));
        listPerson.add(new Person(1920, 1935));
        listPerson.add(new Person(1900, 1950));
        listPerson.add(new Person(1890, 1920));
        listPerson.add(new Person(1890, 2000));
        listPerson.add(new Person(1945, 2000));

        Map<Integer, Integer> mapPersoaneCareAuTrait = new LinkedHashMap<>();

        for (int x = startYear; x <= stopYear; x++) {
            mapPersoaneCareAuTrait.put(x, 0);
        }

        for (int x = startYear; x <= stopYear; x++) {
            for (Person per : listPerson) {

                int value = mapPersoaneCareAuTrait.get(x);

                if (per.getBorn() == x) {
                    mapPersoaneCareAuTrait.put(x, value + 1);
                    continue;
                }

                if (per.getDie() == x) {
                    mapPersoaneCareAuTrait.put(x, value + 1);
                    continue;
                }

                if ((per.getDie() - per.getBorn() > per.getDie() - x) && (per.getDie() - x > 0)) {
                    mapPersoaneCareAuTrait.put(x, value + 1);
                    continue;
                }

            }
        }

        for (Map.Entry<Integer, Integer> mapEntry : mapPersoaneCareAuTrait.entrySet()) {
            System.out.println("an " + mapEntry.getKey() + " numar " + mapEntry.getValue());            
        }

    }

    static class Person {
        final private int born;
        final private int die;

        public Person(int pBorn, int pDie) {
            die = pDie;
            born = pBorn;
        }

        public int getBorn() {
            return born;
        }

        public int getDie() {
            return die;
        }
    }
}

Answer 9

l = [(1920, 1939), (1911, 1944),(1920, 1955), (1938, 1939)]
union = set({})
for i in l:
    temp = set(range(min(i), max(i) + 1))
    if len(union) == 0:
        union = temp
    union = temp & union
print(union)

Answer 10

下面的代码正是你所需要的。

假设年份范围是 1900 - 2000

算法步骤

1. 构造一个包含 100 个整数的数组 X（全部初始化为零；如果包括 2000 年，则为 101 个整数）。
2. 对于 N 个人中的每一个人，将 X[birth year - 1900] 加一，X[death year - 1900] 减一。
3. 遍历 X，同时保持每个元素的总和。活着的人最多的年份是 1900 年加上总和最大的指数。

代码（根据要求使用 Python）

def year_with_max_population(people):
population_changes = [0 for _ in xrange(1900, 2000)]
for person in people:
    population_changes[person.birth_year - 1900] += 1
    population_changes[person.death_year - 1900] -= 1
max_population = 0
max_population_index = 0
population = 0
for index, population_change in enumerate(population_changes):
    population += population_change
    if population > max_population:
        max_population = population
        max_population_index = index
return 1900 + max_population_index

感谢'Brian Schmitz'here