Finding an Appointment (JS)

find-appointment.js

// The businesspeople among you will know that it's often not easy to find an 
// appointment. In this kata we want to find such an appointment automatically. 
// You will be given the calendars of our businessperson and a duration for the 
// meeting. Your task is to find the earliest time, when every businessperson is 
// free for at least that duration.
// 
// Example Schedule:
// 
// Person | Meetings
// -------+-----------------------------------------------------------
//      A | 09:00 - 11:30, 13:30 - 16:00, 16:00 - 17:30, 17:45 - 19:00
//      B | 09:15 - 12:00, 14:00 - 16:30, 17:00 - 17:30
//      C | 11:30 - 12:15, 15:00 - 16:30, 17:45 - 19:00
// Rules:
// 
// All times in the calendars will be given in 24h format "hh:mm", the result 
// must also be in that format
// 
// A meeting is represented by its start time (inclusively) and end time 
// (exclusively) -> if a meeting takes place from 09:00 - 11:00, the next 
// possible start time would be 11:00
// 
// The businesspeople work from 09:00 (inclusively) - 19:00 (exclusively), the 
// appointment must start and end within that range.
// 
// If the meeting does not fit into the schedules, return null or None as result
// The duration of the meeting will be provided as an integer in minutes
// Following these rules and looking at the example above the earliest time for 
// a 60 minutes meeting would be 12:15.
// 
// Data Format:
// 
// The schedule will be provided as 3-dimensional array, in this format:
// 
// var schedules = [
// [['09:00', '11:30'], ['13:30', '16:00'], ['16:00', '17:30'], ['17:45', '19:00]],
// [['09:15', '12:00'], ['14:00', '16:30'], ['17:00', '17:30']],
// [['11:30', '12:15'], ['15:00', '16:30'], ['17:45', '19:00']]
// ];


// -----------------------------------------------------------------------------
// SOLUTION
// -----------------------------------------------------------------------------

function getStartTime(schedules, duration) {
  var overlapRanges = getOverlaps(schedules);
  var available = overlapRanges.find(range => rangeToMinutes(range) >= duration);
  
  return available && available[0] || null;
}

/**
 * Given a time range in format ['09:15', '10:30'],
 * return the length of the range in minutes.
 * @param {Array<Number>} range
 * @return {Number} The minutes in the range
 */
function rangeToMinutes(range) {
  var minutes = 0;
  var start = range[0];
  var end = range[1];
  var startParts = start.split(':');
  var endParts = end.split(':');
  var startHour = +startParts[0];
  var endHour = +endParts[0];
  var startMins = +startParts[1];
  var endMins = +endParts[1];
  
  if (startHour !== endHour) {
    var hrMins = (endHour - startHour) * 60;
    minutes += hrMins;
  }

  if (startMins !== endMins) {
    minutes += (endMins - startMins)
  }

  return minutes;
}

/**
 * Given a set of schedules of busy time ranges, return
 * the time range of availabilities common to all schedules.
 * @param {Array<Array>} schedules
 * @return {Array<Array>} Time ranges which are available.
 */
function getOverlaps(schedules) {
  var res = [];
  
  return schedules.reduce((openSlots, schedule) => {
    var open = getOpenSlots(schedule);

    return intersectSchedules(openSlots, open);
  }, [['09:00', '19:00']]);
  
  return res;
}

/**
 * Given 2 sets of available times, return the times available in both schedules.
 * @param {Array<Array>} schedule1
 * @param {Array<Array>} schedule2
 * @return {Array<Array>}
 */
function intersectSchedules(schedule1, schedule2) {
  var res = [];

  schedule1.forEach(r1 => {
    schedule2.forEach(r2 => {
      var intersection = findIntersection(r1, r2);

      if (intersection) {
        res.push(intersection);
      }
    });
  });

  return res;
}

/**
 * Given 2 ranges, find the interesction.
 * @param {Array} a - 1st range e.g. ['11:30', '13:30']
 * @param {Array} b - 2nd range e.g. ['12:00', '14:00']
 * @return {Array} Interection range, or null if none.
 */
function findIntersection(a, b) {
  var min = (a[0] < b[0]) ? a : b;
  var max = (min === a) ? b : a;

  if (min[1] < max[0]) return null;

  return [max[0], (min[1] < max[1]) ? min[1] : max[1]];
}

/**
 * Given a schedule of meetings, find the oen slots.
 * @param {Array<Array>} schedule - busy times, e.g. [['09:00', '11:30'], ['13:30', '16:00']];
 * @return {Array<Array>} available times, e.g. [['11:30', '13:30'], ['16:00', '19:00']] in above case.
 */
