Algorithm to count occurance in a consecutive amount of time - arrays

Question

I have a set of data that that tells me the on/off status of a component as a function of time. The data looks like this :
0 1
120 1
240 0
360 0
480 1
600 1
720 1
840 0
960 0
1080 0
1200 1
1320 1
1440 0
1560 0
1680 1
1800 0
1920 1
First column shows the time in second and the second column shows the status (1 is on, 0 is off).
I need to know the what is the 600 seconds with the most 1 in it. For example, 0-600 has 3*120 s so 360 seconds where component is on. But 120-720 has 4 etc... This means that this is not only 0-600, 600-1200, it can by any 600 seconds. The hard thing is that this is a cycle, meaning that the worst hour could be from 1920 to 480 (Note that this cycle has 2040s meaning time 2040 is also time 0). The time steps are not always equal. In this case it is a constant 120s, but it could be a mix of 120s and 150s for example.
The only thing I can think of is to scan the file from 0-600, check time is was on, 120-720, 240-840 etc... but it is very time consuming. Especially since I can have very big files.
The program is in Perl, but I only need the algorithm (if it exists). Do any of you has an idea on what would be the best approach?
Thank you

Answer 1

It isn't quite clear what value you're trying to calculate, but your core problem appears to be finding an algorithm for getting the samples in each sliding 600s window. The sliding window can be implemented as an array. Add new samples to the end and purge old samples to keep the total size <= 600s. The only tricky part is accounting for the time values being modulo 2040.
use strict;
use warnings;
use Data::Dump qw(pp);
my #window;
while (my $line = <DATA>) {
chomp $line;
my ($t, $on) = split / +/, $line;
# add sample to sliding window
push #window, { t => $t, on => $on};
# limit window size to 600s
while (1) {
last if #window <= 1;
my $start = $window[0]{t};
my $stop = $window[-1]{t};
# account for time values being mod 2040
if ($stop < $start) {
$stop += 2040;
}
if ($stop - $start > 600) {
# purge old sample from window
shift #window;
}
else {
last;
}
}
# do something with #window
pp \#window;
}
__DATA__
0 1
120 1
240 0
360 0
480 1
600 1
720 1
840 0
960 0
1080 0
1200 1
1320 1
1440 0
1560 0
1680 1
1800 0
1920 1
0 1
120 1
240 0
360 0
The values in #window look like this:
# no wrapping
[
{ on => 1, t => 0 },
{ on => 1, t => 120 },
{ on => 0, t => 240 },
{ on => 0, t => 360 },
{ on => 1, t => 480 },
{ on => 1, t => 600 },
]
# with wrapping
[
{ on => 0, t => 1560 },
{ on => 1, t => 1680 },
{ on => 0, t => 1800 },
{ on => 1, t => 1920 },
{ on => 1, t => 0 },
{ on => 1, t => 120 },
]

Answer 2

The problem may be solved in the following manner.
Define an integer n; Keep adding the ones to n until a zero occurs. That is, if a zero occurs set n to zero. In the process record the maximum n occurrence and the seconds at that time. To do this define another variable m and let m be the max value. Now if n becomes greater than m then m=n. In this way you can get near the 600s interval containing maximum number of 1s. Good luck. I hope, it worked.

Answer 3

Assuming that points are sorted by time, you can keep buffer of consecutive points in a way that time difference between first point and last point do not exceed 600. Here is the code in C#:
// Class for data point
class Point {
public int Time { get; private set; }
public bool On { get; private set; }
public Point(int time, bool on) {
Time = time;
On = on;
}
}
Point[] points = {
new Point(0, true),
new Point(120, true),
new Point(240, false),
new Point(360, false),
new Point(480, true),
new Point(600, true),
new Point(720, true),
new Point(840, false),
new Point(960, false),
new Point(1080, false),
new Point(1200, true),
new Point(1320, true),
new Point(1440, false),
new Point(1560, false),
new Point(1680, true),
new Point(1800, false),
new Point(1920, true),
};
int GetMaxIntervalCount(IEnumerable<Point> points) {
LinkedList<Point> buff = new LinkedList<Point>();
int buffCount = 0, res = -1;
foreach (Point point in points) {
buff.AddFirst(point);
while (buff.Count > 0) {
Point last = buff.Last.Value;
if (Math.Abs(last.Time - point.Time) > 600) {
buff.RemoveLast();
if (last.On) {
--buffCount;
}
} else {
break;
}
}
if (point.On) {
++buffCount;
}
res = Math.Max(res, buffCount);
}
return res;
}
Currently it returns only maximum count, but it can be easily adjusted to also keep actual buffer. Time complexity of a method is O(N) (each point will be
"touched" at most 2 times - on adding and deleting from buffer).