Java 算法-查找循环世界中重叠间隔的持续时间（24小时）

我一直在尝试找出两个时间范围之间重叠小时数的算法，例如：

应该12点回来

及

应该返回4

因此，请帮助我填补创建以下函数的空白：

public static Long findOverlappingInterval(Long startTime1, Long endTime1,
                                           Long startTime2, Long endTime2){ 
    // Any suggestions?
}

谢谢

编辑： 我知道使用

和

创建两个二进制数组并总结结果的解决方案。 意思是：

但这无助于我的具体需求，因为我想将算法的思想用于solr查询，因此使用数组和二进制运算符对我来说不是一个选项

/**开始时间必须小于结束时间*/
/** Start times must be smaller than end times */
public static int findOverlappingInterval(int startTime1, int endTime1, int startTime2, int endTime2) {
    int overlappingTime = 0;
    int[] time1 = new int[Math.abs(endTime1 - startTime1)];
    for (int i1 = startTime1; i1 < endTime1; i1++) {
        time1[i1 - startTime1] = i1;
    }
    int[] time2 = new int[Math.abs(endTime2 - startTime2)];
    for (int i2 = startTime2; i2 < endTime2; i2++) {
        time2[i2 - startTime2] = i2;
    }

    for (int i = 0; i < time1.length; i++) {
        for (int j = 0; j < time2.length; j++) {
            if (time1[i] == time2[j]) {
                overlappingTime++;
            }
        }
    }
    return overlappingTime;
}

