查找數組中最長的相同數字出現

Question

使用JavaScript，我試圖找到一種方法來查找數組中最長出現的相同數字（本例中爲1）。

例如，這裏有一個樣品陣列： [2,5,3,1,1,1,3,7,9,6,4,1,1,1,1,1,4,7,2,3,1,1,4,3]

我想寫，將返回「5」的功能，因爲數字1連續出現5次。 （它也連續發生3次和2次，但是我發生的時間最長）。

到目前爲止，我已經寫了：

function streak(arr) { 
    var i, 
     temp, 
     streak, 
     length = arr.length; 

    for(i=0; i<length; i++) { 
     if (arr[i] === 1) { 
      streak += 1; 
     } else { 
      temp = streak; 
      break; 
     } 
    } 
} 

我知道我需要知道在哪裏我離開，如果我找到一個發生的一些方式，但我感到有點卡住。

任何指針？

Answer 1

我已經稍微修改了你的函數。您需要將最高的條紋作爲當前條紋的單獨變量進行存儲，並在必要時覆蓋循環中的內容 - 最後在函數結束時返回該變量。

function streak(arr) { 
    var i, 
     temp, 
     streak, 
     length = arr.length, 
     highestStreak = 0; 

    for(i = 0; i < length; i++) { 
     // check the value of the current entry against the last 
     if(temp != '' && temp == arr[i]) { 
      // it's a match 
      streak++; 
     } else { 
      // it's not a match, start streak from 1 
      streak = 1; 
     } 

     // set current letter for next time 
     temp = arr[i]; 

     // set the master streak var 
     if(streak > highestStreak) { 
      highestStreak = streak; 
     } 
    } 

    return highestStreak; 
} 

var array = [2,5,3,1,1,1,3,7,9,6,4,1,1,1,1,1,4,7,2,3,1,1,4,3]; 

console.log(streak(array)); // 5 

如果你也想跟蹤一下最高連勝的值是，在你的函數開始定義另一個變量，保存它的價值，當你保存的最高紀錄，並返回作爲數組：

// set the master streak var 
    if(streak > highestStreak) { 
     highestStreakValue = temp; 
     highestStreak = streak; 
    } 
} 

return [highestStreak, highestStreakValue]; 


var array = [2,5,3,1,1,1,3,7,9,6,4,'a','a','a','a','a',4,7,2,3,1,1,4,3]; 
console.log(streak(array)); // [5, "a"] 

Demo returning both

Answer 2

這裏有一個辦法做到這一點：

var values = function(obj) { 
    var res = []; 
    for (var i in obj) { 
    if (obj.hasOwnProperty(i)) { 
     res.push(obj[i]); 
    } 
    } 
    return res; 
}; 

var countStreak = function(xs) { 
    var res = xs.reduce(function(acc, x, i) { 
    if (x === xs[i+1]) { 
     acc[x] = acc[x]+1 || 2; 
    } else { 
     acc[x] = acc[x]-1 || 0; 
    } 
    return acc; 
    },{}) 
    return Math.max.apply(0, values(res)); 
}; 

var ns = [2,5,3,1,1,1,3,7,9,6,4,1,1,1,1,1,4,7,2,3,1,1,4,3] 
countStreak(ns) //=> 5 

Answer 3

您的問題：

• 你沒有保存當前的連勝
• 不指定時streak更多的則是較舊的條紋

使用此：

function streak(arr) { 
    var i, 
     temp, 
     streak = 1, 
     maxStreak = 0, 
     prevNumber, 
     length = arr.length; 

    for(i=1; i<length; i++) { 
     prevNumber = arr[i-1]; 
     if (arr[i] == prevNumber) { 
      streak += 1; 
     } else { 
      if(streak > maxStreak) { 
       maxStreak = streak; 
       streak = 1; 
      } 
     } 
    } 
    return maxStreak; 
} 

Demo

Answer 4

