查找数组中的非连续数字对

Question

给定一个最小长度为3，最大长度为5的数组，它总是包含从0到4的唯一出现的整数，按照升序，我需要挑出两个不连续的数字。非连续是指它们的数值，而不是它们在数组中的位置。

为了澄清，这里是有效的阵列的示例：

1. [ 1, 2, 3 ]
2. [ 0, 1, 2, 4 ]
3. [ 0, 3, 4 ]

对于上面的阵列，有效的回答可能是，分别为：

1. [ 1, 3 ]
2. [ 0, 2 ]，[ 0, 4 ]或[ 1, 4 ]
3. [ 0, 3 ]或[ 0, 4 ]

此外，在这些情况下，有不止一个有效的答案，我需要它来随意选择，如果可能的话（例如，我不想支持以最低数字开头的序列，这是如果我总是从左到右开始检查并在我找到一个有效解决方案时立即停止检查会发生的情况）。

在Javascript中解决这个问题最有效的方法是什么？

Answer 1

你可以用两个嵌套迭代和建立一个新的数组供选择的随机结果。

function getNonConsecutives(array) { 
 
    return array.reduce((r, a, i, aa) => r.concat(aa.slice(i + 2).map(b => [a, b])), []); 
 
} 
 

 
console.log(getNonConsecutives([ 0, 1, 2, 4 ]));

.as-console-wrapper { max-height: 100% !important; top: 0; }

根据Bee157的answer，你可以使用随机选择一个约束，像长为第一指标，并添加所需的空间，第二个索引。

问题是，由于首先选择第一个数字的性质，结果的分布并不相同。

function getNonConsecutives(array) { 
 
    var i = Math.floor(Math.random() * (array.length - 2)); 
 
    return [ 
 
     array[i], 
 
     array[Math.floor(Math.random() * (array.length - 2 - i)) + 2 + i] 
 
    ]; 
 
} 
 

 
console.log(getNonConsecutives([ 0, 1, 2, 4 ]));

Answer 2

因为您声明数组元素是唯一的，并且它们已被排序。
它应该足以采取随机元素

var index1=Math.floor(Math.random()*arr.length) 

现在任何其他元件（除了可能在以下位置的elemnts（index1之间+/- 1）是不连续的 所以一个新的随机元素可以选择不包括所述第一索引。

var index2=Math.floor(Math.random()*arr.length); 
if(index2==index1){ 
    index2+=((index2<arr.length-1)?1:-1); 
} 
if(Math.abs(arr[index1]-arr[index2])<=1){ 
    if(index2==0 && arr.length<4){ 
    //set index2 to arr.length-1 and do check again, if not ok=> no result 
    if(!(arr[index1]-arr[arr.length-1]>=-1)){ 
     return [arr[arr.length-1],arr[index1]]; 
    } 
    } 
    else if(index2==arr.length-1 && arr.length<4){ 
    //set index2 to 0 and do check again, if not ok=> no result 
    if(!(arr[index1]-arr[0]<=1)){ 
     return [arr[0],arr[index1]]; 
    } 
    } 
    else{ 
    //if index2>index1 index2++ 
    //else index2-- 
    //always OK so no further check needed 
    index2+=(index2>index1?1:-1); 
    return [arr[index1],arr[index2]]; 
    } 
} 
else{ 
    //ok 
    return [arr[index1,arr[index2]]; 
} 
return false; 

如果速度并不重要，可以使用过滤器的阵列上，以计算与所有元件在不同的ARR [index1之间的更多然后1个单位的新数组。并从该随机选择一个新的数新阵列。

其他企图

function getNonConsecutive(arr){ 
    var index1,index2,arr2; 
    index1=Math.floor(Math.random()*arr.length); 
    arr2=[].concat(arr); 
    arr2.splice((index1!==0?index1-1:index1),(index!==0?3:2)); 
    if(arr2.length){ 
    index2=Math.floor(Math.random()*arr2.length); 
    return [arr[index1],arr2[index2]]; 
    } 
    else{ 
    //original array has length 3 or less 
    arr2=[].concat(arr); 
    arr2.splice(index1),1); 
    for (var j=0,len=arr.length;j<len;j++){ 
     if(Math.abs(arr1[index1]-arr2[j])>1){ 
     return [arr[index1],arr2[j]]; 
     } 
    } 
    } 
return false 
} 

Answer 3

像这样的东西应该这样做：

const pick = nums => { 
    // Pick a random number 
    const val = nums[Math.floor(Math.random() * nums.length) + 0]; 
    // Filter out any numbers that are numerically consecutive 
    const pool = nums.filter(n => Math.abs(n - val) > 1); 
    // Pick another random number from the remainer 
    const other = pool[Math.floor(Math.random() * pool.length) + 0]; 
    // Sort + return them 
    return [val, other].sort(); 
}; 
console.log(pick([0, 1, 2, 4])); 

Answer 4

demoFn(array) { 
    var i,j, y =[]; 
    for (i=0; i<=array.length;i++) { 
     for (j = i + 1; j <= array.length; j++) { 
      if (array[j] && array[i]) { 
       if (array[j] !== array[i] + 1) { 
        y.push([array[i], array[j]]); 
       } 
      } 
     } 
    } 

}

采取随机排列，并检查它。

Answer 5

您可以使用递归创建一个函数，该函数将在每次迭代中选择随机数并循环所有其他元素，并且如果满足条件，则添加到数组中。

function findN(data) { 
 
    data = data.slice(); 
 
    var r = [] 
 

 
    function repeat(data) { 
 
    if (data.length < 2) return r; 
 
    var n = parseInt(Math.random() * data.length); 
 

 
    data.forEach(function(e, i) { 
 
     if (i != n) { 
 
     var a = data[n]; 
 
     if (Math.abs(a - e) != 1 && r.length < 2) r.push(n < i ? [a, e] : [e, a]) 
 
     } 
 
    }) 
 

 
    data.splice(n, 1); 
 
    repeat(data) 
 
    return r; 
 
    } 
 

 
    return repeat(data) 
 
} 
 

 
console.log(findN([1, 2, 3])) 
 
console.log(findN([0, 1, 2, 4])) 
 
console.log(findN([0, 3, 4]))