求助，如何判断用户输入的区间不重复

Question

如图，每一行就是一个区间，行数不确定
判断用户输入的区间不重复才能提交成功，不填就是默认的最大和最小
可以选择包含或不包含对应的值，想得头都大了（T_T）

Answer 1

不给出代码，不知道你的数据是什么结构的，不过没事，你看我下面的代码吧！

function checkArr(arr){
    //排序
    arr.sort(function(n1,n2){return n1.min-n2.min})
    //遍历
    for(var i=0;i<arr.length;i++){
        //区间的最小值不能大于等于区间的最大值
        if(arr[i].min>=arr[i].max){
            console.log('区间最大值最小值不能相等');
            return;
        }
        //元素对比，从第二个元素开始
        if(i>0){
            //区间不能出现交叉的情况  比如：5-10  6-12    这样就会导致 6，7，8，9，10这几值就会两个区间都在其中
            if(arr[i].min<arr[i-1].max){
                console.log('区间不能出现交叉情况');
                return;
            }
        }
    }
}

下面准备些测试数据

var arr1=[{min:1,max:10},{min:5,max:22},{min:5,max:22}],
arr2=[{min:1,max:1},{min:1,max:22},{min:22,max:26}],
arr3=[{min:1,max:10},{min:20,max:30},{min:30,max:40}];   

测试通过，可能看到函数会有疑问，为什么数组要排序，其实看下面实例。

var arr4=[{min:30,max:40},{min:20,max:30},{min:10,max:20}]  

这个数据，区间范围也没有交叉，只是反过来写了，所以，为了避免这个情况，所以就要先对数组进行排序

看玩应该都懂了，我这里模拟的数据，数组的每一个对象，其实就等同于你的每一行的数据。

细节优化

当然如果想首尾相连，或者区间的最大值不能大于默认的最大值，区间的最小值也不能小于默认的最小值，只需要多判断几次！下面看代码吧，容易理解些

var _min=5,_max=50;
function checkArr(arr,min,max){
    //排序
    arr.sort(function(n1,n2){return n1.min-n2.min})
    //遍历
    for(var i=0;i<arr.length;i++){
        //区间的最小值不能大于等于区间最大值
        if(arr[i].min>=arr[i].max){
            console.log('区间的最小值不能大于等于区间最大值');
            return;
        }
        //区间的最小值不能小于默认最小值
        if(arr[i].min<min){
            console.log('区间的最小值不能小于默认最小值');
            return;
        }
                    
        //区间的最大值不能大于默认最大值
        if(arr[i].max>max){
            console.log('区间的最大值不能大于默认最大值');
            return;
        }
        //元素对比，从第二个元素开始
        if(i>0){
            //区间首尾是否相连（连续 1-10 10-20）。只要区间相连，不会出现区间相差
            if(arr[i].min!==arr[i-1].max){
                console.log('区间必须要相连');
                    return;
            }
        }
    }
}

至于你说的包含情况，我改了下，代码如下，看着就懂了

var _min=5,_max=50;
function checkArr(arr,min,max){
    //排序
    arr.sort(function(n1,n2){return n1.min-n2.min})
    //遍历
    for(var i=0;i<arr.length;i++){
        //区间的最小值不能大于等于区间最大值
        if(arr[i].min>=arr[i].max){
            console.log('区间的最小值不能大于等于区间最大值');
            return;
        }
        //区间的最小值不能小于默认最小值
        if(arr[i].min<min){
            console.log('区间的最小值不能小于默认最小值');
            return;
        }
                    
        //区间的最大值不能大于默认最大值
        if(arr[i].max>max){
            console.log('区间的最大值不能大于默认最大值');
            return;
        }
        //元素对比，从第二个元素开始
        if(i>0){
            //如果前一个的最大值和当前的最小值都是闭区间，那么当前的最小值一定要大于前一个的最大值（如果要求首尾相连，当前的最小值一定比前一个的最大值大1）
            if(arr[i].minInclude&&arr[i-1].maxInclude&&arr[i].min-arr[i-1].max<=0){
                console.log('取值范围错误');
                   return;
                
            }
            //如果前一个的最大值和当前的最小值。一个是开区间，一个是闭区间，那么后一个的的最小值一定要等于当前的最大值
            else if(arr[i].minInclude!==arr[i-1].maxInclude&&arr[i].min!==arr[i-1].max){
                console.log('取值范围错误');
                   return;
            }
            //如果前一个的最大值和当前的最小值都是开区间，那么那么当前的最小值一定要大于等于前一个的最大值（如过是首尾相连，这种情况，肯定不满足条件）
            else if((!arr[i].minInclude)&&(!arr[i-1].maxInclude)&&arr[i].min-arr[i-1].max<0){
                console.log('取值范围错误');
                   return;
            }
        }
    }
} 
//前一个和后一个都是闭区间
var arr9=[{min:10,max:20,minInclude:false,maxInclude:true},{min:21,max:30,minInclude:true,maxInclude:true}]  

//前一个和当前都是闭区间，但是前一个的最大值和后一个的最小值相等
var arr10=[{min:10,max:20,minInclude:false,maxInclude:true},{min:20,max:30,minInclude:true,maxInclude:false}] 

//前一个的最大值和当前的最小值，一个是闭区间，一个是开区间
var arr11=[{min:10,max:20,minInclude:false,maxInclude:true},{min:20,max:30,minInclude:false,maxInclude:false}]
var arr12=[{min:10,max:20,minInclude:false,maxInclude:false},{min:20,max:30,minInclude:true,maxInclude:false}]  

//前一个的最大值和当前的最小值，一个是闭区间，一个是开区间，但是前一个的最大值和当前的最小值不想等
 var arr14=[{min:10,max:20,minInclude:false,maxInclude:false},{min:21,max:30,minInclude:true,maxInclude:false}] 

 //前一个的最大值和当前的最小值，都是开区间，但是当前的最小值小于前一个的最大值
 var arr15=[{min:10,max:20,minInclude:false,maxInclude:false},{min:15,max:30,minInclude:false,maxInclude:false}]

 //前一个的最大值和当前的最小值，都是开区间。前一个的最大值等于当前的最小值
 var arr16=[{min:10,max:20,minInclude:false,maxInclude:false},{min:20,max:30,minInclude:false,maxInclude:false}]

Answer 2

var source = [
    {
        min: {include: false, value: 10},
        max: {include: true, value: 20}
    },
    ...
]

类似这样的数据结构，再判断一下是否重复就行吧。

挨个从source中进行判断，相当于判断两条线段是否重复了。比如两条线段A、B。如果A.max <(=) B.min || A.min >(=) B.max。则这两条线就是不重复的。

Answer 3

看了一下是不是可以用一个二维数组解决：

(function(arr){
  for(let i=0;i<arr.length;i++){
    if(arr[i][0] > arr[i][1]) return false;
    if(arr[i+1] && arr[i][1] > arr[i+1][0]) return false;
  }
  return true;
})([[1,2],[3,4],[7,9]])

这个函数执行结果就是根据是否有重复的区间，如果有就返回false如果没有就返回ture。
至于包含不包含，就在于你如何初始化这个二维数组了。