# Leetcode Non-overlapping intervals problem solution

In this Leetcode Non-overlapping intervals problem solution we have Given an array of intervals intervals where intervals[i] = [starti, endi], return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.

## Problem solution in Python.

```class Solution:
def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
intervals.sort(key=lambda x:x[0])
n=len(intervals)
i=0
j=1
count=0
while j<n:
if intervals[i][1]<=intervals[j][0]: #Non overlapping
i=j
j+=1
elif intervals[i][1]<=intervals[j][1]: #partial overlapping
j+=1
count+=1
elif intervals[i][1]>=intervals[j][1]: #full overalapping
i=j
count+=1
j+=1
return count
```

## Problem solution in Java.

```class Solution {
public int eraseOverlapIntervals(int[][] intervals) {
Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
Arrays.sort(intervals, (a, b) -> Integer.compare(a[1], b[1]));

for (int i = 0; i < intervals.length; i++) {
}
}
}
}
```

## Problem solution in C++.

```class Solution {
public:
int eraseOverlapIntervals(vector<Interval>& intervals) {
std::sort(intervals.begin(), intervals.end(),
[](const Interval& lhs, const Interval& rhs) {
if (lhs.end != rhs.end) {
return lhs.end < rhs.end;
} else {
return lhs.start > rhs.start;
}
});

int n = intervals.size(), lastIdx = 0;
int result = 0;
for (int i = 1; i < n; i++) {
if (intervals[i].start < intervals[lastIdx].end) {
result++;
} else {
lastIdx = i;
}
}
return result;
}
};
```

## Problem solution in C.

```int eraseOverlapIntervals(struct Interval* intervals, int intervalsSize) {
int cmp(const void*a,const void*b)
{
return (*(struct Interval *)a).end -(*(struct Interval *)b).end ;
}
qsort(intervals, intervalsSize, sizeof(intervals[0]), cmp);
int i = 0;
int j = i + 1;
int num = 0;
while(i < intervalsSize - 1 && j < intervalsSize){
if(intervals[j].start<intervals[i].end){
num++;
}else{
i = j;
}
j++;
}
return num;
}
```