ਉਮਰ ਕ੍ਰੈਲਕੁਲੇਟਰ — ਸਾਲਾਂ, ਮਹੀਨਿਆਂ ਅਤੇ ਦਿਨਾਂ ਵਿੱਚ ਸਹੀ ਉਮਰ

ਇਹ ਕੈਲਕੁਲੇਟਰ ਕੀ ਕਰਦਾ ਹੈ

ਆਪਣੀ ਜਨਮ ਦੀ ਤਾਰੀਖ ਟਾਈਪ ਕਰੋ ਅਤੇ ਇਹ ਤੁਹਾਨੂੰ ਬਿਲਕੁਲ ਠੀਕ ਉਮਰ ਦੱਸਦਾ ਹੈ — ਸਾਲਾਂ, ਮਹੀਨਿਆਂ ਅਤੇ ਦਿਨਾਂ ਵਿੱਚ — ਉਸੇ ਤਰ੍ਹਾਂ ਜਿਵੇਂ ਤੁਸੀ ਇਸ ਨੂੰ ਜੋਰ ਨਾਲ ਕਹਿੰਦੇ ਹੋ ("ਮੈਂ 33 ਸਾਲ, 4 ਮਹੀਨੇ ਅਤੇ 5 ਦਿਨ ਪੁਰਾਣਾ ਹਾਂ")। ਇਹ ਉਸੇ ਉਮਰ ਨੂੰ ਸ਼ੁੱਧ ਮਹੀਨਿਆਂ, ਹਫ਼ਤਿਆਂ, ਦਿਨਾਂ, ਘੰਟਿਆਂ, ਮਿੰਟਾਂ ਅਤੇ ਸਕਿੰਟਾਂ ਵਿੱਚ ਵੀ ਦਰਸਾਉਂਦਾ ਹੈ, ਉਹ ਵਾਰ ਜਿਸ ਦਿਨ ਤੁਸੀ ਪੈਦਾ ਹੋਏ ਸੀ, ਅਤੇ ਤੁਹਾਡੇ ਅਗਲੇ ਜਨਮ ਦਿਨ ਤੱਕ ਕਿੰਨਾ ਸਮਾਂ ਬਾਕੀ ਹੈ।

ਦੂਜੀ ਫੀਲਡ ਨੂੰ ਅੱਜ ਦੀ ਤਾਰੀਖ 'ਤੇ ਛੱਡੋ ਆਪਣੀ ਮੌਜੂਦਾ ਉਮਰ ਲਈ, ਜਾਂ ਇਸ ਨੂੰ ਕਿਸੇ ਪਿਛਲੀ ਜਾਂ ਭਵਿਸ਼ਯ ਦੀ ਤਾਰੀਖ 'ਤੇ ਬਦਲੋ ਉਸ ਤਾਰੀਖ 'ਤੇ ਆਪਣੀ ਉਮਰ ਲੱਭਣ ਲਈ।

ਇੱਕ ਨਿਯਮ ਜੋ ਉਮਰ ਨੂੰ ਗੁੰਝਲਦਾਰ ਬਣਾਉਂਦਾ ਹੈ: ਮਹੀਨੇ ਅਤੇ ਸਾਲ ਇੱਕ ਨਿਸ਼ਚਿਤ ਸੰਖਿਆ ਦੇ ਦਿਨ ਨਹੀਂ ਹਨ। ਫਰਵਰੀ ਵਿੱਚ 28 ਜਾਂ 29 ਦਿਨ ਹੁੰਦੇ ਹਨ; ਹੋਰ ਮਹੀਨਿਆਂ ਵਿੱਚ 30 ਜਾਂ 31 ਹੁੰਦੇ ਹਨ। ਇਸ ਲਈ "1 ਮਹੀਨਾ" ਦਾ ਮਤਲਬ ਹੈ "ਉਹੀ ਦਿਨ ਸੰਖਿਆ, ਇੱਕ ਮਹੀਨਾ ਬਾਅਦ ਵਿੱਚ" — "30 ਦਿਨ" ਨਹੀਂ। ਇਹ ਕੈਲਕੁਲੇਟਰ ਉਸ ਕੈਲੰਡਰ ਨਿਯਮ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ, ਜਿਸ ਲਈ ਇਹ ਅਜਿਹੇ ਸਾਧਨਾਂ ਤੋਂ ਇੱਕ ਜਾਂ ਦੋ ਦਿਨ ਦੁਆਰਾ ਵੱਖਰਾ ਹੋ ਸਕਦਾ ਹੈ ਜੋ ਸਿਰਫ 30 ਜਾਂ 365 ਨਾਲ ਵੰਡਦੇ ਹਨ।

