Estoy tratando de recorrer una lista de coordenadas y determinar su distancia al origen (0,0). Por ejemplo, la matriz de pares [[1,3],[-2,2]] debería producir 3.162 y 2.828 respectivamente como resultado.

Creé un bucle for bidimensional para extraer cada coordenada. Luego llamé a una función calcHypotenuse() para elevar los números al cuadrado y sumarlos para obtener distancias.

Sin embargo, cuando presiono los resultados de cada hipotenusa y los devuelvo, obtengo un resultado mixto. Obtengo 4.52 y 2.82. Por alguna razón, 2.82 es la salida correcta para el segundo par de coordenadas, pero el primer par de coordenadas no lo es.

NOTA: Ignore k. No tiene relevancia pertinente para el problema de encontrar la distancia al origen.

function kClosest(points, k) {
    let length = [];
    let a = 0;
    let b = 0;

    for (let i = 0; i < points.length; i++) {
        for (let j = 0; j < points.length; j++) {
            a = points[i][j] * points[i][j];
            b = points[i][j + 1] * points[i][j + 1];
            console.log('Squared Cordinates: (' + a + ',' + b + ')')
            length.push(parseFloat(calcHypotenuse(a / 2, b / 2).toFixed(4)))
            break;
        }
    }

    function calcHypotenuse(a, b) {
        return (Math.sqrt((a * a) + (b * b)));
    }
    return length;
}



console.log(kClosest([
    [1, 3],
    [-2, 2]
], K = 1));

Este problema se deriva del código Leet: https://leetcode.com/problems / k-puntos-más-cercanos-al-origen /

1
Tyler Morales 5 feb. 2019 a las 18:19

2 respuestas

La mejor respuesta

Ignorando k como dices, puedes fácilmente obtener distancias al origen (0,0) usando map ():

El método map () crea una nueva matriz con los resultados de llamar a una función proporcionada en cada elemento de la matriz que realiza la llamada.

function calcHypotenuse(a, b)
{
    let hyp = Math.sqrt(Math.pow(a,2) + Math.pow(b,2));
    return Number.parseFloat(hyp.toFixed(4));
}

function getDistancesTo(points, pair)
{
    let [x0, y0] = pair;
    return points.map(([x, y]) => calcHypotenuse(x - x0,y - y0));
}

console.log(getDistancesTo([[1, 3], [-2, 2]], [0, 0]));

También estoy usando desestructuración para decir que un elemento de la matriz es un par [x,y]. Pero tal vez lo entiendas mejor de esta manera:

function getDistances(points, pair)
{
    let x0 = pair[0], y0 = pair[1];
    return points.map(p => calcHypotenuse(p[0] - x0, p[1] - y0));
}
1
Shidersz 5 feb. 2019 a las 16:00

Estás elevando las coordenadas al cuadrado y luego dividiendo el resultado por 2 antes de ponerlo en la función hipotenusa. Además, no necesita un bucle for doble en este caso ya que está iterando a través de cada subarreglo / par una vez. Lo que sugeriría hacer es tener un ciclo que recorra cada par y poner cada par de coordenadas en la función de hipotenusa así,

function kClosest(points, k) {
    let length = [];
    let a = 0;
    let b = 0;

    for (let i = 0; i < points.length; i++) {
        a = points[i][0];
        b = points[i][1];
        length.push(parseFloat(calcHypotenuse(a, b).toFixed(4)))
    }

    function calcHypotenuse(a, b) {
        return (Math.sqrt((a * a) + (b * b)));
    }
    return length;
}
1
Chris Gong 5 feb. 2019 a las 15:36