Comparing datetimes and joining when they are within 5 minutes [closed] - ruby

Question

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.
Closed 9 years ago.
I have a large array of DateTimes. For example:
[2013-06-17 19:47:12,
2013-06-17 19:40:01,
2013-06-17 19:42:53,
2013-06-17 19:12:27,
2013-06-17 19:45:42,
2013-06-17 19:14:17]... etc
What I'd like to do is iterate through the array and come up with a bunch of ranges for DateTime objects that are within 5 minutes of one another.
So, the result I would get is:
[
{range_start: 2013-06-17 19:40:01, range_end: 2013-06-17 19:47:12},
{range_start: 2013-06-17 19:12:27, range_end: 2013-06-17 19:14:17},
]
As you can see, the first object in the result set would contain all 4 DateTime objects in the example above by getting the earliest time and latest time and making a range. Likewise for the second.
Basically, what I'm trying to do is group together DateTimes that are within 5 minutes of each other, however I'm not sure how to do it without excessive recursion. For example, once I grab the first DateTime and I find another that is within 5 minutes of it, I then need to find all the other DateTime items that are within 5 minutes of the recently found DateTime.
Start at minute 42
Search 5 minutes before and after
Find another DateTime at minute 44, so now range is 42-44
Need to search 5 minutes before and after range of 42-44 (so anything from 38 to 49)
If I find something at minute 49, then range goes to 42-49
Now search radius is 38 to 54, etc...

Answer 1

Assuming that the time array does not include the unix epoch:
array
.sort
.unshift(Time.at(0))
.each_cons(2)
.slice_before{|t1, t2| t1 + 300 < t2}
.map{|a| min, max = a.map(&:last).minmax; {range_start: min, range_end: max}}

Answer 2

I wasn't going to post this as it was so close to sawa's solution. However this is a working solution whereas his has a couple of major issues.
require 'time'
array = [
'2013-06-17 19:47:12',
'2013-06-17 19:40:01',
'2013-06-17 19:42:53',
'2013-06-17 19:12:27',
'2013-06-17 19:45:42',
'2013-06-17 19:14:17'
].map { |dt| DateTime.parse(dt) }
prev_dt = nil
ranges = array.sort.slice_before do |dt|
is_new_range = prev_dt && (dt - prev_dt) * 1440 > 5
prev_dt = dt
is_new_range
end.map { |range| { range_start: range.first, range_end: range.last } }
ranges.each { |r| p r }
output
{:range_start=>#<DateTime: 2013-06-17T19:12:27+00:00 ((2456461j,69147s,0n),+0s,2299161j)>, :range_end=>#<DateTime: 2013-06-17T19:14:17+00:00 ((2456461j,69257s,0n),+0s,2299161j)>}
{:range_start=>#<DateTime: 2013-06-17T19:40:01+00:00 ((2456461j,70801s,0n),+0s,2299161j)>, :range_end=>#<DateTime: 2013-06-17T19:47:12+00:00 ((2456461j,71232s,0n),+0s,2299161j)>}

Answer 3

This is how I'd go about it:
require 'time'
FIVE_MINUTES = 60 * 5
timestamps = [
'2013-06-17 19:47:12',
'2013-06-17 19:40:01',
'2013-06-17 19:42:53',
'2013-06-17 19:12:27',
'2013-06-17 19:45:42',
'2013-06-17 19:14:17'
].map{ |s| Time.parse(s) }.sort
ranges = [timestamps.first .. timestamps.shift]
loop do
break if timestamps.empty?
if (timestamps.first - ranges.last.max) <= FIVE_MINUTES
ranges[-1] = (ranges.last.min .. timestamps.shift)
else
ranges << (timestamps.first .. timestamps.shift)
end
end
pp ranges.map{ |r|
Hash[
:range_start, r.min,
:range_end, r.max
]
}
Which is an array of hashes:
[
{
:range_start => 2013-06-17 19:12:27 -0700,
:range_end => 2013-06-17 19:14:17 -0700
},
{
:range_start => 2013-06-17 19:40:01 -0700,
:range_end => 2013-06-17 19:47:12 -0700
}
]
I converted the DateTime strings to Time values because you get an integer in seconds when subtracting them. That worked well when comparing to FIVE_MINUTES. If you need DateTime objects, you can convert them easily using:
pp ranges.map{ |r|
Hash[
:range_start, r.min.to_datetime,
:range_end, r.max.to_datetime
]
}
Which now looks like:
[
{
:range_start=> #<DateTime: 2013-06-17T19:12:27-07:00 ((2456462j,7947s,0n),-25200s,2299161j)>,
:range_end=> #<DateTime: 2013-06-17T19:14:17-07:00 ((2456462j,8057s,0n),-25200s,2299161j)>
},
{
:range_start=> #<DateTime: 2013-06-17T19:40:01-07:00 ((2456462j,9601s,0n),-25200s,2299161j)>,
:range_end=> #<DateTime: 2013-06-17T19:47:12-07:00 ((2456462j,10032s,0n),-25200s,2299161j)>
}
]
I sorted the array because that made it pretty straightforward to find values that were within the five minute boundaries of each other. That results in the ranges being sorted also.