使用python解决计划冲突

所以我输入了n个用户的时间表，我想形成一个新的时间表，显示时间联盟

这是输入

[08:00-08:50'、'09:00-09:50'、'10:00-10:50'、'11:00-11:50'， '11:00-12:15', '12:00-12:50', '12:00-13:15', '13:00-13:50', “14:00-15:15”，“15:30-18:10']

输出应该是这样的

[08:00-08:50'、'09:00-09:50'、'10:00-10:50'、'11:00-13:50'， “14:00-15:15”，“15:30-18:10']

这就是我迄今为止所尝试的

if start_currenttime < start_oldtime and end_currenttime >= start_oldtime:
    start=start_currenttime
    flag=1

    if end_currenttime>end_oldtime:
        end=end_currenttime

if start_currenttime >= start_oldtime and start_currenttime <= end_oldtime and end_currenttime > end_oldtime:
    flag=1
    end=end_currenttime

if flag:
     return str(start)+"-"+str(end)
else: return "-1"

---

这是一种方法，使用基本for循环：

data = ['08:00-08:50', '09:00-09:50', '10:00-10:50', '11:00-11:50', '11:00-12:15', '12:00-12:50', '12:00-13:15', '13:00-13:50', '14:00-15:15', '15:30-18:10']
data_ = [interval.split('-') for interval in data]


interval_idx = 0
for i in data_:
    if i[0] > data_[interval_idx][1]:
        interval_idx += 1
        data_[interval_idx] = i
    else:
        data_[interval_idx] = [data_[interval_idx][0], i[1]]

data_=['-'.join(interval) for interval in data_[:interval_idx+1]]

print(data_)

输出：

['08:00-08:50', '09:00-09:50', '10:00-10:50', '11:00-13:50', '14:00-15:15', '15:30-18:10']

[['08:00', '08:50'], ['09:00', '09:50'], ['10:00', '10:50'], ['11:00', '13:50'], ['14:00', '15:15'], ['15:30', '18:10']]

---

这是一种方法，使用基本for循环：

data = ['08:00-08:50', '09:00-09:50', '10:00-10:50', '11:00-11:50', '11:00-12:15', '12:00-12:50', '12:00-13:15', '13:00-13:50', '14:00-15:15', '15:30-18:10']
data_ = [interval.split('-') for interval in data]


interval_idx = 0
for i in data_:
    if i[0] > data_[interval_idx][1]:
        interval_idx += 1
        data_[interval_idx] = i
    else:
        data_[interval_idx] = [data_[interval_idx][0], i[1]]

data_=['-'.join(interval) for interval in data_[:interval_idx+1]]

print(data_)

输出：

['08:00-08:50', '09:00-09:50', '10:00-10:50', '11:00-13:50', '14:00-15:15', '15:30-18:10']

[['08:00', '08:50'], ['09:00', '09:50'], ['10:00', '10:50'], ['11:00', '13:50'], ['14:00', '15:15'], ['15:30', '18:10']]

---

正如@h4z3所暗示的，从一个排序的列表开始是很重要的，其中每个间隔的开始顺序是升序。考虑到一天内的时间是按字典顺序排序的，我们不需要解析实际时间，将它们作为字符串处理就足够了

data = ['08:00-08:50', '09:00-09:50', '10:00-10:50', '12:00-12:50', '11:00-11:50', '11:00-12:15', '12:00-13:15', '13:00-13:50', '14:00-15:15', '15:30-18:10']

def parse_intervals(data):
    return [tuple(interval.split('-')) for interval in data]

intervals = sorted(parse_intervals(data))

results = []
start_oldtime, stop_oldtime = intervals[0]
for start_currenttime, stop_currenttime in intervals:
    # if the start of the new is later than the end of the new, close the old
    if stop_oldtime < start_currenttime :
        results.append('-'.join([start_oldtime, stop_oldtime]))
        start_oldtime = start_currenttime
        stop_oldtime = stop_currenttime
    # if the end is later, extend the interval
    else:
        stop_oldtime = max(stop_currenttime, stop_oldtime)

# add any started interval
results.append('-'.join([start_oldtime, stop_oldtime]))

print(results)

---

正如@h4z3所暗示的，从一个排序的列表开始是很重要的，其中每个间隔的开始顺序是升序。考虑到一天内的时间是按字典顺序排序的，我们不需要解析实际时间，将它们作为字符串处理就足够了

data = ['08:00-08:50', '09:00-09:50', '10:00-10:50', '12:00-12:50', '11:00-11:50', '11:00-12:15', '12:00-13:15', '13:00-13:50', '14:00-15:15', '15:30-18:10']

def parse_intervals(data):
    return [tuple(interval.split('-')) for interval in data]

intervals = sorted(parse_intervals(data))

results = []
start_oldtime, stop_oldtime = intervals[0]
for start_currenttime, stop_currenttime in intervals:
    # if the start of the new is later than the end of the new, close the old
    if stop_oldtime < start_currenttime :
        results.append('-'.join([start_oldtime, stop_oldtime]))
        start_oldtime = start_currenttime
        stop_oldtime = stop_currenttime
    # if the end is later, extend the interval
    else:
        stop_oldtime = max(stop_currenttime, stop_oldtime)

# add any started interval
results.append('-'.join([start_oldtime, stop_oldtime]))

print(results)

---

我的目标是，假设一个排序列表：

schedules = ['08:00-08:50', '09:00-09:50', '10:00-10:50', '11:00-11:50', '11:00-12:15', '12:00-12:50', '12:00-13:15', '13:00-13:50', '14:00-15:15', '15:30-18:10']