公共静态int-findOverlappingInterval（int-startTime1、int-endTime1、int-startTime2、int-endTime2）{
int重叠时间=0；
int[]time1=newint[Math.abs（endTime1-startTime1）]；
对于（int i1=startTime1；i1

这个方法应该适用于你想要它做的事情。这对我有用。 不过我不确定包装部分

编辑

/**返回四个时间变量之间的重叠*/
公共静态int-findOverlappingInterval（int-startTime1、int-endTime1、int-startTime2、int-endTime2）{
int重叠时间=0；
//第一次
int time1Length=0；
如果（结束时间1<开始时间1）{
时间长度=24-起始时间1；
时间1长度+=结束时间1；
}
int[]时间1；
if（time1Length==0）{
time1=newint[Math.abs（endTime1-startTime1）]；
对于（int i1=startTime1；i1

这段新代码应该满足您的要求。它在24小时内循环。

首先，对于间隔

（a，b）

（a>b），我们可以很容易地将其分成两个间隔

(a , 23) and (0, b)

---

因此，问题变成了用

a查找
（a，b）
和
（a1，b1）
之间的重叠。您不需要创建数组，只需计算区间之间的交点即可。有三种情况：

没有分割的间隔
一个分开的间隔
两个间隔都是分开的
可以将拆分的间隔作为两个单独的间隔来解决。使用递归，您可以轻松做到这一点：

public static Long findOverlappingInterval(Long startTime1, Long endTime1, Long startTime2, Long endTime2)
{
    if (startTime1 < endTime1 && startTime2 < endTime2) 
        return Math.max(0, Math.min(endTime2, endTime1) - Math.max(startTime1, startTime2) + 1);
    else
    {
        if (startTime1 < endTime1) 
            return findOverlappingInterval(startTime1, endTime1, 0L, endTime2) + 
                   findOverlappingInterval(startTime1, endTime1, startTime2, 23L);
        else if (startTime2 < endTime2) 
            return findOverlappingInterval(0L, endTime1, startTime2, endTime2) + 
                   findOverlappingInterval(startTime1, 23L, startTime2, endTime2);
        else
        {
            return findOverlappingInterval(0L, endTime1, 0L, endTime2) +
                   findOverlappingInterval(0L, endTime1, startTime2, 23L) +
                   findOverlappingInterval(startTime1, 23L, 0L, endTime2) +
                   findOverlappingInterval(startTime1, 23L, startTime2, 23L);
        }
    }
}

public static Long find应用程序接口（Long startTime1、Long endTime1、Long startTime2、Long endTime2）
{
if（startTime1
检查此处的链接：

编辑：从以下链接插入代码：

import java.util.*；
导入java.lang.*；
导入java.io.*；
/*只有当类是公共的时，类的名称才必须是“Main”*/
表意文字
{
公共静态长分钟（长a、长b）{
报税表（（a）（b）？（a）：（b））；
}
公共静态void main（字符串[]args）引发java.lang.Exception
{
长s1=6L，e1=23L，s2=2L，e2=17L，ans=0L；
布尔brokern1，brokern2；
Brokern1=（s1在短时间内有许多令人惊讶的答案

我遵循了在其他答案中已经提出的相同想法：当开始时间
s
小于结束时间
e
，那么结果可以分解为两个单独的计算，范围是
[s，24]
和
[0，e]

<>这可以相互“做”，所以只有3个简单的情况需要考虑。
public static Long findOverlappingInterval(Long startTime1, Long endTime1, Long startTime2, Long endTime2)
{
    if (startTime1 < endTime1 && startTime2 < endTime2) 
        return Math.max(0, Math.min(endTime2, endTime1) - Math.max(startTime1, startTime2) + 1);
    else
    {
        if (startTime1 < endTime1) 
            return findOverlappingInterval(startTime1, endTime1, 0L, endTime2) + 
                   findOverlappingInterval(startTime1, endTime1, startTime2, 23L);
        else if (startTime2 < endTime2) 
            return findOverlappingInterval(0L, endTime1, startTime2, endTime2) + 
                   findOverlappingInterval(startTime1, 23L, startTime2, endTime2);
        else
        {
            return findOverlappingInterval(0L, endTime1, 0L, endTime2) +
                   findOverlappingInterval(0L, endTime1, startTime2, 23L) +
                   findOverlappingInterval(startTime1, 23L, 0L, endTime2) +
                   findOverlappingInterval(startTime1, 23L, startTime2, 23L);
        }
    }
}

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
    public static Long min(Long a,Long b){
        return ((a)<(b)?(a):(b));
    }
    public static Long max(Long a,Long b){
        return ((a)>(b)?(a):(b));
    }
    public static void main (String[] args) throws java.lang.Exception
    {
        Long s1=6L,e1=23L,s2=2L,e2=17L,ans=0L;
        Boolean broken1,broken2;
        broken1=(s1<=e1)?false:true;
        broken2=(s2<=e2)?false:true;
        if(broken1){
            if(broken2)
                ans=min(e1,e2)+1 + 23-max(s1,s2)+1;
            else{
                if(e1>=s2) ans+=(min(e1,e2)-s2+1);
                if(s1<=e2) ans+=(e2-max(s1,s2)+1);
            }
        }
        else{
            if(broken2){
                if(e2>=s1) ans+=(min(e1,e2)-s1+1);
                if(s2<=e1) ans+=(e1-max(s1,s2)+1);
            }
            else{
                if(e1<s2 || e2<s1) ans=0L;
                else ans=min(e1,e2)-max(s1,s2)+1;
            }
        }
        System.out.println(ans+"");
    }
}

public class OverlappingIntervals
{
    private static final long INTERVAL_SIZE = 24;

    public static void main(String[] args)
    {
        test(6,23, 2,17);
        test(0,12, 12,2);

        test(11,4, 12,3);
        test(12,4, 11,3);
    }

    private static void test(
        long s0, long e0, long s1, long e1)
    {
        System.out.println(createString(s0, e0, s1, e1));
        System.out.println(findOverlappingInterval(s0, e0, s1, e1));
    }

    private static String createString(
        long s0, long e0, long s1, long e1)
    {
        StringBuilder sb = new StringBuilder();
        sb.append(createString(s0, e0, "A")).append("\n");
        sb.append(createString(s1, e1, "B"));
        return sb.toString();
    }

    private static String createString(long s, long e, String c)
    {
        StringBuilder sb = new StringBuilder();
        for (int i=0; i<INTERVAL_SIZE; i++)
        {
            if (s < e)
            {
                if (i >= s && i <= e)
                {
                    sb.append(c);
                }
                else
                {
                    sb.append(".");
                }
            }
            else 
            {
                if (i <= e || i >= s)
                {
                    sb.append(c);
                }
                else 
                {
                    sb.append(".");
                }
            }
        }
        return sb.toString();
    }



    public static long findOverlappingInterval(
        long s0, long e0, long s1, long e1)
    {
        return compute(s0, e0+1, s1, e1+1);
    }

    public static long compute(
        long s0, long e0, long s1, long e1)
    {
        if (s0 > e0)
        {
            return 
                compute(s0, INTERVAL_SIZE, s1, e1) +
                compute(0, e0, s1, e1);
        }
        if (s1 > e1)
        {
            return 
                compute(s0, e0, s1, INTERVAL_SIZE) +
                compute(s0, e0, 0, e1);
        }
        return Math.max(0, Math.min(e0, e1) - Math.max(s0, s1));
    }
}

......AAAAAAAAAAAAAAAAAA
..BBBBBBBBBBBBBBBB......
12
AAAAAAAAAAAAA...........
BBB.........BBBBBBBBBBBB
4
AAAAA......AAAAAAAAAAAAA
BBBB........BBBBBBBBBBBB
16
AAAAA.......AAAAAAAAAAAA
BBBB.......BBBBBBBBBBBBB
16