Generate a Random Date Between Two Other Dates

Generate a random date between two other dates

Convert both strings to timestamps (in your chosen resolution, e.g. milliseconds, seconds, hours, days, whatever), subtract the earlier from the later, multiply your random number (assuming it is distributed in the range [0, 1]) with that difference, and add again to the earlier one. Convert the timestamp back to date string and you have a random time in that range.

Python example (output is almost in the format you specified, other than 0 padding - blame the American time format conventions):

import random
import time
    
def str_time_prop(start, end, time_format, prop):
    """Get a time at a proportion of a range of two formatted times.

    start and end should be strings specifying times formatted in the
    given format (strftime-style), giving an interval [start, end].
    prop specifies how a proportion of the interval to be taken after
    start.  The returned time will be in the specified format.
    """

    stime = time.mktime(time.strptime(start, time_format))
    etime = time.mktime(time.strptime(end, time_format))

    ptime = stime + prop * (etime - stime)

    return time.strftime(time_format, time.localtime(ptime))

def random_date(start, end, prop):
    return str_time_prop(start, end, '%m/%d/%Y %I:%M %p', prop)
    
print(random_date("1/1/2008 1:30 PM", "1/1/2009 4:50 AM", random.random()))

Generate random date between two dates and times in Javascript

I think I understand what you are after. This will return a random date between start and end, with a random hour between startHour and endHour (which should be values in the range 0-23).

function randomDate(start, end, startHour, endHour) {
  var date = new Date(+start + Math.random() * (end - start));
  var hour = startHour + Math.random() * (endHour - startHour) | 0;
  date.setHours(hour);
  return date;
}

How to generate random date between two dates using php?

PHP has the rand() function:

$int= rand(1262055681,1262055681);

It also has mt_rand(), which is generally purported to have better randomness in the results:

$int= mt_rand(1262055681,1262055681);

To turn a timestamp into a string, you can use date(), ie:

$string = date("Y-m-d H:i:s",$int);

Elegant method to generate array of random dates within two dates

Maybe I am missing something, but isn't this it?

function randomDate(start, end) {
  return new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
}

const d = randomDate(new Date(2012, 0, 1), new Date());
console.log(d);

Generating random dates within a given range in pandas

We can speed up @akilat90's approach about twofold (in @coldspeed's benchmark) by using the fact that datetime64 is just a rebranded int64 hence we can view-cast:

def pp(start, end, n):
    start_u = start.value//10**9
    end_u = end.value//10**9

    return pd.DatetimeIndex((10**9*np.random.randint(start_u, end_u, n, dtype=np.int64)).view('M8[ns]'))

Sample Image

Generate random dates with random times between two dates for selected period and frequency

It's kind of crappy code but I think it will work as you wish.

function getDiffInSeconds(\DateTime $start, \DateTime $end) : int
{
    $startTimestamp = $start->getTimestamp();
    $endTimestamp = $end->getTimestamp();
    
    return $endTimestamp - $startTimestamp;
}

function getShiftData(\DateTime $start, \DateTime $end) : array
{
    $shiftStartHour = \DateTime::createFromFormat('H:i:s', $start->format('H:i:s'));
    $shiftEndHour = \DateTime::createFromFormat('H:i:s', $end->format('H:i:s'));
    
    $shiftInSeconds = intval($shiftEndHour->getTimestamp() - $shiftStartHour->getTimestamp());
    
    return [
        $shiftStartHour,
        $shiftEndHour,
        $shiftInSeconds,
    ];
}

function dayIsWeekendOrHoliday(\DateTime $date, array $holidays = []) : bool
{
    $weekendDayIndexes = [
        0 => 'Sunday',
        6 => 'Saturday',
    ];
    
    $dayOfWeek = $date->format('w');
    if (empty($holidays)) {
        $dayIsWeekendOrHoliday = isset($weekendDayIndexes[$dayOfWeek]);
    } else {
        $dayMonthDate = $date->format('d/m');
        $dayMonthYearDate = $date->format('d/m/Y');
        $dayIsWeekendOrHoliday = (isset($weekendDayIndexes[$dayOfWeek]) || isset($holidays[$dayMonthDate]) || isset($holidays[$dayMonthYearDate]));
    }
    
    return $dayIsWeekendOrHoliday;
}

