How can one determine the number of months worked within a specific date range?

Question

How can one determine the number of months worked within a specific date range?

I am currently faced with the challenge of determining the number of effective working months within given date ranges. This involves calculating the ratio of working days to total days in each month, excluding weekends.

effective working month = Number of working days work per month / total working days of that month

working days are defined as days without weekends.

The current algorithm being used is:

Total working months = number of working months in first month + number of working months in last month + number of months in between

This approach has helped simplify calculations without the need for loops. However, the code is lengthy and contains multiple functions. Unfortunately, I cannot share the code due to data sensitivity. I would appreciate any insights into a more efficient algorithm to optimize performance.

//Unit test with start date = 2020-05-20, end date = 2021-08-11, expected result of 14.74458875

Number of months in first month = workingDays(2020-05-20,2020-05-31) / workingdays(2020-05-01,2020-05-31)
                             = 0.380952381 
Number of months in last month = workingDays(2021-08-01,2021-08-11) / workingdays(2021-08-01,2021-08-31) 
                              = 0.363636364
Months in between = 14
Total months = 0.380952381 + 14 + 0.363636364
            = 14.74458875

javascript typescript algorithm date

Answer 1

Answer №1

Here is a suggested function that handles both dates equally within a loop iteration. To simplify the counting process, a pattern string is utilized with "x" representing working days. By extracting the relevant substring from the pattern and removing non-"x" characters (weekend days), the resulting length indicates the number of working days. The calculation then involves summing up various elements:

function calculateWorkingDays(startDate, endDate) {
    let monthCounter = -1;
    for (let i = 0; i < 2; i++) {
        let date = i ? endDate : startDate;
        let year = +date.slice(0, 4);
        let month = date.slice(5, 7) - 1;
        let day = +date.slice(8);
        let weekday = new Date(year, month, 1).getDay();
        let pattern = ":xxxxx::xxxxx::xxxxx::xxxxx::xxxxx::x"
                .slice(weekday, weekday + new Date(year, month + 1, 0).getDate());
        monthCounter += (year * 12 + month) * (i ? 1 : -1) 
           + pattern.slice(i ? 0 : day - 1, i ? day : 31).replace(/:/g, "").length
             / pattern.replace(/:/g, "").length;
    }
    return monthCounter;
}

// Example using the given dates
console.log(calculateWorkingDays("2020-05-20", "2021-08-11")); // 14.7445887445...

Answer 2

Here is a suggested function that handles both dates equally within a loop iteration. To simplify the counting process, a pattern string is utilized with "x" representing working days. By extracting the relevant substring from the pattern and removing non-"x" characters (weekend days), the resulting length indicates the number of working days. The calculation then involves summing up various elements:

function calculateWorkingDays(startDate, endDate) {
    let monthCounter = -1;
    for (let i = 0; i < 2; i++) {
        let date = i ? endDate : startDate;
        let year = +date.slice(0, 4);
        let month = date.slice(5, 7) - 1;
        let day = +date.slice(8);
        let weekday = new Date(year, month, 1).getDay();
        let pattern = ":xxxxx::xxxxx::xxxxx::xxxxx::xxxxx::x"
                .slice(weekday, weekday + new Date(year, month + 1, 0).getDate());
        monthCounter += (year * 12 + month) * (i ? 1 : -1) 
           + pattern.slice(i ? 0 : day - 1, i ? day : 31).replace(/:/g, "").length
             / pattern.replace(/:/g, "").length;
    }
    return monthCounter;
}

// Example using the given dates
console.log(calculateWorkingDays("2020-05-20", "2021-08-11")); // 14.7445887445...

Answer 3

Answer №2

Feast your eyes on an implementation that mirrors the algorithm you mentioned. Whether it enhances code readability or performance remains a mystery:

// Handy utility functions

const range = (lo, hi) =>
  [... Array (hi - lo + 1)] .map ((_, i) => lo + i)

