Skip to content

Commit da69a17

Browse files
ayoubzulfiqarayoubzulfiqar
committed
leetcode
1 parent c03ef54 commit da69a17

File tree

4 files changed

+223
-0
lines changed

4 files changed

+223
-0
lines changed

‎InsertInterval/insert_interval.dart

+130
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,130 @@
1+
/*
2+
3+
4+
-* 57. Insert Interval *-
5+
6+
You are given an array of non-overlapping intervals intervals where intervals[i] = [start-i, end-i] represent the start and the end of the ith interval and intervals is sorted in ascending order by start-i. You are also given an interval newInterval = [start, end] that represents the start and end of another interval.
7+
8+
Insert newInterval into intervals such that intervals is still sorted in ascending order by start-i and intervals still does not have any overlapping intervals (merge overlapping intervals if necessary).
9+
10+
Return intervals after the insertion.
11+
12+
13+
14+
Example 1:
15+
16+
Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
17+
Output: [[1,5],[6,9]]
18+
Example 2:
19+
20+
Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
21+
Output: [[1,2],[3,10],[12,16]]
22+
Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].
23+
24+
25+
Constraints:
26+
27+
0 <= intervals.length <= 104
28+
intervals[i].length == 2
29+
0 <= start-i <= end-i <= 105
30+
intervals is sorted by start-i in ascending order.
31+
newInterval.length == 2
32+
0 <= start <= end <= 105
33+
34+
*/
35+
36+
import 'dart:math';
37+
38+
class A {
39+
bool doesIntersect(List<int> intervalA, List<int> intervalB) {
40+
return intervalA[0] <= intervalB[1] && intervalB[0] <= intervalA[1];
41+
}
42+
43+
List<List<int>> insert(List<List<int>> intervals, List<int> newInterval) {
44+
List<List<int>> mergedIntervals = [];
45+
List<int> merged = [newInterval[0], newInterval[1]];
46+
bool isInserted = false;
47+
48+
for (List<int> interval in intervals) {
49+
if (interval[0] > merged[1]) {
50+
if (!isInserted) {
51+
mergedIntervals.add(merged);
52+
isInserted = true;
53+
}
54+
mergedIntervals.add(interval);
55+
} else {
56+
// does intersect
57+
if (doesIntersect(merged, interval)) {
58+
merged[0] = min(merged[0], interval[0]);
59+
merged[1] = max(merged[1], interval[1]);
60+
} else {
61+
// not intersecting
62+
mergedIntervals.add(interval);
63+
}
64+
}
65+
}
66+
67+
// new interval is at the end
68+
if (!isInserted) {
69+
mergedIntervals.add(merged);
70+
isInserted = true;
71+
}
72+
73+
// Java specific to copy to arr[][]...
74+
List.filled(mergedIntervals.length, 0).map((e) => List.filled(2, 0));
75+
List<List<int>> res = List.filled(mergedIntervals.length, 0)
76+
.map((e) => List.filled(2, 0))
77+
.toList();
78+
for (int i = 0; i < mergedIntervals.length; i++) {
79+
res[i] = mergedIntervals.elementAt(i);
80+
}
81+
return res;
82+
}
83+
}
84+
85+
class B {
86+
List<List<int>> insert(List<List<int>> intervals, List<int> newInterval) {
87+
List<List<int>> ans = [];
88+
List<int> toAdd = newInterval;
89+
for (int i = 0; i < intervals.length; i++) {
90+
if (intervals[i][0] > toAdd[1]) {
91+
ans.add(toAdd);
92+
toAdd = intervals[i];
93+
} else if (intervals[i][1] >= toAdd[0])
94+
toAdd = [
95+
min(intervals[i][0], toAdd[0]),
96+
max(intervals[i][1], toAdd[1])
97+
];
98+
else
99+
ans.add(intervals[i]);
100+
}
101+
ans.add(toAdd);
102+
return List.filled(ans.length, 0).map((e) => List.filled(2, 0)).toList();
103+
}
104+
// List.filled(res.length, 0).map((e) => List.filled(2, 0)).toList();
105+
}
106+
107+
class C {
108+
List<List<int>> insert(List<List<int>> intervals, List<int> newInterval) {
109+
List<List<int>> ans = [];
110+
int idx = 0;
111+
while (idx < intervals.length && intervals[idx][0] < newInterval[0]) {
112+
ans.add(intervals[idx++]);
113+
}
114+
if (ans.length == 0 || newInterval[0] > ans.elementAt(ans.length - 1)[1]) {
115+
ans.add(newInterval);
116+
} else {
117+
List<int> lastInterval = ans.elementAt(ans.length - 1);
118+
lastInterval[1] = max(lastInterval[1], newInterval[1]);
119+
}
120+
while (idx < intervals.length) {
121+
List<int> lastInterval = ans.elementAt(ans.length - 1);
122+
if (lastInterval[1] >= intervals[idx][0]) {
123+
lastInterval[1] = max(lastInterval[1], intervals[idx++][1]);
124+
} else
125+
ans.add(intervals[idx++]);
126+
}
127+
return List.filled(ans.length, 0).map((e) => <int>[]).toList();
128+
// return ans.toArray(new int[ans.size()][]);
129+
}
130+
}