function getScheduleDates(\DateTime $start, \DateTime $end, int $frequencyInSeconds) : array
{
    if ($frequencyInSeconds < (24 * 60 * 60)) {
        throw new \InvalidArgumentException('Frequency must be bigger than one day');
    }
    
    $diffInSeconds = getDiffInSeconds($start, $end);
    
    // If difference between $start and $end is bigger than two days
    if ($diffInSeconds > (2 * 24 * 60 * 60)) {
        // If difference is bigger than 2 days we add 1 day to start and subtract 1 day from end
        $start->modify('+1 day');
        $end->modify('-1 day');
        
        // Getting new $diffInSeconds after $start and $end changes
        $diffInSeconds = getDiffInSeconds($start, $end);
    }
    
    if ($frequencyInSeconds > $diffInSeconds) {
        throw new \InvalidArgumentException('Frequency is bigger than difference between dates');
    }
    
    $holidays = [
        '01/01'         => 'New Year',
        '18/04/2020'    => 'Easter 1st official holiday because 19/04/2020',
        '20/04/2020'    => 'Easter',
        '21/04/2020'    => 'Easter 2nd day',
        '27/04'         => 'Konings',
        '04/05'         =>  '4mei',
        '05/05'         =>  '4mei',
        '24/12'         => 'Christmas 1st day',
        '25/12'         => 'Christmas 2nd day',
        '26/12'         => 'Christmas 3nd day',
        '27/12'         => 'Christmas 3rd day',
        '31/12'         => 'Old Year'
    ];
    
    [$shiftStartHour, $shiftEndHour, $shiftInSeconds] = getShiftData($start, $end);
    $amountOfNotifications = floor($diffInSeconds / $frequencyInSeconds);
    $periodInSeconds = intval($diffInSeconds / $amountOfNotifications);
    $maxDaysBetweenNotifications = intval($periodInSeconds / (24 * 60 * 60));
    // If $maxDaysBetweenNotifications is equals to 1 then we have to change $periodInSeconds to amount of seconds for one day
    if ($maxDaysBetweenNotifications === 1) {
        $periodInSeconds = (24 * 60 * 60);
    }
    
    $dates = [];
    for ($i = 0; $i < $amountOfNotifications; $i++) {
        $periodStart = clone $start;
        $periodStart->setTimestamp($start->getTimestamp() + ($i * $periodInSeconds));
        $seconds = mt_rand(0, $shiftInSeconds);
        
        // If $maxDaysBetweenNotifications is equals to 1 then we have to check only one day without loop through the dates
        if ($maxDaysBetweenNotifications === 1) {
            $interval = new \DateInterval('P' . $maxDaysBetweenNotifications . 'DT' . $seconds . 'S');
            $date = clone $periodStart;
            $date->add($interval);
            
            $dayIsWeekendOrHoliday = dayIsWeekendOrHoliday($date, $holidays);
        } else {
            // When $maxDaysBetweenNotifications we have to loop through the dates to pick them
            $loopsCount = 0;
            $maxLoops = 3; // Max loops before breaking and skipping the period
            do {
                $day = mt_rand(0, $maxDaysBetweenNotifications);
                $periodStart->modify($shiftStartHour);
                $interval = new \DateInterval('P' . $day . 'DT' . $seconds . 'S');
                $date = clone $periodStart;
                $date->add($interval);
                
                $dayIsWeekendOrHoliday = dayIsWeekendOrHoliday($date, $holidays);
                
                // If the day is weekend or holiday then we have to increment $loopsCount by 1 for each loop
                if ($dayIsWeekendOrHoliday === true) {
                    $loopsCount++;
                    
                    // If $loopsCount is equals to $maxLoops then we have to break the loop
                    if ($loopsCount === $maxLoops) {
                        break;
                    }
                }
            } while ($dayIsWeekendOrHoliday);
        }
        
        // Adds the date to $dates only if the day is not a weekend day and holiday
        if ($dayIsWeekendOrHoliday === false) {
            $dates[] = $date;
        }
    }
    
    return $dates;
}

$start = new \DateTime('2020-12-30 08:00:00', new \DateTimeZone('Europe/Sofia'));
$end = new \DateTime('2021-01-18 17:00:00', new \DateTimeZone('Europe/Sofia'));
$frequencyInSeconds = 86400; // 1 day

$dates = getScheduleDates($start, $end, $frequencyInSeconds);
var_dump($dates);

You have to pass $start, $end and $frequencyInSeconds as I showed in example and then you will get your random dates. Notice that I $start and $end must have hours in them because they are used as start and end hours for shifts. Because the rule is to return a date within a shift time only in working days. Also you have to provide frequency in seconds - you can calculate them outside the function or you can change it to calculate them inside. I did it this way because I don't know what are your predefined periods.

This function returns an array of \DateTime() instances so you can do whatever you want with them.

UPDATE 08/01/2020:
Holidays now are part of calculation and they will be excluded from returned dates if they are passed when you are calling the function. You can pass them in d/m and d/m/Y formats because of holidays like Easter and in case when the holiday is on weekend but people will get additional dayoff during the working week.

UPDATE 13/01/2020:
I've made updated code version to fix the issue with infinite loops when $frequencyInSeconds is shorter like 1 day. The new code used few functions getDiffInSeconds, getShiftData and dayIsWeekendOrHoliday as helper methods to reduce code duplication and cleaner and more readable code

Getting random date between two dates

Use rand():

 $random = Carbon::now()->subMinutes(rand(1, 55));

Python generating a list of dates between two dates

You can use pandas.date_range() for this:

import pandas
pandas.date_range(sdate,edate-timedelta(days=1),freq='d')

DatetimeIndex(['2019-03-22', '2019-03-23', '2019-03-24', '2019-03-25',
           '2019-03-26', '2019-03-27', '2019-03-28', '2019-03-29',
           '2019-03-30', '2019-03-31', '2019-04-01', '2019-04-02',
           '2019-04-03', '2019-04-04', '2019-04-05', '2019-04-06',
           '2019-04-07', '2019-04-08'],
          dtype='datetime64[ns]', freq='D')

Select a random date between two other dates SQL

You can order any result set randomly by using the RAND() function:

SELECT *
FROM `table`
WHERE date BETWEEN "2020-01-01" AND "2020-06-01" 
ORDER BY RAND()
LIMIT 4

Generate random date greater than current date using JAVA

The following solution will generate a random date from tomorrow and a year forward

Random randomDays = ThreadLocalRandom.current();
LocalDateTime date = LocalDateTime.now().plusDays(randomDays.nextInt(365) + 1);

Depending on the range of the date you want you can of course change the bound parameter to nextInt.

Generate a Random Date Between Two Other Dates