這裏你需要另外兩個數組。從源陣列使用循環

1. 商店不同數字撥打第二組陣列中的哪一個等於所述第一組陣列，其具有的不同數字的長度。
2. 使循環等於第一組數組的長度，然後根據其索引將值推送到第二組數組。
3. 做一個循環再次使用第二組陣列，並在那裏你會發現使用第二個數組的索引
4. 最後最爲出現時從第一組數字數組獲取使用從第4步得到的指數。

我並沒有使代碼爲你自己先試試吧，因爲你只是要求一些指針

Answer 5

另一種方法。我將數組轉換爲字符串。正則表達式有一個backrefence，它確保只有相同字符的序列匹配。同樣當exec與g標誌一起使用時，重複執行將從上次匹配結束開始繼續，而不是從開始開始。

var arr = [2,5,3,1,1,1,3,7,9,6,4,1,1,1,1,1,4,7,2,3,1,1,4,3]; 
var str = arr.join(''); 
var regex = /(.)\1*/g; 
var match; 
var largest = ''; 

while (match = regex.exec(str)) { 
    largest = match[0].length > largest.length ? match[0] : largest; 
} 

console.log(largest.length); 

Answer 6

我的建議：

function getLongestRow(inputArray) { 
    // Initialize dummy variables 
    var start = inputArray[0], curRowLen = 0, maxRowLen = 0, maxRowEle = 0; 

    // Run through the array 
    for(var i = 0;i < inputArray.length;i++) { 
     // If current Element does not belong to current row 
     if(inputArray[i] != start) { 
      // If current row is longer than previous rows, save as new longest row 
      if(curRowLen > maxRowLen) { 
       maxRowLen = curRowLen; 
       maxRowEle = start; 
       curRowLen = 1; 
      } 
      // Start new row 
      start = inputArray[i]; 
     } else { 
      // Current element does belongt to current row, increase length 
      curRowLen++; 
     } 
    } 

    // Check whether last row was longer than previous rows 
    if(curRowLen > maxRowLen) { 
     maxRowLen = curRowLen; 
     maxRowEle = start; 
    } 

    // Return longest row & element longest row consits of 
    console.log('The longest row in your array consists of '+maxRowLen+' elements of '+maxRowEle+'.'); 
} 

的jsfiddle：http://jsfiddle.net/hdwp5/

Answer 7

您可以通過從一個給定的指標， 所有比賽前瞻和跳躍前進到下一個不匹配的使用較少的迭代項目的索引。

如果剩餘的物品少於您找到的最大物品，您也可以退出。

function maxRepeats(arr){ 
    var L= arr.length, i= 0, 
    max= 1, count= 0; 
    while(L-i > max){ 
     while(arr[i+count]=== arr[i])++count; 
     if(count > max) max= count; 
     i+= count; 
     count= 0; 
    } 
    return max; 
} 
var A= [2, 5, 3, 1, 1, 1, 3, 7, 9, 6, 4, 1, 
1, 1, 1, 1, 4, 7, 2, 3, 1, 1, 4, 3]; 

maxRepeats（A）;返回5

找到重複最大次數的多個項目並不容易，因爲您必須在列出它們之前找到最大數量，因此不容易， 。 如果你真的只需要最大數量，忽略了這一點：

function mostRepeats(arr, maximum){ 
    var i= 0, max= maximum || 1, 
    L= arr.length-max, 
    count= 0, index= []; 
    while(i<L){ 
     while(arr[i+count]=== arr[i])++count; 
     if(count=== maximum) index.push(arr[i]+' starting at #'+i); 
     else if(count > max) max= count; 
     i+= count; 
     count= 0; 
    } 
    if(max===1) return 'No repeats'; 
    return maximum? max+' repeats of: '+index.join(', '): mostRepeats(arr, max); 
} 

var A= [2, 5, 3, 1, 1, 1, 3, 7, 9, 6, 4, 1, 1, 1, 
1, 1, 4, 7, 2, 3, 3, 3, 3, 3, 1, 1, 4, 3]; 

