ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਵਾਲਾ ਕੈਲਕੁਲੇਟਰ

ਪੇਸ਼ਕਸ਼

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

ਗਿਣਤੀ ਕਰਨ ਦਾ ਤਰੀਕਾ

ਦੋ ਤਾਰੀਖਾਂ ਦੇ ਵਿਚਕਾਰ ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਦੋਨੋਂ ਤਾਰੀਖਾਂ ਨੂੰ ਇੱਕ ਸਾਂਝੇ ਸਮਾਂ ਪ੍ਰਤੀਨਿਧੀ (ਆਮ ਤੌਰ 'ਤੇ ਯੂਨਿਕਸ ਟਾਈਮਸਟੈਂਪ ਜਾਂ ਜੂਲਿਅਨ ਤਾਰੀਖ) ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਇਨ੍ਹਾਂ ਪ੍ਰਤੀਨਿਧੀਆਂ ਦੇ ਵਿਚਕਾਰ ਅੰਤਰ ਲੱਭਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਤਰੀਕਾ ਹੇਠ ਲਿਖੀਆਂ ਗੱਲਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦਾ ਹੈ:

1. ਲੀਪ ਸਾਲ: ਉਹ ਸਾਲ ਜੋ 4 ਨਾਲ ਭਾਗ ਦੇਣ ਵਾਲੇ ਹੁੰਦੇ ਹਨ ਉਹ ਲੀਪ ਸਾਲ ਹੁੰਦੇ ਹਨ, ਸਿਵਾਏ ਸਦੀ ਦੇ ਸਾਲਾਂ ਲਈ, ਜੋ 400 ਨਾਲ ਭਾਗ ਦੇਣੇ ਚਾਹੀਦੇ ਹਨ ਤਾਂ ਜੋ ਉਹ ਲੀਪ ਸਾਲ ਹੋਣ।
2. ਮਹੀਨਿਆਂ ਦੀ ਵੱਖ-ਵੱਖ ਲੰਬਾਈ: ਵੱਖ-ਵੱਖ ਮਹੀਨਿਆਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਹੁੰਦੀ ਹੈ (28-31)।
3. ਕੈਲੰਡਰ ਸਿਸਟਮ ਵਿੱਚ ਬਦਲਾਅ: ਵੱਖ-ਵੱਖ ਖੇਤਰਾਂ ਵਿੱਚ ਜੂਲਿਅਨ ਤੋਂ ਗ੍ਰੇਗੋਰਿਅਨ ਕੈਲੰਡਰ ਵਿੱਚ ਬਦਲਾਅ।

ਦੋ ਤਾਰੀਖਾਂ (ਤਾਰੀਖ1 ਅਤੇ ਤਾਰੀਖ2) ਦੇ ਵਿਚਕਾਰ ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਬੁਨਿਆਦੀ ਫਾਰਮੂਲਾ ਹੈ:

1days_between = |date2_timestamp - date1_timestamp| / (86400)
2

ਜਿੱਥੇ ਟਾਈਮਸਟੈਂਪ ਸੈਕੰਡਾਂ ਵਿੱਚ ਹਨ, ਅਤੇ 86400 (24 * 60 * 60) ਨਾਲ ਵੰਡਣਾ ਸੈਕੰਡਾਂ ਨੂੰ ਦਿਨਾਂ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।

ਹੋਰ ਸਹੀ ਗਿਣਤੀਆਂ ਲਈ, ਖਾਸ ਕਰਕੇ ਇਤਿਹਾਸਕ ਤਾਰੀਖਾਂ ਜਾਂ ਵੱਖ-ਵੱਖ ਕੈਲੰਡਰ ਸਿਸਟਮਾਂ ਦੇ ਨਾਲ ਜੁੜੀਆਂ ਗਿਣਤੀਆਂ ਕਰਨ ਵੇਲੇ, ਜੂਲਿਅਨ ਡੇਅ ਨੰਬਰ (JDN) ਬਦਲਾਅ ਵਰਗੀਆਂ ਹੋਰ ਜਟਿਲ ਅਲਗੋਰਿਦਮਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਜੂਲਿਅਨ ਤਾਰੀਖ ਦੀ ਗਿਣਤੀ

ਜੂਲਿਅਨ ਤਾਰੀਖ (JD) ਜੂਲਿਅਨ ਪੀਰੀਅਡ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਦਿਨਾਂ ਦੀ ਇੱਕ ਲਗਾਤਾਰ ਗਿਣਤੀ ਹੈ। ਇਹ ਖਗੋਲੀਅ ਤਰੱਕੀਆਂ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਵੱਖ-ਵੱਖ ਕੈਲੰਡਰ ਸਿਸਟਮਾਂ ਵਿੱਚ ਤਾਰੀਖਾਂ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਇੱਕ ਮਿਆਰੀ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਗ੍ਰੇਗੋਰਿਅਨ ਤਾਰੀਖ ਨੂੰ ਜੂਲਿਅਨ ਤਾਰੀਖ ਵਿੱਚ ਬਦਲਣ ਦਾ ਫਾਰਮੂਲਾ ਹੈ:

JD = (1461 * (Y + 4800 + (M - 14)/12))/4 + (367 * (M - 2 - 12 * ((M - 14)/12)))/12 - (3 * ((Y + 4900 + (M - 14)/12)/100))/4 + D - 32075

ਜਿੱਥੇ:

• Y ਸਾਲ ਹੈ
• M ਮਹੀਨਾ ਹੈ (1-12)
• D ਮਹੀਨੇ ਦਾ ਦਿਨ ਹੈ (1-31)

ਇਹ ਗਿਣਤੀ ਲੀਪ ਸਾਲਾਂ ਅਤੇ ਜੂਲਿਅਨ ਅਤੇ ਗ੍ਰੇਗੋਰਿਅਨ ਕੈਲੰਡਰਾਂ ਦੇ ਵਿਚਕਾਰ ਬਦਲਾਅ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੀ ਹੈ।

ਵਰਤੋਂ ਦੇ ਕੇਸ

ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਵਾਲਾ ਕੈਲਕੁਲੇਟਰ ਵੱਖ-ਵੱਖ ਵਾਸਤਵਿਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਹੈ:

1. ਪ੍ਰੋਜੈਕਟ ਪ੍ਰਬੰਧਨ: ਪ੍ਰੋਜੈਕਟ ਦੀ ਮਿਆਦ ਅਤੇ ਅਖੀਰ ਦੀਆਂ ਤਾਰੀਖਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨਾ।
2. ਵਿੱਤੀ ਯੋਜਨਾ: ਬਿਆਜ ਦੇ ਸਮੇਂ ਦੀ ਗਿਣਤੀ ਜਾਂ ਭੁਗਤਾਨ ਦੀਆਂ ਸ਼ਰਤਾਂ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਨਾ।
3. ਯਾਤਰਾ ਦੀ ਯੋਜਨਾ: ਯਾਤਰਾ ਦੀ ਮਿਆਦ ਅਤੇ ਵਾਪਸੀ ਦੀਆਂ ਤਾਰੀਖਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨਾ।
4. ਉਮਰ ਦੀ ਗਿਣਤੀ: ਕਾਨੂੰਨੀ ਜਾਂ ਚਿਕਿਤਸਾ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਦਿਨਾਂ ਵਿੱਚ ਸਹੀ ਉਮਰ ਦਾ ਨਿਰਧਾਰਨ ਕਰਨਾ।
5. ਸਮਾਰੋਹ ਦੀ ਯੋਜਨਾ: ਵਿਸ਼ੇਸ਼ ਸਮੇਂ ਦੇ ਅੰਤਰਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਸਮਾਰੋਹਾਂ ਦੀ ਯੋਜਨਾ ਬਣਾਉਣਾ ਅਤੇ ਸਹਿਯੋਗ ਕਰਨਾ।

ਵਿਕਲਪ

ਜਦੋਂ ਕਿ ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਵਾਲਾ ਕੈਲਕੁਲੇਟਰ ਬਹੁਤ ਸਹਾਇਕ ਹੈ, ਕੁਝ ਸਮੇਂ-ਸੰਬੰਧੀ ਗਿਣਤੀਆਂ ਲਈ ਵਿਕਲਪ ਹਨ:

1. ਵਪਾਰ ਦਿਨਾਂ ਦਾ ਕੈਲਕੁਲੇਟਰ: ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਵੇਲੇ ਹਫ਼ਤੇ ਦੇ ਅੰਤ ਅਤੇ ਛੁੱਟੀਆਂ ਨੂੰ ਬਾਹਰ ਰੱਖਦਾ ਹੈ।
2. ਚੰਦਰ ਕੈਲੰਡਰ: ਕੁਝ ਸੰਸਕ੍ਰਿਤੀਆਂ ਵਿੱਚ ਧਾਰਮਿਕ ਜਾਂ ਸਾਂਸਕ੍ਰਿਤਿਕ ਸਮਾਰੋਹਾਂ ਦੀਆਂ ਤਾਰੀਖਾਂ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
3. ਵਿੱਤੀ ਸਾਲ ਦਾ ਕੈਲਕੁਲੇਟਰ: ਸਾਲ ਦੇ ਕੈਲੰਡਰ ਦੇ ਬਜਾਏ ਇੱਕ ਸੰਸਥਾ ਦੇ ਵਿੱਤੀ ਸਾਲ ਦੇ ਆਧਾਰ 'ਤੇ ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਦਾ ਹੈ।
4. ਖਗੋਲੀਅ ਤਾਰੀਖ ਪ੍ਰਣਾਲੀਆਂ: ਲੰਬੇ ਸਮੇਂ ਦੇ ਦੌਰਾਨ ਸਹੀ ਸਮੇਂ ਦੇ ਮਾਪਾਂ ਲਈ ਵਿਗਿਆਨਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਕੋਡ ਦੇ ਉਦਾਹਰਣ

ਇੱਥੇ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਦੋ ਤਾਰੀਖਾਂ ਦੇ ਵਿਚਕਾਰ ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਅਤੇ ਨਿਰਧਾਰਿਤ ਦਿਨਾਂ ਦੇ ਬਾਅਦ ਇੱਕ ਤਾਰੀਖ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਨ ਦੇ ਉਦਾਹਰਣ ਹਨ:

1' ਦੋ ਤਾਰੀਖਾਂ ਦੇ ਵਿਚਕਾਰ ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਐਕਸਲ ਫਾਰਮੂਲਾ
2=DATEDIF(A1, B1, "D")
3
4' ਨਿਰਧਾਰਿਤ ਦਿਨਾਂ ਦੇ ਬਾਅਦ ਤਾਰੀਖ ਦੀ ਗਿਣਤੀ ਕਰਨ ਲਈ ਐਕਸਲ ਫਾਰਮੂਲਾ
5=A1 + C1
6

1from datetime import datetime, timedelta
2
3def days_between_dates(start_date, end_date):
4    return (end_date - start_date).days
5
6def date_after_period(start_date, days):
7    return start_date + timedelta(days=days)
8
9## ਉਦਾਹਰਨ ਦੀ ਵਰਤੋਂ
10start = datetime(2023, 1, 1)
11end = datetime(2023, 12, 31)
12print(f"ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ: {days_between_dates(start, end)}")
13print(f"100 ਦਿਨਾਂ ਦੇ ਬਾਅਦ ਦੀ ਤਾਰੀਖ: {date_after_period(start, 100)}")
14

1function daysBetweenDates(startDate, endDate) {
2  const oneDay = 24 * 60 * 60 * 1000; // ਘੰਟੇ * ਮਿੰਟ * ਸਕਿੰਟ * ਮਿਲੀਸੈਕਿੰਡ
3  const diffDays = Math.round(Math.abs((startDate - endDate) / oneDay));
4  return diffDays;
5}
6
7function dateAfterPeriod(startDate, days) {
8  const result = new Date(startDate);
9  result.setDate(result.getDate() + days);
10  return result;
11}
12
13// ਉਦਾਹਰਨ ਦੀ ਵਰਤੋਂ
14const start = new Date(2023, 0, 1); // 1 ਜਨਵਰੀ 2023
15const end = new Date(2023, 11, 31); // 31 ਦਸੰਬਰ 2023
16console.log(`ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ: ${daysBetweenDates(start, end)}`);
17console.log(`100 ਦਿਨਾਂ ਦੇ ਬਾਅਦ ਦੀ ਤਾਰੀਖ: ${dateAfterPeriod(start, 100)}`);
18

1import java.time.LocalDate;
2import java.time.temporal.ChronoUnit;
3
4public class DateCalculator {
5    public static long daysBetweenDates(LocalDate startDate, LocalDate endDate) {
6        return ChronoUnit.DAYS.between(startDate, endDate);
7    }
8
9    public static LocalDate dateAfterPeriod(LocalDate startDate, long days) {
10        return startDate.plusDays(days);
11    }
12
13    public static void main(String[] args) {
14        LocalDate start = LocalDate.of(2023, 1, 1);
15        LocalDate end = LocalDate.of(2023, 12, 31);
16        System.out.println("ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ: " + daysBetweenDates(start, end));
17        System.out.println("100 ਦਿਨਾਂ ਦੇ ਬਾਅਦ ਦੀ ਤਾਰੀਖ: " + dateAfterPeriod(start, 100));
18    }
19}
20

ਵਿਜ਼ੁਅਲਾਈਜ਼ੇਸ਼ਨ

ਇੱਥੇ ਇੱਕ SVG ਡਾਇਗ੍ਰਾਮ ਹੈ ਜੋ ਦੋ ਤਾਰੀਖਾਂ ਦੇ ਵਿਚਕਾਰ ਦਿਨਾਂ ਦੀ ਗਿਣਤੀ ਕਰਨ ਦੇ ਸੰਕਲਪ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ:

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

ਨਤੀਜਾ

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