如何计算一个人生日后的第10000天是什么时候？

Question

我想知道如何用基本Python解决这个问题（不使用库）：如何计算一个人生日后的10000天将是（或将是）什么时候。例如，考虑到2008年5月19日星期一，理想的日期是2035年10月5日星期五。（根据https://www.durrans.com/projects/calc/10000/index.html?dob=19/5/2008

到目前为止，我所做的是以下脚本

years = range(2000, 2050)
lst_days = []
count = 0
sum = 0
for year in years:
    if((year % 400 == 0) or  (year % 100 != 0) and  (year % 4 == 0)):   
        lst_days.append(366)
    else:
        lst_days.append(365)
while sum <= 10000:
        sum = sum + lst_days[count]
        count = count+1
print(count)

它估计了一个人从生日起10000天后的年龄（对于2000年以后出生的人）。但我对如何继续感到困惑。

Answer 1

我想出了一个解决方案，它不涉及库或包，只涉及循环和条件（闰年的帐户）：

def isLeapYear(years):
  if years % 4 == 0:
    if years % 100 == 0:
      if years % 400 == 0:
        return True
      else:
        return False
    else:
      return True
  else:
    return False

monthDays = [31,28,31,30,31,30,31,31,30,31,30,31]
sum = 0
sumDays = []
for i in monthDays:
  sumDays.append(365 - sum)
  sum += i

timeInp = input("Please enter your birthdate in the format dd/mm/yyyy\n")
timeInp = timeInp.split("/")
days = int(timeInp[0])
months = int(timeInp[1])
years = int(timeInp[2])
totDays = 10000

if totDays > 366:
  if isLeapYear(years):
    if months == 1 or months == 2:
      totDays -= (sumDays[months - 1] + 1 - days) + 1
    else:
      totDays -= (sumDays[months - 1] - days) + 1
  else:
    totDays -= (sumDays[months - 1] - days) + 1
  
  months = 1
  days = 1
  years += 1

while totDays > 366:
  if isLeapYear(years):
    totDays -= 366
  else:
    totDays -= 365
  years += 1

i = 0
while totDays != 0:
  if isLeapYear(years):
    monthDays[1] = 29
  else:
    monthDays[1] = 28
    
  if totDays >= monthDays[i]:
    months += 1
    totDays -= monthDays[i]
  elif totDays == monthDays[i]:
    months += 1
    totDays = 0
  else:
    days += totDays 
    if days % (monthDays[i] + 1)!= days:
      days %= monthDays[i] + 1
      months += 1
    totDays = 0

  if months == 13:
    months = 1
    years += 1

  i += 1
  if i == 12:
    i = 0

print(str(days) + "/" + str(months) + "/" + str(years))

顾名思义，isLeapYear（）接受一个参数years，并返回一个布尔值。

我们解决这个问题的第一步，就是把日期“翻译”到下一年。这使我们未来的计算更容易。为此，我们可以定义一个数组sumDays，它存储每个月完成一年（进入新年）所需的天数。然后，我们从总天数中减去该金额，计算闰年，并更新变量。

接下来，是简单的部分，只需跳过几年，而我们有足够的时间来完成一整年。

一旦我们不能再增加一整年，我们就只能一个月接一个月，直到我们的天数用完。

我希望这有帮助！如果您需要任何进一步的细节或澄清（或者如果我犯了错误），请告诉我：

样本测试用例：

输入#1：

19/05/2008

输出#1：

5/10/2035

输入#2：

05/05/2020

输出#2：

21/9/2047

输入#3：

29/02/2020

输出#3：

17/7/2047

我用这个网站检查了我的大部分解决方案：https://www.countcalculate.com/calendar/birthday-in-days/result

Answer 2

如果您导入库日期时间

import datetime
your_date = "01/05/2000"
(day, month, years) = your_date.split("/")
date = datetime.date(int(years), int(month), int(day))
date_10000 = date+datetime.timedelta(days=10000)
print(date_10000)

没有库脚本