def merge_overlap(ranges):
    intervals = [a_range.split('-') for a_range in ranges]

    merged_intervals = []
    current_interval = intervals[0]
    for interval in intervals:
        if current_interval[1] < interval[0]:
            merged_intervals.append(current_interval)
            current_interval = interval
        else:
            current_interval[1] = interval[1]
    merged_intervals.append(current_interval)
    return merged_intervals


print(merge_overlap(schedules))

以“-”分隔 有一个空的要填充的合并\u间隔，以及一个当前\u间隔，用于在将重叠间隔添加到合并\u间隔之前合并重叠间隔 穿越间隔 如果当前_间隔的上限低于间隔的下限，则将其添加到合并的_间隔中，并将当前_间隔设置为间隔 如果不是，则通过以下方式合并到当前_间隔：当前_间隔[1]=间隔[1]

---

我的目标是，假设一个排序列表：

schedules = ['08:00-08:50', '09:00-09:50', '10:00-10:50', '11:00-11:50', '11:00-12:15', '12:00-12:50', '12:00-13:15', '13:00-13:50', '14:00-15:15', '15:30-18:10']

def merge_overlap(ranges):
    intervals = [a_range.split('-') for a_range in ranges]

    merged_intervals = []
    current_interval = intervals[0]
    for interval in intervals:
        if current_interval[1] < interval[0]:
            merged_intervals.append(current_interval)
            current_interval = interval
        else:
            current_interval[1] = interval[1]
    merged_intervals.append(current_interval)
    return merged_intervals


print(merge_overlap(schedules))

以“-”分隔 有一个空的要填充的合并\u间隔，以及一个当前\u间隔，用于在将重叠间隔添加到合并\u间隔之前合并重叠间隔 穿越间隔 如果当前_间隔的上限低于间隔的下限，则将其添加到合并的_间隔中，并将当前_间隔设置为间隔 如果不是，则通过以下方式合并到当前_间隔：当前_间隔[1]=间隔[1]

---

我的想法可以分解为三个条件。首先，我们将一次循环两个计时，我们将第一个计时称为第一个计时，第二个计时称为下一个计时。然后，我们将在以下条件下检查每个计时。当然，我假设数组已排序

如果下一个_计时完全包含在计时中，我们将删除它。 如果next_计时与计时相交，我们将更新计时以结束next_计时，并删除next_计时。 如果下一次计时与计时完全不相交，我们将什么也不做。 我实现了前面的算法，如下所示：

timings = ['08:00-08:50', '09:00-09:50', '10:00-10:50',
        '11:00-11:50', '11:00-12:15', '12:00-12:50',
        '12:00-13:15', '13:00-13:50', '14:00-15:15',
        '15:30-18:10']
# split to easily find start and end timing
timings = [t.split('-') for t in timings]

def is_within_the_range(timing,next_timing):
    return True if timing[0] >= next_timing[0] and timing[1]>=next_timing[1] else False

def is_intersecting(timing,next_timing):
    return True if timing[0] <=  next_timing[0] and timing[1] > next_timing[0] and timing[1] < next_timing[1] else False

i = 1
while i < len(timings):
timing = timings[i-1]
next_timing = timings[i]
if is_within_the_range(timing,next_timing):
    del timings[i]
    i = i-1
elif is_intersecting(timing,next_timing):
    timing[1] = next_timing[1]
    timings[i-1] = timing
    del timings[i]
    i = i-1
i+=1 

print(timings)

---

我的想法可以分解为三个条件。首先，我们将一次循环两个计时，我们将第一个计时称为第一个计时，第二个计时称为下一个计时。然后，我们将在以下条件下检查每个计时。当然，我假设数组已排序

如果下一个_计时完全包含在计时中，我们将删除它。 如果next_计时与计时相交，我们将更新计时以结束next_计时，并删除next_计时。 如果下一次计时与计时完全不相交，我们将什么也不做。 我实现了前面的算法，如下所示：

timings = ['08:00-08:50', '09:00-09:50', '10:00-10:50',
        '11:00-11:50', '11:00-12:15', '12:00-12:50',
        '12:00-13:15', '13:00-13:50', '14:00-15:15',
        '15:30-18:10']
# split to easily find start and end timing
timings = [t.split('-') for t in timings]

def is_within_the_range(timing,next_timing):
    return True if timing[0] >= next_timing[0] and timing[1]>=next_timing[1] else False

def is_intersecting(timing,next_timing):
    return True if timing[0] <=  next_timing[0] and timing[1] > next_timing[0] and timing[1] < next_timing[1] else False

i = 1
while i < len(timings):
timing = timings[i-1]
next_timing = timings[i]
if is_within_the_range(timing,next_timing):
    del timings[i]
    i = i-1
elif is_intersecting(timing,next_timing):
    timing[1] = next_timing[1]
    timings[i-1] = timing
    del timings[i]
    i = i-1
i+=1 

print(timings)

---

到目前为止你都尝试了什么？请告诉我们你尝试了什么。所以不是代码编写服务，我们可以帮你调试提示：如果对时间进行排序很容易，就像在您的示例输入中一样。我对输入进行了排序，因此它与我上面所写的内容完全相同：类似的内容将在这里派上用场……到目前为止您尝试了什么？请向我们展示您尝试了什么。所以不是代码编写服务，我们可以帮你调试提示：如果对时间进行排序很容易，就像在您的示例输入中一样。我对输入进行了排序，因此它与我上面所写的完全相同：类似的东西在这里会派上用场…