¿Cómo encontrar el máximo/mínimo de una matriz anidada en javascript?

Question

Quiero encontrar el máximo de una matriz anidada, algo como esto:

a = [[1,2],[20,3]] 
d3.max(d3.max(a)) // 20 

pero mi matriz contiene un campo de texto que quiero descartar:

a = [["yz",1,2],["xy",20,3]] 
d3.max(a) // 20 

Answer 1

Si tiene una matriz anidada de números (arrays = [[1, 2], [20, 3]]), nido d3.max:

var max = d3.max(arrays, function(array) { 
    return d3.max(array); 
}); 

o equivalentemente, utilice :

var max = d3.max(arrays.map(function(array) { 
    return d3.max(array); 
})); 

Si desea ignorar s Tring valores, puede utilizar array.filter ignorar cadenas:

var max = d3.max(arrays, function(array) { 
    return d3.max(array.filter(function(value) { 
    return typeof value === "number"; 
    })); 
}); 

Alternativamente, si conoce la cadena siempre está en la primera posición, se puede usar array.slice que es un poco más eficiente:

var max = d3.max(arrays, function(array) { 
    return d3.max(array.slice(1)); 
}); 

Otra opción más es usar una función de acceso que devuelve NaN para valores que no son números. Esto hará que d3.max ignore esos valores. Convenientemente, JavaScript incorporado en Number función hace exactamente esto, por lo que puede decir:

var max = d3.max(arrays, function(array) { 
    return d3.max(array, Number); 
}); 

Answer 2

Es un truco cruel, pero mirando el source code para d3.max, su mejor opción podría ser definir un d3.max1 que descarte el primer elemento copiando ese código, pero reemplazando i=-1 con i=0. El código en ese enlace se extrae aquí. Tenga en cuenta que no soy un usuario regular de d3.js, pero por lo que sé de la biblioteca, querrá asegurarse de que su versión tenga un estuche f.call como lo hace esta función, para que pueda responder a las actualizaciones en vivo correctamente. .

d3.max = function(array, f) { 
    var i = -1, 
     n = array.length, 
     a, 
     b; 
    if (arguments.length === 1) { 
    while (++i < n && ((a = array[i]) == null || a != a)) a = undefined; 
    while (++i < n) if ((b = array[i]) != null && b > a) a = b; 
    } else { 
    while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined; 
    while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b; 
    } 
    return a; 
}; 

Entonces sería d3.max(d3.max1(a)).

Answer 3

Utilice esta:

function arrmax(arrs) { 
    var toplevel = []; 

    var f = function(v) { 
     return !isNaN(v); 
    }; 

    for (var i = 0, l = arrs.length; i<l; i++) { 
     toplevel.push(Math.max.apply(window, arrs[i].filter(f))); 
    } 
    return Math.max.apply(window, toplevel); 
} 

o mejor:

function arrmax(arrs) { 
    if (!arrs || !arrs.length) return undefined; 
    var max = Math.max.apply(window, arrs[0]), m, 
     f = function(v){ return !isNaN(v); }; 
    for (var i = 1, l = arrs.length; i<l; i++) { 
     if ((m = Math.max.apply(window, arrs[i].filter(f)))>max) max=m; 
    } 
    return max; 
} 

Ver MDN para Array.filter detalles del método.

Answer 4

Puede acoplar una matriz y aplicar una función a cada miembro

Array.prototype.flatten= function(fun){ 
    if(typeof fun!= 'function') fun= ''; 
    var A= [], L= this.length, itm; 
    for(var i= 0; i<L; i++){ 
     itm= this[i]; 
     if(itm!= undefined){ 
      if(!itm.flatten){ 
       if(fun) itm= fun(itm); 
       if(itm) A.push(itm); 
      } 
      else A= A.concat(itm.flatten(fun)); 
     } 
    } 
    return A; 
} 

var a= [["yz", 1, 2], ["xy", 20, 3]], max=-Infinity; 

var max=Math.max.apply(a, a.flatten(Number)); 

Answer 5

Si ahora exactamente qué columnas desea probar, puede utilizar:

var columns = ["ColumnA", "ColumnB", "ColumnC"]; 

var max = selectedMax(columns,dataset); 
var min = selectedMin(columns,dataset) 

function selectedMax(columns, dataset) { 
    var max; 
    columns.forEach(function(element, index, array) { 
     var tmpmax = d3.max(dataset, function(d) { 
      return +d[element]; 
     });  
     max = (tmpmax > max || max === undefined) ? tmpmax : max; 
    }); 
    return max; 
} 

function selectedMin(columns, dataset) { 
    var min; 
    columns.forEach(function(element, index, array) { 
     var tmpmin = d3.min(dataset, function(d) { 
      return +d[element]; 
     }); 
     min = (tmpmin < min || min === undefined) ? tmpmin : min; 
    }); 
return min; 
}