ਤੁਹਾਡੀ ਉਮਰ ਕਿਵੇਂ ਕੰਮ ਕੀਤੀ ਜਾਂਦੀ ਹੈ

ਉਮਰ ਦੋ ਤਾਰੀਖਾਂ ਦੇ ਵਿਚਕਾਰ ਦਾ ਅੰਤਰ ਹੈ। ਉਸ ਅੰਤਰ ਨੂੰ ਮਾਪਣ ਦੇ ਦੋ ਸਚੇ ਤਰੀਕੇ ਹਨ, ਅਤੇ ਇਹ ਸਾਧਨ ਦੋਵੇਂ ਦਰਸਾਉਂਦਾ ਹੈ।

1. ਕੈਲੰਡਰ ਉਮਰ (ਸਾਲ, ਮਹੀਨੇ, ਦਿਨ)। ਤੁਹਾਡੇ ਜਨਮ ਦਿਨ ਤੋਂ ਪੂਰੇ ਸਾਲਾਂ ਦੀ ਗਣਨਾ ਕਰੋ, ਫਿਰ ਪੂਰੇ ਮਹੀਨੇ, ਫਿਰ ਬਚੇ ਹੋਏ ਦਿਨ:

1. ਜਨਮ ਦੇ ਬਾਅਦ ਪੂਰੇ ਸਾਲਾਂ ਦੀ ਗਣਨਾ ਕਰੋ।
2. ਆਖਰੀ ਜਨਮ ਦਿਨ ਤੋਂ, ਪੂਰੇ ਮਹੀਨਿਆਂ ਦੀ ਗਣਨਾ ਕਰੋ।
3. ਉਥੋਂ, ਬਚੇ ਹੋਏ ਦਿਨਾਂ ਦੀ ਗਣਨਾ ਕਰੋ।

ਸੂਖਮ ਭਾਗ ਮਹੀਨੇ ਦੀ ਸੀਮਾ ਦੇ ਨੇੜੇ ਹੈ। ਕੋਈ ਜਿਸ ਦਾ ਜਨਮ 31 ਜਨਵਰੀ ਨੂੰ ਹੋਇਆ, 1 ਮਾਰਚ ਨੂੰ ਮਾਪਿਆ ਗਿਆ, ਹੈ 1 ਮਹੀਨਾ ਅਤੇ 1 ਦਿਨ ਪੁਰਾਣਾ — ਕਿਉਂਕਿ "ਜਨ 31 ਤੋਂ ਇੱਕ ਮਹੀਨਾ ਬਾਅਦ" ਫ਼ਰ 28/29 (ਫ਼ਰ 31 ਨਹੀਂ ਹੈ) ਉੱਤਰ ਲੈਂਦਾ ਹੈ, ਅਤੇ 1 ਮਾਰਚ ਉਸ ਤੋਂ ਇੱਕ ਦਿਨ ਬਾਅਦ ਹੈ। ਇਹ ਕੈਲਕੁਲੇਟਰ ਛੋਟੇ ਮਹੀਨੇ ਦੇ ਅਖੀਰ ਤੱਕ ਕਲੈਂਪ ਕਰਦਾ ਹੈ, ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਵਰਤੇ ਜਾਂਦੇ dateutil.relativedelta ਨਿਯਮ ਨਾਲ ਮਿਲਦਾ ਹੈ ਇਸ ਲਈ ਮਹੀਨੇ ਦੇ ਅੰਤ ਦੇ ਜਨਮ ਦਿਨ ਕਦੇ ਨਕਾਰਾਤਮਕ ਦਿਨ ਦੀ ਸੰਖਿਆ ਨਹੀਂ ਦਿੰਦੇ।

2. ਕੁਲ ਬੀਤਿਆ ਹੋਇਆ ਸਮਾਂ (ਦਿਨ, ਘੰਟੇ, ਸਕਿੰਟ)। "ਤੁਹਾਡੀ ਉਮਰ ਹੋਰ ਇਕਾਈਆਂ ਵਿੱਚ" ਅੰਕੜਿਆਂ ਲਈ, ਦੋ ਤਾਰੀਖਾਂ ਨੂੰ ਪੂਰੇ ਦਿਨਾਂ ਦੀ ਸੰਖਿਆ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਗੁਣਾ ਜਾਂਦਾ ਹੈ:

$\text{days} = \left\lfloor \frac{\text{target date} - \text{birth date}}{86{,}400{,}000 \text{ ms}} \right\rfloor$