function getOpenSlots(schedule) {
  var res = [];
  var head = schedule[0] && schedule[0][0];
  var tail = schedule[schedule.length - 1] &&schedule[schedule.length - 1][1];
  
  if (schedule.length <= 1) {
    return schedule;
  }
  
  // first slot
  if (head !== '09:00') {
    res.push(['09:00', head]);
  }
  
  schedule.forEach((curr, i) => {
    var prev = schedule[i - 1];
    var isTimeBetween = prev && prev[1] !== curr[0];

    if (i > 0 && isTimeBetween) {
     res.push([prev[1], curr[0]]);
    }
  });
  
  // last slot
  if (tail !== '19:00') {
    res.push([tail, '19:00']);
  }
  
  return res;
}

Functional version

/**
 * @author Vladimir Sukhov
 * @description Script to find windows between two calendars for the meeting
 * @license GPLv.2
 */

// format: "[h]h-mm:[h]h-mm"
// Set initial data here
const bounds = ["8:00", "18:30"];
const cOne  = ["9:00-9:30", "10:05-12:00", "14:15-14:55", "16:00-17:30"];
const cTwo = ["9:15-9:35", "10:30-11:30", "11:55-13:00", "15:00-17:00"];
const window = /*0-n*/30;

const _pos = {start: 0, end: 1};
const _time2Int /* ["9:00-9:35"] => [540,575] */ = (interval) => interval.split("-").map(e=>e.split(":").reduce((t,v, i) => i === 0 ? +t+ +v*60 : +t + +v ,0));
const _int2Time /* [540,575] => ["9:00-9:35"] */ = (value) => `${Math.floor(value/60)}:${(value - Math.floor(value/60)*60) < 10 ? "0"+(value - Math.floor(value/60)*60) : (value - Math.floor(value/60)*60) }`;
const _flatLst = (list) => list.reduce((t,v) => t.concat(v));

const __a_srtList = (list) => list.sort((a,b) => (a[0] < b[0] ? - 1 : (a[0] > b[0] ? 1 : 0)));
const __a_adjust = (list, startIdx = 0) => {
    let p = list;
    return startIdx + 1 === list.length ? p : (()=>{
        let mut = _mutPair(p, startIdx); 
        p = mut[0];
        return mut[1] ?__a_adjust(p,startIdx) : __a_adjust(p,startIdx + 1);
    })();
}

const _wWrap = (l, r) =>{
    let res = [];
    let x = Math.floor((((l - r) / window)));
    if(x <= 0) {
        return "trash"; // :)
    }else {
        for(let i = 0; i <= x; i++) {
            res.push(_int2Time(+r + (i * window)))
        }
    }
    return res.map((_,i,a) => i + 1 < res.length ? `${a[i]}-${a[i+1]}` : null).filter((v) => v && v.length !== 0);
}

const _mutPair = (array, aDx = 0) =>{
    let t;
    let bDx = aDx + 1;
    let tempArr = array;
    let hadChange = false;
    if(array[aDx][_pos.end] > array[bDx][_pos.start]){
        hadChange = !hadChange;
        t = [
            Math.min(array[aDx][_pos.start], array[bDx][_pos.start]),
            Math.max(array[aDx][_pos.end], array[bDx][_pos.end])
        ]
        if(aDx<bDx){ // consistent sorting
            tempArr[aDx] = t; tempArr[bDx] = [];
        }else {
            tempArr[bDx] = t; tempArr[aDx] = [];
        }
    }    
    return [tempArr.filter(a => a.length !== 0), hadChange];
}

const _fndWin = (list) => {
    const maxLen = list.length;
    let result = [];
    result.push(_wWrap((list[_pos.start])[_pos.start], _time2Int(bounds[_pos.start]))); // day start -> first meeting
    result = result.concat(list.map((_, idx, arr) => idx + 1 < maxLen ? 
                                                        _wWrap(arr[idx + 1][_pos.start],arr[idx][_pos.end]) : 
                                                        _wWrap(_time2Int(bounds[_pos.end]),(arr[idx])[_pos.end])));
    return result.filter(e => e.length > 0 && e != "trash"); // cleanup
}

(async(c)=> await __a_srtList(c))([].concat(cOne.map(e=>_time2Int(e))).concat(cTwo.map(e=>_time2Int(e))))
    .then(async s => await __a_adjust(s))
    .then(async a => _fndWin(a))
    .then(async w => _flatLst(w))
    .then(async l => console.log(l));

// var schedules = [
// [['09:00', '11:30'], ['13:30', '16:00'], ['16:00', '17:30'], ['17:45', '19:00]],
// [['09:15', '12:00'], ['14:00', '16:30'], ['17:00', '17:30']],
// [['11:30', '12:15'], ['15:00', '16:30'], ['17:45', '19:00']]
// ];

Missing close quote at end of 1st line of times:
'19:00]],