Javascript：在数组中查找连续的数字时，请始终使用一个
我正在做一些编码练习，在网上发现了一些问题。 在返回数组中的连续数时，我总是得到比预期值低1个整数Javascript：在数组中查找连续的数字时，请始终使用一个,javascript,arrays,Javascript,Arrays,我正在做一些编码练习，在网上发现了一些问题。 在返回数组中的连续数时，我总是得到比预期值低1个整数 function LongestConsecutive(arr) { arr.sort((a,b) => {return a-b}); let highest = 0; let counter = 0; let prevNum; arr.forEach((num,index,arr) => { if (prevNum === undefined)
function LongestConsecutive(arr) {
arr.sort((a,b) => {return a-b});
let highest = 0;
let counter = 0;
let prevNum;
arr.forEach((num,index,arr) => {
if (prevNum === undefined) {
prevNum = num
} else {
if (num + 1 == arr[index + 1]) {
counter += 1;
highest = Math.max(highest,counter)
} else {
counter = 0;
}
}
})
return highest;
}
例如，输入[5,6,1,2,8,9,7]应该返回5-因为排序时有5个连续的数字。我一直得到一个低于我应该得到的，所以对于这个例子，我得到4。得到正确答案的唯一方法是返回“highest+1”，这显然是在避免问题 第一次迭代将命中
if (prevNum === undefined) {
prevNum = num;
}
function longestConsecutive(arr) { // Non-constructor functions start with a lower-case letter
arr.sort((a, b) => a - b); // Use expression form
let highest = 0;
let counter = 0;
arr.forEach((num, index, arr) => {
if (index === 0) {
highest = 1;
counter = 1;
} else if (num - 1 === arr[index - 1]) { // Merge `else if`, use strict equal
counter += 1;
highest = Math.max(highest, counter);
} else {
counter = 1;
}
});
return highest;
}
第一次迭代将成功
if (prevNum === undefined) {
prevNum = num;
}
function longestConsecutive(arr) { // Non-constructor functions start with a lower-case letter
arr.sort((a, b) => a - b); // Use expression form
let highest = 0;
let counter = 0;
arr.forEach((num, index, arr) => {
if (index === 0) {
highest = 1;
counter = 1;
} else if (num - 1 === arr[index - 1]) { // Merge `else if`, use strict equal
counter += 1;
highest = Math.max(highest, counter);
} else {
counter = 1;
}
});
return highest;
}
根据连续的定义，你总是有一个连续的数字。所以你需要从1开始计数器。好吧，根据连续的定义，你总是有一个连续的数字。因此，您需要从1开始计数器。也可以使用array:reduce实现 函数longestRunarray{ 常量{streak}=数组 .sorta，b=>a-b//按升序排序 .reduce{count，streak}，current，index，arr=>{ 如果当前===arr[索引-1]+1{ count++；//如果比上一个多1，则递增 }否则{ 计数=1；//否则重置为1 } 返回{count，streak:Math.maxstrick，count}； }，{count:0，streak:0}；//对于空数组，初始值为0,0 返回条纹； } console.loglongestRun[]；//0 console.loglongestRun[0]；//1. console.loglongestRun[0,1]；//2. console.loglongestRun[0,1,0]；//2. console.loglongestRun[0,0,0]；//1.
console.loglongestRun[2,0,1,0,3,0]；//4也可以通过数组：reduce实现 函数longestRunarray{ 常量{streak}=数组 .sorta，b=>a-b//按升序排序 .reduce{count，streak}，current，index，arr=>{ 如果当前===arr[索引-1]+1{ count++；//如果比上一个多1，则递增 }否则{ 计数=1；//否则重置为1 } 返回{count，streak:Math.maxstrick，count}； }，{count:0，streak:0}；//对于空数组，初始值为0,0 返回条纹； } console.loglongestRun[]；//0 console.loglongestRun[0]；//1. console.loglongestRun[0,1]；//2. console.loglongestRun[0,1,0]；//2. console.loglongestRun[0,0,0]；//1.
console.loglongestRun[2,0,1,0,3,0]；//4如果可以通过条件将阵列拆分为子阵列，则可以通过在非连续点拆分阵列来实现 常量arr=[5,6,1,2,8,9,7,11,12,13,14] //用于在条件点拆分数组的实用程序 const splitBy=arr，cond=>arr.reducea，cur，i，src=>{ ifcondcur，i，src{ a、 推 } a[a.length-1].pushcur 归还 }, [] const contuitives=splitBy arr.sorta，b=>a-b， cur，i，src=>cur！==src[i-1]+1 .sorta，b=>b.length-a.length //最大的连续列表将是第一个数组
console.logconsuctionives[0].length如果可以通过条件将阵列拆分为子阵列，则可以通过在非连续点拆分阵列来实现 常量arr=[5,6,1,2,8,9,7,11,12,13,14] //用于在条件点拆分数组的实用程序 const splitBy=arr，cond=>arr.reducea，cur，i，src=>{ ifcondcur，i，src{ a、 推 } a[a.length-1].pushcur 归还 }, [] const contuitives=splitBy arr.sorta，b=>a-b， cur，i，src=>cur！==src[i-1]+1 .sorta，b=>b.length-a.length //最大的连续列表将是第一个数组
console.logconcertives[0].length我尝试了这段代码，它与问题中给出预期结果的代码不同。另外，如果有两组连续的 相同和最大长度的ve编号，均打印
var arr = [5, 6, 1, 2, 8, 9, 7, 99, 98];
arr.sort((a, b) => a - b);
var prevNum = arr[0];
var consecutiveNumbersArr = [prevNum];
// Map of consecutiveNumbersArr array as key and
// the array length as values
var arrMap = new Map();
for (let i = 1; i < arr.length; i++) {
let num = arr[i];
if (num === prevNum+1) {
prevNum = num;
consecutiveNumbersArr.push(num);
continue;
}
arrMap.set(consecutiveNumbersArr, consecutiveNumbersArr.length);
consecutiveNumbersArr = [];
consecutiveNumbersArr.push(num);
prevNum = num;
}
arrMap.set(consecutiveNumbersArr, consecutiveNumbersArr.length);
// the largest length of all the consecutive numbers array
var largest = 0;
for (let value of arrMap.values()) {
if (value > largest) {
largest = value;
}
}
// print the result - the largest consecutive array
for (let [key, value] of arrMap) {
if (value === largest) {
console.log("RESULT: " + key);
}
}
我尝试了这段代码，它与问题中给出预期结果的代码不同。此外，如果有两组长度相同且最大的连续数字，则会同时打印这两组数字
var arr = [5, 6, 1, 2, 8, 9, 7, 99, 98];
arr.sort((a, b) => a - b);
var prevNum = arr[0];
var consecutiveNumbersArr = [prevNum];
// Map of consecutiveNumbersArr array as key and
// the array length as values
var arrMap = new Map();
for (let i = 1; i < arr.length; i++) {
let num = arr[i];
if (num === prevNum+1) {
prevNum = num;
consecutiveNumbersArr.push(num);
continue;
}
arrMap.set(consecutiveNumbersArr, consecutiveNumbersArr.length);
consecutiveNumbersArr = [];
consecutiveNumbersArr.push(num);
prevNum = num;
}
arrMap.set(consecutiveNumbersArr, consecutiveNumbersArr.length);
// the largest length of all the consecutive numbers array
var largest = 0;
for (let value of arrMap.values()) {
if (value > largest) {
largest = value;
}
}
// print the result - the largest consecutive array
for (let [key, value] of arrMap) {
if (value === largest) {
console.log("RESULT: " + key);
}
}
1和2也是连续的数字。你如何解决这个问题？或者问题是大多数数字都是连续数字吗？1和2也是连续数字。你如何解决这个问题？或者问题是连续数字和大多数数字是一致的吗？啊，达普，我完全不理解OP的连续性是什么意思，也解释了排序，我想知道的是。。。修正。啊，达普，我完全不理解OP所指的连续，也解释了排序，我想知道。。。fixing.actually@Xufox，你所说的：arr.sorta，b=>a-b；//是什么意思使用表达式形式-为什么是这种方式而不是返回方式？@RaymonOpie它更短更干净。@RaymonOpie返回实际上是@Xufox，你所说的：arr.sorta，b=>a-b；//使用表达式形式-为什么是这种方式而不是返回方式？@RaymonOpie它更短更干净。@RaymonOpie返回是隐式的我真的很喜欢简洁，这太棒了，但是如果在数组中稍后发生连续运行，它就不能正常工作。例如[5,6,1,2,8,9,7,11,12,13,14]应该为[5,6,7,8,9]返回5，但为[11,12,13,14]返回4。啊，鬼鬼祟祟的鬼鬼祟祟，我花了太长的时间才意识到你偷了另一种不过现在有点失去了简洁感。是的。试图找到一种按条件拆分数组的好方法。如果你有这个工具，它可以变得非常简洁。我真的很喜欢它的简洁性，这太棒了，但是如果以后在数组中连续运行，它就不能正常工作。例如[5,6,1,2,8,9,7,11,12,13,14]应该为[5,6,7,8,9]返回5，但为[11,12,13,14]返回4。啊，鬼鬼祟祟的鬼鬼祟祟，我花了太长的时间才意识到你偷了另一种不过现在有点失去了简洁感。是的。试图找到一种按条件拆分数组的好方法。如果你有这个实用程序，它可以变得非常简洁。