ਦੋਵੇਂ ਤਾਰੀਖਾਂ ਪਹਿਲਾਂ UTC ਅੱਧੀ ਰਾਤ 'ਤੇ ਸਥਿਰ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਦਿਨ ਦੀ ਬਚਤ ਵਾਲੀ ਚੀਜ਼ ਤਬਦੀਲੀ ਇੱਕ ਘੰਟਾ ਨਹੀਂ ਜੋੜ ਜਾਂ ਕੱਢ ਸਕਦੀ ਅਤੇ ਦਿਨ ਦੀ ਸੰਖਿਆ ਨੂੰ ਬਰਬਾਦ ਨਹੀਂ ਕਰ ਸਕਦੀ। ਹਫ਼ਤੇ ਦਿਨ ÷ 7 (ਹੇਠਾਂ ਨੇ ਚੁਣਿਆ); ਘੰਟੇ, ਮਿੰਟ ਅਤੇ ਸਕਿੰਟ ਦਿਨ ਦੀ ਗਿਣਤੀ ਨੂੰ ਸਕੇਲ ਕੀਤੇ ਹਨ।

ਸਿਰਫ ਦਿਨਾਂ ਨੂੰ 365 ਨਾਲ ਕਿਉਂ ਨਾ ਵੰਡਿਆ ਜਾਵੇ? ਕਿਉਂਕਿ ਤੁਸੀ ਭਟਕ ਜਾਓ ਗੇ। 7,305 ਦਿਨਾਂ ਨੂੰ 365 ਨਾਲ ਵੰਡਣਾ 20.01 ਸਾਲ ਦਿੰਦਾ ਹੈ; 365.25 ਨਾਲ ਵੰਡਣਾ 20.00 ਦਿੰਦਾ ਹੈ — ਲੇਕਿਨ ਨਾ ਕਿ ਜਾਣਦਾ ਹੈ ਕਿਹੜੇ ਸਾਲ ਲੀਪ ਸਾਲ ਸੀ ਜਾਂ ਕਿਹੜੇ ਮਹੀਨਿਆਂ ਦੁਆਰਾ ਤੁਸੀ ਅਸਲ ਵਿੱਚ ਰਹਿੰਦੇ ਸੀ। ਕੈਲੰਡਰ ਗਿਣਤੀ ਸਹੀ ਹੈ; ਦਿਨ-ਵੰਡਿਆ ਇੱਕ ਅੰਦਾਜ਼ਾ ਹੈ। "ਮੈ ਕਿੰਨਾ ਪੁਰਾਣਾ ਹਾਂ" ਲਈ ਕੈਲੰਡਰ ਉਮਰ ਵਰਤੋ, ਅਤੇ ਸਹੀ ਬੀਤਿਆ ਹੋਇਆ-ਸਮਾਂ ਕੰਮ ਲਈ ਕੁਲ ਦਿਨ/ਹਫ਼ਤੇ (ਦਵਾਈ ਦਾ ਸਮਾਂ, ਪ੍ਰਾਜੈਕਟ ਦੇ ਅਵਾਂ, ਮਾਈਲ ਸਟੋਨ ਕਾਊਂਟਡਾਉਨ)।

ਕੰਮ ਕੀਤਾ ਉਦਾਹਰਣ

ਜਨਮ 1 ਜਨਵਰੀ 2000, ਮਾਪਿਆ ਗਿਆ 1 ਜਨਵਰੀ 2020:

7,305 ਦਿਨ = 20 × 365 + 5 ਲੀਪ ਦਿਨ (2000, 2004, 2008, 2012, 2016)। ਉਹ ਸਿੰਗਲ ਵਿਵਰਨ — ਪੰਜ ਵਾਧੂ ਦਿਨ ਬਹੁਤ ਸਾਰੇ ਲੋਕ ਭੁੱਲ ਜਾਂਦੇ ਹਨ — ਬਿਲਕੁਲ ਕਿਉਂ ਇੱਕ ਕੈਲਕੁਲੇਟਰ ਮਾਨਸਿਕ ਗਣਿਤ ਨੂੰ ਹਰਾ ਦਿੰਦਾ ਹੈ।

ਕੋਡ ਵਿੱਚ ਉਮਰ

ਹਰੇਕ ਭਾਸ਼ਾ ਵਿੱਚ ਸਮਾਨ ਗਣਨਾ। ਕੈਲੰਡਰ ਉਮਰ ਲਈ, ਹੱਥ-ਲੁਚਿਤ ਗਣਿਤ ਉੱਤੇ ਬਿਲਟ-ਇਨ ਤਾਰੀਖ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਤਰਜੀਹ ਦਿਓ — ਇਹ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਲੀਪ ਸਾਲ ਅਤੇ ਮਹੀਨਿਆਂ ਦੀ ਲੰਬਾਈ ਜਾਣਦਾ ਹੈ।

