Jeśli masz tablicę zawierającą nieokreśloną ilość tablicJak znaleźć najdłuższy tablicę w tablicę tablic w JavaScript
ex:
var masterArray = [ [1,2,3,4,5],
[1,2],
[1,1,1,1,2,2,2,2,4,4],
[1,2,3,4,5] ];
Jaki jest skuteczny sposób, aby znaleźć indeks najdłuższa tablica w masterArray? (w tym przykładzie indeks będzie wynosił 2).
var masterArray = [ [1,2,3,4,5],
[1,2],
[1,1,1,1,2,2,2,2,4,4],
[1,2,3,4,5] ];
One-liner jest:
masterArray.map(function(a){return a.length;}).indexOf(Math.max.apply(Math, masterArray.map(function(a){return a.length;})));
Ale lepiej buforować map wyników.
var lengths = masterArray.map(function(a){return a.length;});
lengths.indexOf(Math.max.apply(Math, lengths));
Uwaga, jeszcze kod iteracji tablicy 3 razy (map, max, indexOf oddzielnie).
Dla bardziej wydajnego powinieneś ręcznie iterować tablicę.
var max = -Infinity;
var index = -1;
masterArray.forEach(function(a, i){
if (a.length>max) {
max = a.length;
index = i;
}
});
Reduce Metoda:
masterArray.reduce(function(maxI,el,i,arr) {return el.length>arr[maxI].length ? i : maxI;}, 0)
masterArray.reduce(function(a,i,ii){
if (ii === 1){
return a
};
if (i.length > a.length){
return i
}
return a
})Zwraca najdłuższą tablicę, a nie jej indeks. –
Lazy underscore.js podejście:
_.max(masterArray, function(i){ return i.length; })
Powoduje, że zwraca najdłuższą długość, a nie indeks. –
Właściwie zwraca samą pod-tablicę. Odsunęło to pytanie trochę. – djvs
Można iteracyjne nad wszystkie wpisy na zewnętrznej macierzy przy użyciu for pętlę i porównać długość każdego z jego elementów, które najdłużej tablica, którą dotychczas znalazłeś.
Następująca funkcja zwraca indeks najdłuższej tablicy lub -1, jeśli tablica jest pusta.
function indexOfLongest(arrays) {
var longest = -1;
for (var i = 0; i < arrays.length; i++) {
if (longest == -1 || arrays[i].length > arrays[longest].length) {
longest = i;
}
}
return longest;
}
var masterArray = [ [1,2,3,4,5],
[1,2],
[1,1,1,1,2,2,2,2,4,4],
[1,2,3,4,5] ];
document.write(indexOfLongest(masterArray));Użyj while pętli
var masterArray = [
[1, 2, 3, 4, 5],
[1, 2],
[1, 1, 1, 1, 2, 2, 2, 2, 4, 4],
[1, 2, 3, 4, 5]
];
var i = 0, len = masterArray.length;
while (i < len) {
// if array[i + 1] exists
// and array[i + 1] length greater than array[i] length
// and i + 1 equals array length - 1
// break
if (masterArray[i + 1]
&& masterArray[i + 1].length < masterArray[i].length
&& i + 1 === len - 1) {
break
}
// else increment i
else {
++i
}
}
console.log(masterArray[i])U sing lodash:
_.max(_.map(masterArray, function(v, k) { return { id: k, size: v.length }; }),'size').id;
tworzy nowy układ z obiektami o „id” i „L”, a następnie stwierdza się maksymalną wielkość w tej tablicy i zwraca jej „identyfikator”.
Bardziej podoba mi się rozwiązanie @ Downgoat. –
.reduce jest najpiękniejszy sposób, aby to zrobić:
masterArray.reduce(function (pending, cur, index, ar) { ar[ pending ].length > cur.length ? index: pending }, 0);
Albo z ES6:
masterArray.reduce((p, c, i, a) => a[p].length > c.length ? i : p, 0);
posortować listę indeksów według długości w kolejności malejącej, i weź pierwszy:
a.map((e, i) => i) . sort((i, j) => a[j].length - a[i].length) [0]
skuteczny w jaki sposób? –
Powinienem był to wyjaśnić. Chciałem tylko w zwięzły sposób, nic o efektywności pamięci – jmancherje