your_date = "20/05/2000"
(day, month, year) = your_date.split("/")
days = 10000
year = int(year)
month = int(month)
day = int(day)
end=False
#m1,m3,m5,m7,m8,m10,m12=31
#m2=28
#m4,m6,m9,m11=30
m=[31,28,31,30,31,30,31,31,30,31,30,31]
while end!=True:
    if(((year % 400 == 0) or  (year % 100 != 0) and  (year % 4 == 0)) and(days-366>=0)):   
        days-=366
        year+=1
    elif(((year % 400 != 0) or  (year % 100 != 0) and  (year % 4 != 0)) and(days-366>=0)):
        days-=365
        year+=1
    else:
        end=True
end=False
if(((year % 400 == 0) or  (year % 100 != 0) and  (year % 4 == 0))):   
    m[1]=29
else:
    m[1]=28
while end!=True:
    if(days-m[month]>=0):
        days-=m[month]
        if(month+1!=12):
            month+=1
        else:
            year+=1
            if(((year % 400 == 0) or  (year % 100 != 0) and  (year % 4 == 0))):   
                m[1]=29
            else:
                m[1]=28
            month=0
    else:
        end=True

if(day+days>m[month]):
    day=day+days-m[month]+1
    if(month+1!=12):
        month+=1
    else:
        year+=1
        if(((year % 400 == 0) or  (year % 100 != 0) and  (year % 4 == 0))):   
            m[1]=29
        else:
            m[1]=28
        month=0
else:
    day=day+days
print(day,"/",month,"/",year)

Answer 3

只使用基本python包

基于“无特殊包”意味着只能使用基本python包，可以使用datetime。timedelta对于此类问题：

import datetime

start_date = datetime.datetime(year=2008, month=5, day=19)

end_date = start_date + datetime.timedelta(days=10000)

print(end_date.date())

没有任何基本软件包（并继续解决问题）

侧步甚至基本python包，并把问题向前推进，沿着以下路线的东西应该会有所帮助（我希望！）。

首先定义一个函数，确定一年是否为闰年：

def is_it_a_leap_year(year) -> bool:
    """
    Determine if a year is a leap year

    Args:
        year: int

    Extended Summary:
        According to:
            https://airandspace.si.edu/stories/editorial/science-leap-year
        The rule is that if the year is divisible by 100 and not divisible by
        400, leap year is skipped. The year 2000 was a leap year, for example,
        but the years 1700, 1800, and 1900 were not.  The next time a leap year
        will be skipped is the year 2100.
    """
    if year % 4 != 0:

        return False

    if year % 100 == 0 and year % 400 != 0:

        return False

    return True

然后定义一个函数来确定一个人的年龄（利用上述函数来识别闰年）：

def age_after_n_days(start_year: int,
                     start_month: int,
                     start_day: int,
                     n_days: int) -> tuple:
    """
    Calculate an approximate age of a person after a given number of days,
    attempting to take into account leap years appropriately.

    Return the number of days left until their next birthday

    Args:
        start_year (int): year of the start date
        start_month (int): month of the start date
        start_day (int): day of the start date
        n_days (int): number of days to elapse
    """

    # Check if the start date happens on a leap year and occurs before the
    # 29 February (additional leap year day)
    start_pre_leap = (is_it_a_leap_year(start_year) and start_month < 3)

    # Account for the edge case where you start exactly on the 29 February
    if start_month == 2 and start_day == 29:

        start_pre_leap = False

    # Keep a running counter of age
    age = 0

    # Store the "current year" whilst iterating through the days
    current_year = start_year

    # Count the number of days left
    days_left = n_days

    # While there is at least one year left to elapse...
    while days_left > 364:

        # Is it a leap year?
        if is_it_a_leap_year(current_year):

            # If not the first year
            if age > 0:

                days_left -= 366

            # If the first year is a leap year but starting after the 29 Feb...
            elif age == 0 and not start_pre_leap:

                days_left -= 365

            else:

                days_left -= 366

        # If not a leap year...
        else:

            days_left -= 365

        # If the number of days left hasn't dropped below zero
        if days_left >= 0:

            # Increment age
            age += 1

            # Increment year
            current_year += 1

    return age, days_left 

使用您的示例，您可以使用以下方法测试函数：

age, remaining_days = age_after_n_days(start_year=2000, start_month=5, start_day=19, n_days=10000)

现在你有了将要过去的完整年数和剩余天数

然后你可以用remaining_days算出确切的日期