Ruby가 범위 내에서 발생 횟수를 찾습니다.

Question

각 행이 프로세스의 시작 및 종료 시간을 알려주는 다음 데이터가 있습니다.

12:20:00에서 14:00:00까지 5 분의 단계를 알고 싶습니다. 각 인스턴스에서 얼마나 많은 프로세스가 실행되고 있는지 알고 싶습니다. 예를 들어, 각각 12:30과 12:35에 2 개와 1 개의 프로세스가 실행 중입니다.

저는 이것을 Ruby 1.8에서 구현하고 싶습니다. Ruby 1.8에서 이것을 구현하는 방법은 무엇입니까?

12:28:08, 12:33:29 
12:28:20, 12:33:41 
12:32:32, 12:32:44 
12:36:56, 12:42:31 
13:08:55, 13:09:08 
14:09:00, 14:09:12 
14:59:19, 15:04:37 
15:41:40, 15:41:52 

(댓글) 시 : 이미 시작 시간에 대한 배열을 가지고, STIME 및 종료 시간, etime이. 당신은 (1.9에서 개발하지만,뿐만 아니라 1.8에서 작동한다)이 코드를 시도 할 수 있습니다

(sTime..eTime).step($time_interval) do |cTime| # Current Time 
     cnt = 0 
     (0..(sessionstarttime.length-1)).each {|i| if cTime.between? (sessionstarttime[i], sessionendtime[i]); cnt += 1} 
     printf "%s, %d\n", cTime.strftime("%d/%m/%Y %H:%M:%S"), cnt 
    end 

Answer 1

: :이 같은 것을하고 싶지 필요하지 않은 물론

a = %Q{ 
12:28:08, 12:33:29 
12:28:20, 12:33:41 
12:32:32, 12:32:44 
12:36:56, 12:42:31 
13:08:55, 13:09:08 
14:09:00, 14:09:12 
14:59:19, 15:04:37 
15:41:40, 15:41:52 
} 

start = '12:20:00' 
stop = '14:00:00' 

require 'stringio' 

def time_to_sec(time) 
    a = time.split(':').map(&:to_i) 
    a[0] * 3600 + a[1] * 60 + a[2] 
end 

def sec_to_time(sec) 
    h, n = sec.divmod 3600 
    m, s = n.divmod 60 
    "%02d:%02d:%02d" % [h, m, s] 
end 

rows = StringIO.new(a).read.delete(",").split("\n").reject{ |i| i.empty? }.map do |range| 
    range.split.map{ |time| time_to_sec(time) } 
end 

ranges = rows.map{ |i| i[0]..i[1] } 

(time_to_sec(start)..time_to_sec(stop)).step(5*60) do |time| 
    cnt = ranges.count{|i| i.include? time} 
    puts "#{sec_to_time(time)}: #{cnt}" 
end 

을 'A' 실제 파일을 사용하는 경우 변수 또는 StringIO. 당신이 시간 객체에 값을 변환하면

Answer 2

, 다음을 수행 할 수 있습니다 (I이 예를 들어 2000-01-01의 날짜를 가정 한주의) : 여기

a= [ 
    { :s=> Time.utc(2000, 1, 1, 12, 28, 8), :e=> Time.utc(2000, 1, 1, 12, 33, 29) }, 
    { :s=> Time.utc(2000, 1, 1, 12, 28, 20), :e=> Time.utc(2000, 1, 1, 12, 33, 41) }, 
    { :s=> Time.utc(2000, 1, 1, 12, 32, 32), :e=> Time.utc(2000, 1, 1, 12, 32, 44) }, 
    { :s=> Time.utc(2000, 1, 1, 12, 36, 56), :e=> Time.utc(2000, 1, 1, 12, 42, 31) }, 
    { :s=> Time.utc(2000, 1, 1, 13, 8, 55), :e=> Time.utc(2000, 1, 1, 13, 9, 8) }, 
    { :s=> Time.utc(2000, 1, 1, 14, 9, 0), :e=> Time.utc(2000, 1, 1, 14, 9, 12) }, 
    { :s=> Time.utc(2000, 1, 1, 14, 59, 19), :e=> Time.utc(2000, 1, 1, 15, 4, 37) }, 
    { :s=> Time.utc(2000, 1, 1, 15, 41, 40), :e=> Time.utc(2000, 1, 1, 15, 41, 52) } 
] 

