252. Meeting rooms

#include <stdbool.h>
#include <stdlib.h>

/**
 * Definition of Interval:
 * typedef struct {
 *     int start, end;
 * } Interval;
 */

static int cmpStart(const void *a, const void *b) {
  const Interval *x = a, *y = b;
  return (x->start > y->start) - (x->start < y->start);
}

bool canAttendMeetings(Interval *intervals, int intervalsSize) {
  qsort(intervals, intervalsSize, sizeof(Interval), cmpStart);
  for (int i = 0; i < intervalsSize - 1; i++) {
    if (intervals[i].end > intervals[i + 1].start)
      return false;
  }
  return true;
}

#include <algorithm>
#include <vector>

using namespace std;

/**
 * Definition of Interval:
 * class Interval {
 * public:
 *     int start, end;
 *     Interval(int start, int end) {
 *         this->start = start;
 *         this->end = end;
 *     }
 * }
 */

class Solution {
public:
  bool canAttendMeetings(vector<Interval> &intervals) {
    sort(
        intervals.begin(), intervals.end(),
        [](const Interval &a, const Interval &b) { return a.start < b.start; });
    for (int i = 0; i < (int)intervals.size() - 1; i++) {
      if (intervals[i].end > intervals[i + 1].start)
        return false;
    }
    return true;
  }
};

package intervals

import "slices"

// Definition of Interval:
// type Interval struct {
//     start int
//     end   int
// }

func canAttendMeetings(intervals []Interval) bool {
    slices.SortFunc(intervals, func(a, b Interval) int { return a.start - b.start })
    for i := 0; i < len(intervals)-1; i++ {
        if intervals[i].end > intervals[i+1].start {
            return false
        }
    }
    return true
}

import java.util.Collections;
import java.util.List;

/**
 * Definition of Interval:
 * public class Interval {
 *     public int start, end;
 *     public Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 * }
 */

class Solution {
    public boolean canAttendMeetings(List<Interval> intervals) {
        Collections.sort(intervals, (a, b) -> Integer.compare(a.start, b.start));
        for (int i = 0; i < intervals.size() - 1; i++) {
            if (intervals.get(i).end > intervals.get(i + 1).start)
                return false;
        }
        return true;
    }
}

/**
 * Definition of Interval:
 * class Interval {
 *   constructor(start, end) {
 *     this.start = start;
 *     this.end = end;
 *   }
 * }
 */

/**
 * @param {Interval[]} intervals
 * @returns {boolean}
 */
var canAttendMeetings = function (intervals) {
  intervals.sort((a, b) => a.start - b.start);
  for (let i = 0; i < intervals.length - 1; i++) {
    if (intervals[i].end > intervals[i + 1].start) return false;
  }
  return true;
};

from typing import List

"""
Definition of Interval:
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""


class Solution:
    def canAttendMeetings(self, intervals: List[Interval]) -> bool:
        intervals.sort(key=lambda i: i.start)
        for i in range(len(intervals) - 1):
            if intervals[i].end > intervals[i + 1].start:
                return False
        return True

// Definition of Interval:
// pub struct Interval {
//     pub start: i32,
//     pub end: i32,
// }

impl Solution {
    pub fn can_attend_meetings(mut intervals: Vec<Interval>) -> bool {
        intervals.sort_by_key(|i| i.start);
        intervals.windows(2).all(|w| w[0].end <= w[1].start)
    }
}