‎InsertInterval/insert_interval.go

+40
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
package main
2+
3+
import "sort"
4+
5+
func min(a, b int) int {
6+
if a <= b {
7+
return a
8+
}
9+
return b
10+
}
11+
12+
func max(a, b int) int {
13+
if a >= b {
14+
return a
15+
}
16+
return b
17+
}
18+
19+
func insert(intervals [][]int, newInterval []int) [][]int {
20+
idx := sort.Search(len(intervals), func(i int) bool {
21+
return intervals[i][1] >= newInterval[0]
22+
})
23+
idx2 := sort.Search(len(intervals), func(i int) bool {
24+
return intervals[i][0] > newInterval[1]
25+
})
26+
if idx == idx2 && (idx == len(intervals) || newInterval[1] < intervals[idx][0]) {
27+
result := make([][]int, len(intervals)+1)
28+
copy(result, intervals[:idx])
29+
result[idx] = newInterval
30+
copy(result[idx+1:], intervals[idx:])
31+
return result
32+
}
33+
intervals[idx][0] = min(intervals[idx][0], newInterval[0])
34+
intervals[idx][1] = max(intervals[idx2-1][1], newInterval[1])
35+
if diff := idx2 - idx; diff > 1 {
36+
copy(intervals[idx+1:], intervals[idx2:])
37+
intervals = intervals[:len(intervals)-(diff-1)]
38+
}
39+
return intervals
40+
}

‎InsertInterval/insert_interval.md

+52
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
# A
2+
3+
## Solution
4+
5+
```dart
6+
class Solution {
7+
bool doesIntersect(List<int> intervalA, List<int> intervalB) {
8+
return intervalA[0] <= intervalB[1] && intervalB[0] <= intervalA[1];
9+
}
10+
11+
List<List<int>> insert(List<List<int>> intervals, List<int> newInterval) {
12+
List<List<int>> mergedIntervals = [];
13+
List<int> merged = [newInterval[0], newInterval[1]];
14+
bool isInserted = false;
15+
16+
for (List<int> interval in intervals) {
17+
if (interval[0] > merged[1]) {
18+
if (!isInserted) {
19+
mergedIntervals.add(merged);
20+
isInserted = true;
21+
}
22+
mergedIntervals.add(interval);
23+
} else {
24+
// does intersect
25+
if (doesIntersect(merged, interval)) {
26+
merged[0] = min(merged[0], interval[0]);
27+
merged[1] = max(merged[1], interval[1]);
28+
} else {
29+
// not intersecting
30+
mergedIntervals.add(interval);
31+
}
32+
}
33+
}
34+
35+
// new interval is at the end
36+
if (!isInserted) {
37+
mergedIntervals.add(merged);
38+
isInserted = true;
39+
}
40+
41+
// Java specific to copy to arr[][]...
42+
List.filled(mergedIntervals.length, 0).map((e) => List.filled(2, 0));
43+
List<List<int>> res = List.filled(mergedIntervals.length, 0)
44+
.map((e) => List.filled(2, 0))
45+
.toList();
46+
for (int i = 0; i < mergedIntervals.length; i++) {
47+
res[i] = mergedIntervals.elementAt(i);
48+
}
49+
return res;
50+
}
51+
}
52+
```

‎README.md

+1
Original file line numberDiff line numberDiff line change
@@ -185,6 +185,7 @@ This repo contain leetcode solution using DART and GO programming language. Most
185185
- [**2246.** Longest Path With Different Adjacent Characters](LongestPathWithDifferentAdjacentCharacters/longest_path_with_Different_adjacent_characters.dart)
186186
- [**1061.** Lexicographically Smallest Equivalent String](LexicographicallySmallestEquivalentString/lexicographically_smallest_equivalent_string.dart)
187187
- [**2421.** Number of Good Paths](NumberOfGoodPaths/number_of_good_paths.dart)
188+
- [**57.** Insert Interval](InsertInterval/insert_interval.dart)
188189

189190
## Reach me via
190191

0 commit comments

Comments
 (0)