checkTime = Time.utc(2000, 1, 1, 12, 32, 40) 

a.delete_if{|b| #b[:s] is start time, b[:e] is end time 
    (b[:s] > checkTime) || (b[:e] < checkTime) 
} 

Answer 3

의 커플 필요한 것을 계산해야하는 것을 모델링하는 간단한 개체. 이렇게하면 필요한 경우보다 복잡한 논리를 수행하는 데 사용할 수있는 인터페이스가 시작됩니다.

다음

require 'time' 

# Object Definitions 

class ProcessTimelineEntry 
    def initialize(start_time, end_time) 
    @start_time = start_time 
    @end_time = end_time 
    end 

    def running_at?(time) 
    time >= @start_time && time < @end_time 
    end 
end 

class ProcessTimeline 
    def initialize() 
    @entries = [] 
    end 

    def add_entry(start_time, end_time) 
    @entries << ProcessTimelineEntry.new(start_time, end_time) 
    end 

    def process_count_at(time) 
    @entries.count { |e| e.running_at?(time) } 
    end 
end 

# Example Usage 

timeline = ProcessTimeline.new 

DATA.readlines.each do |line| 
    start_time, end_time = line.split(', ') 
    timeline.add_entry(Time.parse(start_time), Time.parse(end_time)) 
end 

puts timeline.process_count_at(Time.parse("12:30")) 
puts timeline.process_count_at(Time.parse("12:35")) 


__END__ 
12:28:08, 12:33:29 
12:28:20, 12:33:41 
12:32:32, 12:32:44 
12:36:56, 12:42:31 
13:08:55, 13:09:08 
14:09:00, 14:09:12 
14:59:19, 15:04:37 
15:41:40, 15:41:52 

Answer 4

, 당신은 각 시간 단계에서 실행중인 프로세스의 수를 알고 싶어 주어진 다른 답변을 게시보다 스타트 스톱 쌍 또는 시간 단계의 많은 수의 더 나은 확장 할 수있는 솔루션입니다 (단지 1 또는 2 선택한 시간 단계) :

START = Time.utc(2000,1,1, 12,20,0).to_i 
FINISH = Time.utc(2000,1,1, 14,0,0).to_i 
STEP = 60*5 # 5 minutes 
result = Array.new(((FINISH-START).to_f/STEP).ceil, 0) 
processes = %Q{ 
    12:28:08, 12:33:29 
    12:28:20, 12:33:41 
    12:32:32, 12:32:44 
    12:36:56, 12:42:31 
    13:08:55, 13:09:08 
    14:09:00, 14:09:12 
    14:59:19, 15:04:37 
    15:41:40, 15:41:52 } 

processes.each_line do |times| 
    times =~ /(\d\d):(\d\d):(\d\d), (\d\d):(\d\d):(\d\d)/ 
    st = Time.utc(2000,1,1, $1.to_i,$2.to_i,$3.to_i).to_i 
    fin = Time.utc(2000,1,1, $4.to_i,$5.to_i,$6.to_i).to_i 
    st = START if st < START 
    fin = END if fin > END 
    (st..fin).step(STEP) do |t| 
    result[(t-START)/STEP] += 1 
    end 
end 

각 시간 단계에서 실행 얼마나 많은 프로세스의 수는 result에 남아있을 것입니다. 좋은 인터페이스를 제공하려는 경우 원하는 경우 오브젝트 랩퍼를 둘 수 있습니다.