const parseDate = (s, [y, m, d] = s.split('-') .map (Number)) =>
  [y, m -1 , d]  // JS Dates start month at index 0

const isLeapYear = (y) =>
  (y % 4 == 0) && (y % 100 != 0 || y % 400 == 0)

const daysInMonth = (y, m) =>
  isLeapYear (y)
    ? [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] [m]
    : [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] [m]

// Auxiliary functions

const fullMonthsBetween = (y1, m1, y2, m2) => // excludes both endpoints
  Math.max((12 * y2 + m2) - (12 * y1 + m1) - 1, 0)

const workingDaysInRemainderOfMonth = (y, m, d, day = new Date (y, m, d) .getDay ()) =>
  range (d, daysInMonth (y, m))
    .filter ((_, i) => [1, 2, 3, 4, 5] .includes((day + i) % 7))
    .length

const workingDaysInStartOfMonth = (y, m, d) =>
  range (1, d)
    .filter ((_, i) => [1, 2, 3, 4, 5] .includes ((d + i) % 7))
    .length

// Main function

const workingMonthsBetween = (start, end) => {
  const [y1, m1, d1] = parseDate (start)
  const [y2, m2, d2] = parseDate (end)
  return fullMonthsBetween (y1, m1, y2, m2)
         + workingDaysInRemainderOfMonth (y1, m1, d1)
            / workingDaysInRemainderOfMonth(y1, m1, 1)
         + workingDaysInStartOfMonth (y2, m2, d2)
            / workingDaysInRemainderOfMonth(y2, m2, 1)
}

// Demo
console .log (
  workingMonthsBetween ('2020-05-20', '2021-08-12')  //~> 14.744588744588745
)

This solution consists of several small, modular functions. While consolidating them could boost efficiency, I find the clarity and maintainability of distinct helper functions preferable to a monolithic approach.

range generates a range of integers.

range (3, 12) //=> [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

parseDate converts a date string like '2020-08-12' into year/month/day values [2010, 7, 12]. Adjusting for JavaScript's zero-indexed months accounts for the subtraction by one.
isLeapYear serves its self-explanatory purpose while considering leap year intricacies.
daysInMonth calculates the total days in a month, accounting for leap years.
fullMonthsBetween provides the count of whole months between two year/month pairs, excluding the start and end points.
workingDaysInRemainderOfMonth tallies the remaining workdays in a given month from a specific point onward by filtering out weekends using essential arithmetic.
workingDaysInStartOfMonth similarly computes workdays starting from the beginning of a month up to a specified date.
workingMonthsBetween represents the central functionality, determining the months span between two ISO-8601 date strings based on the underlying auxiliary functions.

Holiday considerations are currently omitted. Incorporating them would elevate complexity beyond mere triviality.

Additional Note

A brief exploration was undertaken regarding Zeller's Congruence, which reveals superior speed compared to utilizing the Date constructor isolatedly. Referencing performance benchmarks supports this observation:

// General-purpose utility functions
const range = (lo, hi) => 
  [... Array (hi - lo + 1)] .map ((_, i) => lo + i)

// Rest of code block retains similar structure as previous snippet for brevity
...

Answer 4

Feast your eyes on an implementation that mirrors the algorithm you mentioned. Whether it enhances code readability or performance remains a mystery:

// Handy utility functions

const range = (lo, hi) =>
  [... Array (hi - lo + 1)] .map ((_, i) => lo + i)

const parseDate = (s, [y, m, d] = s.split('-') .map (Number)) =>
  [y, m -1 , d]  // JS Dates start month at index 0

const isLeapYear = (y) =>
  (y % 4 == 0) && (y % 100 != 0 || y % 400 == 0)

const daysInMonth = (y, m) =>
  isLeapYear (y)
    ? [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] [m]
    : [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] [m]

// Auxiliary functions

const fullMonthsBetween = (y1, m1, y2, m2) => // excludes both endpoints
  Math.max((12 * y2 + m2) - (12 * y1 + m1) - 1, 0)