1' Whole days between two dates (A1 = birth, B1 = target):
2=B1-A1
3
4' Calendar age in complete years / months / leftover days:
5=DATEDIF(A1, B1, "y") & " years, " & DATEDIF(A1, B1, "ym") & " months, " & DATEDIF(A1, B1, "md") & " days"
6

1from dateutil.relativedelta import relativedelta
2from datetime import date
3
4birth, target = date(2000, 1, 1), date(2020, 1, 1)
5
6age = relativedelta(target, birth)          # calendar age
7print(f"{age.years}y {age.months}m {age.days}d")
8
9total_days = (target - birth).days           # total elapsed days
10print(total_days)                            # 7305
11

1function calendarAge(birth, target) {
2  let months = (target.getUTCFullYear() - birth.getUTCFullYear()) * 12
3             + (target.getUTCMonth() - birth.getUTCMonth());
4  const anchor = new Date(Date.UTC(birth.getUTCFullYear(), birth.getUTCMonth() + months, birth.getUTCDate()));
5  if (anchor > target) months--;
6  return { years: Math.floor(months / 12), months: months % 12 };
7}
8
9const birth = new Date(Date.UTC(2000, 0, 1));
10const target = new Date(Date.UTC(2020, 0, 1));
11const totalDays = Math.floor((target - birth) / 86400000); // 7305
12

1import java.time.LocalDate;
2import java.time.Period;
3import java.time.temporal.ChronoUnit;
4
5LocalDate birth = LocalDate.of(2000, 1, 1);
6LocalDate target = LocalDate.of(2020, 1, 1);
7
8Period age = Period.between(birth, target);   // 20y 0m 0d
9long totalDays = ChronoUnit.DAYS.between(birth, target); // 7305
10

1using System;
2
3var birth = new DateTime(2000, 1, 1);
4var target = new DateTime(2020, 1, 1);
5
6int years = target.Year - birth.Year;
7if (birth.AddYears(years) > target) years--;   // not birthday yet
8long totalDays = (target - birth).Days;         // 7305
9

1#include <chrono>
2using namespace std::chrono;
3
4// C++20 calendar types
5sys_days birth = year{2000}/1/1;
6sys_days target = year{2020}/1/1;
7
8auto total_days = (target - birth).count();     // 7305
9years_months_days ymd_diff{birth, target};      // year_month_day arithmetic
10

1package main
2
3import "time"
4
5func main() {
6    birth := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
7    target := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
8    totalDays := int(target.Sub(birth).Hours() / 24) // 7305
9    _ = totalDays
10}
11

1use chrono::{NaiveDate, Datelike};
2
3let birth = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
4let target = NaiveDate::from_ymd_opt(2020, 1, 1).unwrap();
5
6let total_days = (target - birth).num_days(); // 7305
7let years = target.year() - birth.year();     // adjust if birthday not reached
8

1<?php
2$birth = new DateTime('2000-01-01');
3$target = new DateTime('2020-01-01');
4$diff = $birth->diff($target);
5
6echo "{$diff->y}y {$diff->m}m {$diff->d}d\n"; // 20y 0m 0d
7echo $diff->days;                             // 7305
8

1require 'date'
2
3birth  = Date.new(2000, 1, 1)
4target = Date.new(2020, 1, 1)
5
6total_days = (target - birth).to_i           # 7305
7years = target.year - birth.year
8years -= 1 if birth.next_year(years) > target
9

1birth  <- as.Date("2000-01-01")
2target <- as.Date("2020-01-01")
3
4total_days <- as.integer(target - birth)     # 7305
5

ਆਮ ਸਵਾਲ

ਮੈ ਬਿਲਕੁਲ ਕਿੰਨਾ ਪੁਰਾਣਾ ਹਾਂ? ਆਪਣੀ ਜਨਮ ਦੀ ਤਾਰੀਖ ਦਰਜ ਕਰੋ ਅਤੇ ਟਾਰਗੇਟ ਨੂੰ ਅੱਜ 'ਤੇ ਛੱਡੋ। ਕੈਲਕੁਲੇਟਰ ਤੁਹਾਡੀ ਉਮਰ ਸਾਲਾਂ, ਮਹੀਨਿਆਂ ਅਤੇ ਦਿਨਾਂ ਵਿੱਚ ਦਰਸਾਉਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਕੁਲ ਦਿਨਾਂ, ਹਫ਼ਤਿਆਂ, ਘੰਟਿਆਂ ਅਤੇ ਸਕਿੰਟਾਂ ਵਿੱਚ ਦੁਹਰਾਉਂਦਾ ਹੈ।

