public ArrayList<Interval> merge(ArrayList<Interval> intervals) {
// Start typing your Java solution below
// DO NOT write main() function
Collections.sort(
intervals,
new Comparator<Interval>() {
public int compare(Interval a, Interval b) {
return new Integer(a.start).compareTo(new Integer(b.start));
}
});
ArrayList<Interval> res = new ArrayList<Interval>();
if (intervals.size() == 0) return res;
Interval first = new Interval(intervals.get(0).start, intervals.get(0).end);
if (intervals.size() == 1) {
res.add(first);
return res;
}
int i = 1;
while (i < intervals.size()) {
if (intervals.get(i).start > first.end) {
res.add(first);
first = intervals.get(i);
} else if (intervals.get(i).end > first.end) {
first.end = intervals.get(i).end;
}
i++;
}
res.add(first);
return res;
}
public void addNum(int val) {
if (hash.contains(val)) return;
hash.add(val);
Interval tmp = new Interval(val, val);
Interval greater = set.ceiling(tmp);
Interval smaller = set.floor(tmp);
if (greater != null) {
// System.out.println("greater:"+greater.start+" "+greater.end+" val:"+val);
if (greater.start == val + 1) {
greater.start = val;
merge(smaller, greater);
return;
}
}
if (smaller != null) {
// System.out.println("smaller:"+smaller.start+" "+smaller.end+" val:"+val);
if (smaller.end == val - 1) {
smaller.end = val;
merge(smaller, greater);
return;
}
}
set.add(tmp);
// for(Interval I : set){
// System.out.print(I.start+" "+I.end+" ");
// }
// System.out.println();
}
public void testConstructor_RI_RI2() throws Throwable {
Instant dt1 = new Instant(new DateTime(2004, 6, 9, 0, 0, 0, 0));
Instant dt2 = new Instant(new DateTime(2005, 7, 10, 1, 1, 1, 1));
Interval test = new Interval(dt1, dt2);
assertEquals(dt1.getMillis(), test.getStartMillis());
assertEquals(dt2.getMillis(), test.getEndMillis());
}
@Test
public void forEachOnFromToInterval() {
MutableList<Integer> result = Lists.mutable.of();
Interval interval = Interval.oneTo(5);
interval.forEach(CollectionAddProcedure.on(result));
Assert.assertEquals(FastList.newListWith(1, 2, 3, 4, 5), result);
}
/**
* compareTo
*
* @param that a {@link org.opennms.features.poller.remote.gwt.client.utils.Interval} object.
* @return a int.
*/
public int compareTo(final Interval that) {
if (that == null) return -1;
return new CompareToBuilder()
.append(this.getStartMillis(), that.getStartMillis())
.append(this.getEndMillis(), that.getEndMillis())
.toComparison();
}
// -----------------------------------------------------------------------
public void testParse_noOffsetInString() throws Throwable {
DateTime start = new DateTime(2010, 6, 30, 12, 30, ISOChronology.getInstance(PARIS));
DateTime end = new DateTime(2010, 7, 1, 14, 30, ISOChronology.getInstance(PARIS));
assertEquals(new Interval(start, end), Interval.parse("2010-06-30T12:30/2010-07-01T14:30"));
assertEquals(new Interval(start, end), Interval.parse("2010-06-30T12:30/P1DT2H"));
assertEquals(new Interval(start, end), Interval.parse("P1DT2H/2010-07-01T14:30"));
}
@Test
public void toFastList() {
Interval interval = Interval.evensFromTo(0, 10);
FastList<Integer> toList = (FastList<Integer>) interval.toList();
Verify.assertStartsWith(toList, 0, 2, 4, 6, 8, 10);
Verify.assertSize(6, toList);
}
/**
* Refine interval.
*
* @param iv root isolating interval with f(left) * f(right) < 0.
* @param f univariate polynomial, non-zero.
* @param eps requested interval length.
* @return a new interval v such that |v| < eps.
*/
public Interval<C> refineInterval(Interval<C> iv, GenPolynomial<C> f, C eps) {
if (f == null || f.isZERO() || f.isConstant() || eps == null) {
return iv;
}
if (iv.length().compareTo(eps) < 0) {
return iv;
}
RingFactory<C> cfac = f.ring.coFac;
C two = cfac.fromInteger(2);
Interval<C> v = iv;
while (v.length().compareTo(eps) >= 0) {
C c = v.left.sum(v.right);
c = c.divide(two);
// System.out.println("c = " + c);
// c = RootUtil.<C>bisectionPoint(v,f);
if (PolyUtil.<C>evaluateMain(cfac, f, c).isZERO()) {
v = new Interval<C>(c, c);
break;
}
Interval<C> iv1 = new Interval<C>(v.left, c);
if (signChange(iv1, f)) {
v = iv1;
} else {
v = new Interval<C>(c, v.right);
}
}
return v;
}
@Test
public void reverseInjectIntoOnFromToByInterval() {
Interval interval = Interval.oneTo(5);
Assert.assertEquals(Integer.valueOf(20), interval.reverseInjectInto(5, AddFunction.INTEGER));
Assert.assertEquals(
Integer.valueOf(20), interval.reverseThis().reverseInjectInto(5, AddFunction.INTEGER));
}
@Test
public void collectOnFromToInterval() {
Interval interval = Interval.oneTo(5);
LazyIterable<String> result = interval.collect(String::valueOf);
Verify.assertIterableSize(5, result);
Verify.assertContainsAll(result, "1", "5");
}
@Test
public void forEachWithExecutorInReverse() {
MutableList<Integer> result = Lists.mutable.of();
Interval interval = Interval.fromToBy(5, 1, -1);
interval.forEach(CollectionAddProcedure.on(result), Executors.newSingleThreadExecutor());
Assert.assertEquals(FastList.newListWith(5, 4, 3, 2, 1), result);
}
@Test
public void forEachWithExecutor() {
MutableList<Integer> result = Lists.mutable.of();
Interval interval = Interval.oneTo(5);
interval.forEach(CollectionAddProcedure.on(result), Executors.newSingleThreadExecutor());
Assert.assertEquals(FastList.newListWith(1, 2, 3, 4, 5), result);
}
public ArrayList<Interval> insert(ArrayList<Interval> inter, Interval newIn) {
// Start typing your Java solution below
// DO NOT write main() function
ArrayList<Interval> a = new ArrayList<Interval>();
boolean flag = false;
for (Interval in : inter) {
if (a.size() > 0 && in.start <= a.get(a.size() - 1).end) {
Interval tail = a.remove(a.size() - 1);
tail.end = max(in.end, tail.end);
a.add(tail);
} else a.add(in);
if (!flag && newIn.start <= a.get(a.size() - 1).end) {
flag = true;
Interval tail = a.remove(a.size() - 1);
if (newIn.end >= tail.start) {
tail.start = min(tail.start, newIn.start);
tail.end = max(tail.end, newIn.end);
a.add(tail);
} else {
a.add(newIn);
a.add(tail);
}
}
}
if (!flag) a.add(newIn);
return a;
}
/**
* Creates (if not already existing) and returns the partition in which the instant,value should
* be written. instant can be invalid (in case value only or no partitioning) value can be null
* (in case
*
* @return a Partition
*/
public synchronized Partition createAndGetPartition(long instant, Object value)
throws IOException {
Partition partition;
if (partitioningSpec.timeColumn != null) {
if ((pcache == null) || (pcache.start > instant) || (pcache.getEnd() <= instant)) {
Entry<Long, Interval> entry = intervals.floorEntry(instant);
if ((entry != null) && (instant < entry.getValue().getEnd())) {
pcache = entry.getValue();
} else { // no partition in this interval.
PartitionInfo pinfo = partitioningSpec.timePartitioningSchema.getPartitionInfo(instant);
pcache = new Interval(pinfo.partitionStart, pinfo.partitionEnd);
intervals.put(pcache.start, pcache);
}
}
}
partition = pcache.get(value);
if (partition == null) {
if (partitioningSpec.timeColumn != null) {
PartitionInfo pinfo = partitioningSpec.timePartitioningSchema.getPartitionInfo(instant);
partition = createPartition(pinfo, value);
} else {
partition = createPartition(value);
}
pcache.add(value, partition);
}
return partition;
}
@Test
public void toSet() {
Interval interval = Interval.evensFromTo(0, 10);
MutableSet<Integer> set = interval.toSet();
Verify.assertContainsAll(set, 0, 2, 4, 6, 8, 10);
Verify.assertSize(6, set);
}
public static void main(String[] args) {
int[] a = {100, 80, 60, 50, 40, 35, 95};
int c = 0, n = a.length;
Interval[] intervals = new Interval[n / 2 + 1];
int i = 0;
while (true) {
while (i < n - 1 && a[i + 1] <= a[i]) i++;
if (i >= n - 1) break;
int min = i++;
while (i < n && a[i] >= a[i - 1]) i++;
int max = i - 1;
Interval temp = new Interval();
intervals[c] = temp;
temp.buy = a[min];
temp.sell = a[max];
c++;
}
if (c == 0) {
System.out.println("No such possibility exist");
} else {
for (Interval intrvl : intervals) {
if (intrvl == null) break;
System.out.print(intrvl);
}
}
}
@Test
public void iterator() {
Interval zero = Interval.zero();
Iterator<Integer> zeroIterator = zero.iterator();
Assert.assertTrue(zeroIterator.hasNext());
Assert.assertEquals(Integer.valueOf(0), zeroIterator.next());
Assert.assertFalse(zeroIterator.hasNext());
Interval oneToFive = Interval.oneTo(5);
Iterator<Integer> oneToFiveIterator = oneToFive.iterator();
for (int i = 1; i < 6; i++) {
Assert.assertTrue(oneToFiveIterator.hasNext());
Assert.assertEquals(Integer.valueOf(i), oneToFiveIterator.next());
}
Verify.assertThrows(NoSuchElementException.class, (Runnable) oneToFiveIterator::next);
Interval threeToNegativeThree = Interval.fromTo(3, -3);
Iterator<Integer> threeToNegativeThreeIterator = threeToNegativeThree.iterator();
for (int i = 3; i > -4; i--) {
Assert.assertTrue(threeToNegativeThreeIterator.hasNext());
Assert.assertEquals(Integer.valueOf(i), threeToNegativeThreeIterator.next());
}
Verify.assertThrows(
NoSuchElementException.class, (Runnable) threeToNegativeThreeIterator::next);
Verify.assertThrows(
UnsupportedOperationException.class, () -> Interval.zeroTo(10).iterator().remove());
}
/**
* Invariant interval for algebraic number magnitude.
*
* @param iv root isolating interval for f, with f(left) * f(right) < 0.
* @param f univariate polynomial, non-zero.
* @param g univariate polynomial, gcd(f,g) == 1.
* @param eps length limit for interval length.
* @return v with v a new interval contained in iv such that |g(a) - g(b)| < eps for a, b in v
* in iv.
*/
public Interval<C> invariantMagnitudeInterval(
Interval<C> iv, GenPolynomial<C> f, GenPolynomial<C> g, C eps) {
Interval<C> v = iv;
if (g == null || g.isZERO()) {
return v;
}
if (g.isConstant()) {
return v;
}
if (f == null || f.isZERO() || f.isConstant()) { // ?
return v;
}
GenPolynomial<C> gp = PolyUtil.<C>baseDeriviative(g);
// System.out.println("g = " + g);
// System.out.println("gp = " + gp);
C B = magnitudeBound(iv, gp);
// System.out.println("B = " + B);
RingFactory<C> cfac = f.ring.coFac;
C two = cfac.fromInteger(2);
while (B.multiply(v.length()).compareTo(eps) >= 0) {
C c = v.left.sum(v.right);
c = c.divide(two);
Interval<C> im = new Interval<C>(c, v.right);
if (signChange(im, f)) {
v = im;
} else {
v = new Interval<C>(v.left, c);
}
// System.out.println("v = " + v.toDecimal());
}
return v;
}
@Test
public void take() {
Assert.assertEquals(FastList.newListWith(1, 2), Interval.fromTo(1, 3).take(2));
Assert.assertEquals(FastList.newListWith(1, 2), Interval.fromTo(1, 2).take(3));
Verify.assertThrows(IllegalArgumentException.class, () -> Interval.fromTo(1, 3).take(-1));
}
public int minMeetingRooms(Interval[] intervals) {
if (intervals == null || intervals.length == 0) return 0;
Arrays.sort(
intervals,
new Comparator<Interval>() {
public int compare(Interval a, Interval b) {
return a.start - b.start;
}
});
PriorityQueue<Interval> heap =
new PriorityQueue<Interval>(
intervals.length,
new Comparator<Interval>() {
public int compare(Interval a, Interval b) {
return a.end - b.end;
}
});
heap.offer(intervals[0]);
for (int i = 1; i < intervals.length; i++) {
Interval poll = heap.poll();
if (intervals[i].start >= poll.end) poll.end = intervals[i].end;
else heap.offer(intervals[i]);
heap.offer(poll);
}
return heap.size();
}
@Test
public void drop() {
Assert.assertEquals(FastList.newListWith(3, 4), Interval.fromTo(1, 4).drop(2));
Verify.assertIterableEmpty(Interval.fromTo(1, 2).drop(3));
Verify.assertThrows(IllegalArgumentException.class, () -> Interval.fromTo(1, 3).drop(-1));
}
public void testConstructor_long_long2() throws Throwable {
DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
Interval test = new Interval(dt1.getMillis(), dt1.getMillis());
assertEquals(dt1.getMillis(), test.getStartMillis());
assertEquals(dt1.getMillis(), test.getEndMillis());
assertEquals(ISOChronology.getInstance(), test.getChronology());
}
// the given list is sorted
// remove the duplicates of intervals with the same start
// the rule is like this: keep the longest length interval
private List<Interval> removeDuplicateStart() {
List<Interval> list = getIntervalListFromETask();
if (null == list) {
return null;
}
List<Interval> res = new ArrayList<Interval>();
int sz = list.size();
int i = 0;
while (i < sz) {
int j = i + 1;
Interval longestInterval = list.get(i);
int maxDuration = (int) (longestInterval.getEnd() - longestInterval.getStart());
while (j < sz && list.get(j).getStart() == list.get(i).getStart()) {
int curDuration = (int) (list.get(j).getEnd() - list.get(j).getStart());
if (curDuration > maxDuration) {
maxDuration = curDuration;
longestInterval = list.get(j);
}
j++;
}
res.add(longestInterval);
i = j;
}
return res;
}
@Override
public List<Double[]> getValues(Interval interval) {
List<Double[]> result = new ArrayList<Double[]>();
for (Interval<Double[]> i : intervalTree.search(interval))
result.add(new Double[] {i.getLow(), i.getHigh()});
return result;
}
@Override
public boolean hasNext() {
if (next != null) return true;
next = new ArrayList<Partition>();
while (it.hasNext()) {
Entry<Long, Interval> entry = it.next();
Interval intv = entry.getValue();
if (jumpToStart && (intv.getEnd() <= start)) {
continue;
} else {
jumpToStart = false;
}
if (partitioningSpec.type == _type.TIME) {
next.add(intv.partitions.values().iterator().next());
} else {
for (Partition p : intv.partitions.values()) {
if ((partitionValueFilter == null) || (partitionValueFilter.contains(p.getValue()))) {
next.add(p);
}
}
}
if (!next.isEmpty()) {
break;
}
}
if (next.isEmpty()) {
next = null;
return false;
} else {
return true;
}
}
public ArrayList<Interval> insert(ArrayList<Interval> intervals, Interval newInterval) {
ArrayList<Interval> result = new ArrayList<Interval>();
int p = 0;
while (p < intervals.size()) {
if (intervals.get(p).end < newInterval.start) {
result.add(intervals.get(p));
p++;
} else {
newInterval.start = Math.min(newInterval.start, intervals.get(p).start);
break;
}
}
result.add(newInterval);
while (p < intervals.size()) {
if (intervals.get(p).start > newInterval.end) {
result.add(intervals.get(p));
} else if (intervals.get(p).end >= newInterval.end
&& intervals.get(p).start <= newInterval.end) {
newInterval.end = Math.max(newInterval.end, intervals.get(p).end);
}
p++;
}
return result;
}
public void testConstructor_Object6() throws Throwable {
IntervalConverter oldConv =
ConverterManager.getInstance().getIntervalConverter(new Interval(0L, 0L));
IntervalConverter conv =
new IntervalConverter() {
public boolean isReadableInterval(Object object, Chronology chrono) {
return false;
}
public void setInto(ReadWritableInterval interval, Object object, Chronology chrono) {
interval.setChronology(chrono);
interval.setInterval(1234L, 5678L);
}
public Class<?> getSupportedType() {
return ReadableInterval.class;
}
};
try {
ConverterManager.getInstance().addIntervalConverter(conv);
Interval base = new Interval(-1000L, 1000L);
Interval test = new Interval(base);
assertEquals(1234L, test.getStartMillis());
assertEquals(5678L, test.getEndMillis());
} finally {
ConverterManager.getInstance().addIntervalConverter(oldConv);
}
}
public void testConstructor_Object5() throws Throwable {
IntervalConverter oldConv = ConverterManager.getInstance().getIntervalConverter("");
IntervalConverter conv =
new IntervalConverter() {
public boolean isReadableInterval(Object object, Chronology chrono) {
return false;
}
public void setInto(ReadWritableInterval interval, Object object, Chronology chrono) {
interval.setChronology(chrono);
interval.setInterval(1234L, 5678L);
}
public Class<?> getSupportedType() {
return String.class;
}
};
try {
ConverterManager.getInstance().addIntervalConverter(conv);
DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
Interval test = new Interval(dt1.toString() + '/' + dt2.toString());
assertEquals(1234L, test.getStartMillis());
assertEquals(5678L, test.getEndMillis());
} finally {
ConverterManager.getInstance().addIntervalConverter(oldConv);
}
}
// -----------------------------------------------------------------------
public void testConstructor_Object1() throws Throwable {
DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
Interval test = new Interval(dt1.toString() + '/' + dt2.toString());
assertEquals(dt1.getMillis(), test.getStartMillis());
assertEquals(dt2.getMillis(), test.getEndMillis());
}
public void testConstructor_RI_RI_instant() throws Throwable {
Instant dt1 = new Instant(12345678L);
Instant dt2 = new Instant(22345678L);
Interval test = new Interval(dt1, dt2);
assertEquals(12345678L, test.getStartMillis());
assertEquals(22345678L, test.getEndMillis());
assertEquals(ISOChronology.getInstanceUTC(), test.getChronology());
}