const workingDaysInRemainderOfMonth = (y, m, d, day = new Date (y, m, d) .getDay ()) =>
  range (d, daysInMonth (y, m))
    .filter ((_, i) => [1, 2, 3, 4, 5] .includes((day + i) % 7))
    .length

const workingDaysInStartOfMonth = (y, m, d) =>
  range (1, d)
    .filter ((_, i) => [1, 2, 3, 4, 5] .includes ((d + i) % 7))
    .length

// Main function

const workingMonthsBetween = (start, end) => {
  const [y1, m1, d1] = parseDate (start)
  const [y2, m2, d2] = parseDate (end)
  return fullMonthsBetween (y1, m1, y2, m2)
         + workingDaysInRemainderOfMonth (y1, m1, d1)
            / workingDaysInRemainderOfMonth(y1, m1, 1)
         + workingDaysInStartOfMonth (y2, m2, d2)
            / workingDaysInRemainderOfMonth(y2, m2, 1)
}

// Demo
console .log (
  workingMonthsBetween ('2020-05-20', '2021-08-12')  //~> 14.744588744588745
)

This solution consists of several small, modular functions. While consolidating them could boost efficiency, I find the clarity and maintainability of distinct helper functions preferable to a monolithic approach.

range generates a range of integers.

range (3, 12) //=> [3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

parseDate converts a date string like '2020-08-12' into year/month/day values [2010, 7, 12]. Adjusting for JavaScript's zero-indexed months accounts for the subtraction by one.
isLeapYear serves its self-explanatory purpose while considering leap year intricacies.
daysInMonth calculates the total days in a month, accounting for leap years.
fullMonthsBetween provides the count of whole months between two year/month pairs, excluding the start and end points.
workingDaysInRemainderOfMonth tallies the remaining workdays in a given month from a specific point onward by filtering out weekends using essential arithmetic.
workingDaysInStartOfMonth similarly computes workdays starting from the beginning of a month up to a specified date.
workingMonthsBetween represents the central functionality, determining the months span between two ISO-8601 date strings based on the underlying auxiliary functions.

Holiday considerations are currently omitted. Incorporating them would elevate complexity beyond mere triviality.

Additional Note

A brief exploration was undertaken regarding Zeller's Congruence, which reveals superior speed compared to utilizing the Date constructor isolatedly. Referencing performance benchmarks supports this observation:

// General-purpose utility functions
const range = (lo, hi) => 
  [... Array (hi - lo + 1)] .map ((_, i) => lo + i)

// Rest of code block retains similar structure as previous snippet for brevity
...

How can one determine the number of months worked within a specific date range?

Answer №1

Answer №2

Additional Note

Similar questions

Is it possible to invoke fancybox using a class selector?

Automatically shutting windows using jQuery after a certain number of seconds

The JSON file is not filling the options in the dropdown menu

Tips for avoiding recursive error function calls in Angular 5

Activate the next tab by clicking a button in ReactJS

Animating avatars with Three.js

I am requesting for the average to be adjusted based on the user's choice between Hindi or English percentage scale

How to effectively utilize higher order map in RxJS?

Tips for successfully transferring property values while utilizing Ajax in Struts 2

How can I use JQuery to iterate through Object data and dynamically create tr and td elements?

Utilize Element-UI to effectively close dropdown menus

Creating an index signature in TypeScript without having to use union types for the values - a comprehensive guide

Strategies for choosing the perfect GIF to showcase in a React JS project

What is the method for extending props from React.HTMLProps<HTMLButtonElement>?

The issue of ERR_MODULE_NOT_FOUND in Node.js express.Router arises when attempting to import new routes

Styling a table based on specific conditions using Angular and JavaScript

Retrieve the shortened version of the month from a non-English date

Utilize Regular Expression Constant Validator in Angular 8's Reactive Formbuilder for efficient data validation requirements

What is the recommended approach for testing a different branch of a return guard using jest?

Interruption of client-side JavaScript by the ASP timer tick event