ਮੇਰੀ ਉਮਰ ਇੱਕ ਹੋਰ ਕੈਲਕੁਲੇਟਰ ਤੋਂ ਕਿਉਂ ਵੱਖਰੀ ਹੈ? ਲਗਭਗ ਹਮੇਸ਼ਾ ਮਹੀਨਾ/ਦਿਨ ਦਾ ਬਾਕੀ। ਸਾਧਨ ਮਹੀਨੇ ਦੀ ਸੀਮਾ ਦੇ ਬਾਅਦ ਦੇ ਦਿਨਾਂ ਦੀ ਗਣਨਾ ਕਰਨ ਦੇ ਤਰੀਕੇ 'ਤੇ ਅਸਹਮਤ ਹਨ। ਇਹ ਛੋਟੇ ਮਹੀਨੇ ਵਿੱਚ ਕਲੈਂਪ ਕਰਦਾ ਹੈ (relativedelta ਕੋ); ਇੱਕ ਸਾਧਨ ਜੋ 30 ਨਾਲ ਵੰਡਦਾ ਹੈ ਇੱਕ ਜਾਂ ਦੋ ਦਿਨ ਨਾਲ ਭਿੰਨ ਹੋਵੇਗਾ।

ਕੀ ਇਹ ਲੀਪ ਸਾਲ ਅਤੇ ਫਰਵਰੀ 29 ਜਨਮ ਦਿਨਾਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ? ਹਾਂ। ਦਿਨ ਦੀ ਸੰਖਿਆ ਵਿੱਚ ਰੇਂਜ ਵਿੱਚ ਹਰੇਕ ਲੀਪ ਦਿਨ ਸ਼ਾਮਲ ਹੈ, ਅਤੇ ਇੱਕ ਫ਼ਰ 29 ਦਾ ਜਨਮ ਦਿਨ ਗ਼ੈਰ-ਲੀਪ ਸਾਲਾਂ ਵਿੱਚ ਫ਼ਰ 28 / 1 ਮਾਰ ਦੇ ਵਿਰੁੱਧ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ ਪ੍ਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ।

ਕੀ ਮੈ ਕੋਈ ਪਿਛਲੀ ਜਾਂ ਭਵਿਸ਼ਯ ਦੀ ਤਾਰੀਖ 'ਤੇ ਉਮਰ ਦੀ ਗਣਨਾ ਕਰ ਸਕਦਾ ਹਾਂ? ਹਾਂ — "ਉਮਰ ਦੇ ਟਾਰਗੇਟ ਦੀ ਤਾਰੀਖ" ਨੂੰ ਕਿਸੇ ਵੀ ਤਾਰੀਖ 'ਤੇ ਸੈੱਟ ਕਰੋ। ਇੱਕ ਭਵਿਸ਼ਯ ਦੀ ਤਾਰੀਖ ਦੱਸਦੀ ਹੈ ਕਿ ਤੁਸੀ ਉਦੋਂ ਕਿੰਨੇ ਪੁਰਾਣੇ ਹੋਵੋਗੇ; ਪਿਛਲੀ, ਤੁਸੀ ਕਿੰਨੇ ਪੁਰਾਣੇ ਸੀ।

ਸਮਾਂ ਖੇਤਰ ਬਾਰੇ ਕੀ? ਗਣਨਾ ਤੋਂ ਪਹਿਲੇ ਤਾਰੀਖਾਂ ਨੂੰ UTC ਵਿੱਚ ਸਧਾਰਣ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ ਪੂਰੇ-ਦਿਨ ਦਾ ਕੁਲ ਸਥਿਰ ਹੈ ਕਿ ਤੁਸੀ ਕਿੱਥੇ ਹੋ ਜਾਂ ਦਿਨ ਦੀ ਬਚਤ ਤਬਦੀਲ ਹੋ ਗਈ।

ਸ੍ਰੋਤ

1. Python dateutil — relativedelta (ਕੈਲੰਡਰ-ਉਮਰ ਮਹੀਨਾ/ਦਿਨ ਨਿਯਮ ਇਹ ਸਾਧਨ ਅਨੁਸਰਣ ਕਰਦਾ ਹੈ)।
2. Java Platform — Period.between ਅਤੇ ChronoUnit.DAYS।
3. Microsoft Excel — DATEDIF ਫ਼ੰਕਸ਼ਨ।
4. MDN Web Docs — Date।
5. Dershowitz, N., & Reingold, E. M. Calendrical Calculations: The Ultimate Edition. Cambridge University Press, 2018।