mostRepeats（A）;返回：

重複5次：1開始在＃11，3日起在＃19

Answer 8

不幸的是，我不能評論，因爲缺乏聲譽，所以我會張貼這個答案。對於我的任務Robbie Averill's solution是完美的，但它包含一個小錯誤。我的數組由2個值組成 - 0 & 1.5，但上面提到的代碼只計算「1.5」值，儘管我的「0」在較高的連續條件下重複。問題是，價值沒有做嚴格比較的位置：

if(temp != '' && temp == arr[i]) { 

和修復很簡單：if(temp !== '' && temp == arr[i]) {

我已經更新了羅比的jsfiddler與此修復程序：http://jsfiddle.net/d5X2k/5/

Answer 9

替代方案：使用正則表達式和將數組轉換爲字符串。

var arr = [2,5,3,1,1,1,3,7,9,6,4,1,1,1,1,1,4,7,2,3,1,1,4,3]; 
var str = arr.join('').match(/1+/g); 
console.log(process ? process.sort().pop() : "No ocurrences"); 

Answer 10

不幸的是，一個問題已被標記爲重複，但它不是這個一樣。所以，我必須在這裏把我的回答，對不起......

let tab = [0,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,1] 
 
    , arr = [] 
 
    , n = 0 
 
    , res = null ; 
 

 
for(let i of tab) 
 
{ 
 
    if (i) { ++ n } 
 
    else if (n) { arr.push(n) ; n = 0 } 
 
} 
 
arr.push(n) ; 
 

 
res = Math.max(...arr); 
 

 
console.log("Streak with 1 is ", Math.max(...arr));

這比減少更好的解決方案，更慢，因爲你可以看到：

let tab = [0,0,0,1,1,1,0,0,0,0,1,0,1,1,1,1,1]; 
 
let arr = []; 
 
let n = 0; 
 
let res = null; 
 

 
let loop = 0; 
 
let start = new Date().getTime(); 
 

 
while (loop < 1000000){ 
 
    ++ loop; 
 
    
 
    arr = []; 
 
    for(let i of tab) 
 
    { 
 
     if (i) { ++ n } 
 
     else if (n) { arr.push(n) ; n = 0 } 
 
    } 
 
    arr.push(n); 
 
    res = Math.max(...arr); 
 
} 
 
let end = new Date().getTime(); 
 
console.log("laps old fashion = ", end - start); 
 

 
loop = 0; 
 
let streaks = null; 
 
start = new Date().getTime(); 
 
while (loop < 1000000){ 
 
    ++ loop; 
 
    streaks = tab.reduce((res, n) => 
 
    (n ? res[res.length-1]++ : res.push(0), res) 
 
    , [0]); 
 
    res = Math.max(...streaks); 
 
} 
 
end = new Date().getTime(); 
 
console.log("laps reduce = ", end - start); 
 

 
console.log("Streak with 1 is ", Math.max(...arr));

Answer 11

你可以拿Array#reduce並返回實際相同項目的開始索引sequ ENCE。然後檢查並更新計數器，如果項目不相等。

var array = [2, 5, 3, 1, 1, 1, 3, 7, 9, 6, 4, 1, 1, 1, 1, 1, 4, 7, 2, 3, 1, 1, 4, 3], 
 
    maxCount = 0, 
 
    maxValues; 
 

 
array.reduce(function (j, a, i, aa) { 
 
    if (aa[j] === a) { 
 
     return j; 
 
    } 
 
    if (i - j === maxCount){ 
 
     maxValues.push(aa[j]); 
 
    }    
 
    if (i - j > maxCount) { 
 
     maxCount = i - j; 
 
     maxValues = [aa[j]]; 
 
    } 
 
    return i; 
 
}, -1); 
 

 
console.log(maxCount); 
 
console.log(maxValues);