obtener el número más cercano fuera de la matriz

163

Tengo un número de menos 1000 a más 1000 y tengo una matriz con números. Me gusta esto:

[2, 42, 82, 122, 162, 202, 242, 282, 322, 362]

Quiero que el número que tengo cambie al número más cercano de la matriz.

Por ejemplo, obtengo el 80número que quiero obtener 82.

javascript arrays novato
fuente
2
Imposiblemente simple: dejar de lado una variable x, ir a través de la matriz una por una, comparar icon el número actual en la matriz, si la diferencia entre ella y ies menor que el valor actual en x, establecer xel número de matriz actual. Cuando finaliza, xtiene el número más cercano a ila matriz.
deceze

Respuestas:

208

Versión ES5:

var counts = [4, 9, 15, 6, 2],
  goal = 5;

var closest = counts.reduce(function(prev, curr) {
  return (Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev);
});

console.log(closest);
Expandir fragmento

Joe Grund
fuente
1
La desventaja es que solo funciona si la devolución de llamada de reduce se llama desde el mismo alcance que los vars declarados. Como no puede pasar goalpara reducir, debe hacer referencia a él desde un ámbito global.
7yl4r
55
podría usar una función de orden superior para hacer eso también.
dmp
3
@ 7yl4r o envolverlo en una función? ;)
Dominic
1
@ 7yl4r no realmente ... puedes usar bind para lograr esto ... ---------- // reducer.js function reducer (goal, prev, curr) {return (Math.abs (curr - objetivo) <Math.abs (anterior - objetivo)? curr: anterior); } // main.js var recuentos = [4, 9, 15, 6, 2], objetivo = 5; count.reduce (reducer.bind (nulo, objetivo)); ---------- No sé cómo poner código en los comentarios jajaja.
Mauricio Soares
Esto itera sobre cada elemento que no es óptimo si la lista está ordenada pero está bien para listas pequeñas. Incluso sin una búsqueda binaria, un ciclo podría salir si el siguiente número está más lejos.
Dominic
144

Aquí está el pseudocódigo que debe ser convertible a cualquier lenguaje de procedimiento:

array = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362]
number = 112
print closest (number, array)

def closest (num, arr):
    curr = arr[0]
    foreach val in arr:
        if abs (num - val) < abs (num - curr):
            curr = val
    return curr

Simplemente resuelve las diferencias absolutas entre el número dado y cada elemento de la matriz y le devuelve uno de los que tiene la mínima diferencia.

Para los valores de ejemplo:

number = 112  112  112  112  112  112  112  112  112  112
array  =   2   42   82  122  162  202  242  282  322  362
diff   = 110   70   30   10   50   90  130  170  210  250
                         |
                         +-- one with minimal absolute difference.

Como prueba de concepto, aquí está el código de Python que usé para mostrar esto en acción:

def closest (num, arr):
    curr = arr[0]
    for index in range (len (arr)):
        if abs (num - arr[index]) < abs (num - curr):
            curr = arr[index]
    return curr

array = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362]
number = 112
print closest (number, array)

Y, si realmente lo necesita en Javascript, consulte a continuación un archivo HTML completo que demuestra la función en acción:

<html>
    <head></head>
    <body>
        <script language="javascript">
            function closest (num, arr) {
                var curr = arr[0];
                var diff = Math.abs (num - curr);
                for (var val = 0; val < arr.length; val++) {
                    var newdiff = Math.abs (num - arr[val]);
                    if (newdiff < diff) {
                        diff = newdiff;
                        curr = arr[val];
                    }
                }
                return curr;
            }
            array = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362];
            number = 112;
            alert (closest (number, array));
        </script>
    </body>
</html>

Ahora tenga en cuenta que puede haber margen para mejorar la eficiencia si, por ejemplo, sus elementos de datos están ordenados (eso podría inferirse de los datos de la muestra pero no lo declara explícitamente). Podría, por ejemplo, utilizar una búsqueda binaria para encontrar el elemento más cercano.

También debe tener en cuenta que, a menos que necesite hacerlo muchas veces por segundo, las mejoras de eficiencia serán principalmente imperceptibles a menos que sus conjuntos de datos sean mucho más grandes.

Si no desea intentarlo de esa manera (y puede garantizar la matriz se ordena en orden ascendente), este es un buen punto de partida:

<html>
    <head></head>
    <body>
        <script language="javascript">
            function closest (num, arr) {
                var mid;
                var lo = 0;
                var hi = arr.length - 1;
                while (hi - lo > 1) {
                    mid = Math.floor ((lo + hi) / 2);
                    if (arr[mid] < num) {
                        lo = mid;
                    } else {
                        hi = mid;
                    }
                }
                if (num - arr[lo] <= arr[hi] - num) {
                    return arr[lo];
                }
                return arr[hi];
            }
            array = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362];
            number = 112;
            alert (closest (number, array));
        </script>
    </body>
</html>

Básicamente utiliza el uso de corchetes y la comprobación del valor medio para reducir el espacio de la solución a la mitad para cada iteración, un O(log N)algoritmo clásico , mientras que la búsqueda secuencial anterior fue O(N):

0  1  2   3   4   5   6   7   8   9  <- indexes
2 42 82 122 162 202 242 282 322 362  <- values
L             M                   H  L=0, H=9, M=4, 162 higher, H<-M
L     M       H                      L=0, H=4, M=2, 82 lower/equal, L<-M
      L   M   H                      L=2, H=4, M=3, 122 higher, H<-M
      L   H                          L=2, H=3, difference of 1 so exit
          ^
          |
          H (122-112=10) is closer than L (112-82=30) so choose H

Como se dijo, eso no debería hacer una gran diferencia para los conjuntos de datos pequeños o para cosas que no necesitan ser cegadoramente rápidas, pero es una opción que puede considerar.

paxdiablo
fuente
2
@micha, agregué el código JS equivalente a la respuesta, solo tomó un tiempo cambiar los idiomas de uno al que estaba más acostumbrado: -)
paxdiablo
2
Tiempo de ejecución deficiente para este algoritmo si tiene grandes conjuntos de datos.
ylun.ca
44
@ ylun.ca, dado que no hay una declaración explícita en la pregunta de que los datos están ordenados (el ejemplo está ordenado pero puede ser una coincidencia), no puede obtener una mejor eficiencia que O (n). En cualquier caso, para un conjunto de datos de ese tamaño, la eficiencia es sobre todo irrelevante. Pero su punto es válido, así que agregaré notas a ese efecto para que la respuesta sea más completa.
paxdiablo
1
¡Gracias, desearía poder votar más de una vez! Más respuestas sobre el desbordamiento de la pila deberían tener este tipo de esfuerzo puesto en ellos.
Richard Vanbergen
48

Versión ES6 (2015):

const counts = [4, 9, 15, 6, 2];
const goal = 5;

const output = counts.reduce((prev, curr) => Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev);

console.log(output);
Expandir fragmento

Para la reutilización, puede incluir una función de curry que admita marcadores de posición ( http://ramdajs.com/0.19.1/docs/#curry o https://lodash.com/docs#curry ). Esto le da mucha flexibilidad dependiendo de lo que necesita:

const getClosest = curry((counts, goal) => {
  return counts
    .reduce((prev, curr) => Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev);
});

const closestTo5 = getClosest(_, 5);
const closestTo = getClosest([4, 9, 15, 6, 2]);
Joe Grund
fuente
24

Código de trabajo de la siguiente manera:

var array = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362];

function closest(array, num) {
  var i = 0;
  var minDiff = 1000;
  var ans;
  for (i in array) {
    var m = Math.abs(num - array[i]);
    if (m < minDiff) {
      minDiff = m;
      ans = array[i];
    }
  }
  return ans;
}
console.log(closest(array, 88));
Expandir fragmento

Umesh Patil
fuente
8
Cuantos más, mejor.
Hot Licks
66
Yo diría que esta es una mejor solución porque solo usa JavaScript. La respuesta aceptada usa jQuery, que no se mencionó en la pregunta original, y que otros que miran esta pregunta pueden no estar usando.
Sean the Bean
17

Funciona con matrices sin clasificar.

Si bien se publicaron algunas buenas soluciones aquí, JavaScript es un lenguaje flexible que nos brinda herramientas para resolver un problema de muchas maneras diferentes. Todo se reduce a tu estilo, por supuesto. Si su código es más funcional, encontrará la variación de reducción adecuada, es decir:

  arr.reduce(function (prev, curr) {
    return (Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev);
  });

Sin embargo, algunos pueden encontrar eso difícil de leer, dependiendo de su estilo de codificación. Por lo tanto, propongo una nueva forma de resolver el problema:

  var findClosest = function (x, arr) {
    var indexArr = arr.map(function(k) { return Math.abs(k - x) })
    var min = Math.min.apply(Math, indexArr)
    return arr[indexArr.indexOf(min)]
  }

  findClosest(80, [2, 42, 82, 122, 162, 202, 242, 282, 322, 362]) // Outputs 82

Al contrario de otros enfoques para encontrar el valor mínimo utilizando Math.min.apply, éste no requiere de la matriz de entrada arra clasificar . No necesitamos preocuparnos por los índices ni ordenarlos de antemano.

Explicaré el código línea por línea para mayor claridad:

  1. arr.map(function(k) { return Math.abs(k - x) })Crea una nueva matriz, esencialmente almacenando los valores absolutos de los números dados (número en arr) menos el número de entrada ( x). Luego buscaremos el número más pequeño (que también es el más cercano al número de entrada)
  2. Math.min.apply(Math, indexArr) Esta es una forma legítima de encontrar el número más pequeño en la matriz que acabamos de crear (nada más)
  3. arr[indexArr.indexOf(min)]Esta es quizás la parte más interesante. Hemos encontrado nuestro número más pequeño, pero no estamos seguros de si debemos sumar o restar el número inicial ( x). Eso es porque solíamos Math.abs()encontrar la diferencia. Sin embargo, array.mapcrea (lógicamente) un mapa de la matriz de entrada, manteniendo los índices en el mismo lugar. Por lo tanto, para encontrar el número más cercano, solo devolvemos el índice del mínimo encontrado en la matriz dada indexArr.indexOf(min).

He creado un contenedor que lo demuestra.

Dan Mindru
fuente
1
No lo sé, pero supongo que uno podría tener dudas sobre el rendimiento, ya que esto es prácticamente 3ny es ES5 a pesar de que respondiste en 2016 y otras soluciones están bien, aunque este novato que hizo esta pregunta claramente no era un programador en ese momento.
noob
1
¡Sí, es genial verte aprender! Por cierto, solo hablé de dudas sobre el rendimiento sin argumentar que en realidad funcionó peor, pero ejecuté los números por usted y su O(n)solución realiza alrededor de 100k operaciones / seg menos que @paxdiablo O(log n)en números aleatorios. Cuando se diseña un algoritmo siempre se ordena primero, dicen. (Excepto si sabes lo que estás haciendo y tienes puntos de referencia para respaldarte.)
noob
1
Accesorios para la solución simple. Funciona muy bien para mi caso de uso (no tengo el lujo de tener una matriz previamente ordenada como lo hace noob.)
jaggedsoft
2
Puede hacer que findClosest devuelva una función de devolución de llamada reducida para que sea reutilizable en todas las matrices: const findClosest = goal => (a,b) => Math.abs(a - goal) < Math.abs(b - goal) ? a : b;
Jakob E
1
Ejemplo: [2, 42, 82, 122, 162, 202, 242, 282, 322, 362].reduce(findClosest(80))
Jakob E
11

Para matrices ordenadas (búsqueda lineal)

Todas las respuestas hasta ahora se concentran en buscar en toda la matriz. Teniendo en cuenta que su matriz ya está ordenada y realmente solo desea el número más cercano, esta es probablemente la solución más rápida:

var a = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362];
var target = 90000;

/**
 * Returns the closest number from a sorted array.
 **/
function closest(arr, target) {
  if (!(arr) || arr.length == 0)
    return null;
  if (arr.length == 1)
    return arr[0];

  for (var i = 1; i < arr.length; i++) {
    // As soon as a number bigger than target is found, return the previous or current
    // number depending on which has smaller difference to the target.
    if (arr[i] > target) {
      var p = arr[i - 1];
      var c = arr[i]
      return Math.abs(p - target) < Math.abs(c - target) ? p : c;
    }
  }
  // No number in array is bigger so return the last.
  return arr[arr.length - 1];
}

// Trying it out
console.log(closest(a, target));
Expandir fragmento

Tenga en cuenta que el algoritmo puede mejorarse enormemente, por ejemplo, utilizando un árbol binario.

Hubert Grzeskowiak
fuente
Si bien esta estrategia aquí es buena, tiene varios errores tipográficos. Ejemplo, a[i]o i[0].
Wesley Workman
1
Gracias, @WesleyWorkman. Solo los arreglé. Espero tener todo. Por cierto, también puedes editar las respuestas de otros.
Hubert Grzeskowiak
¿Dónde necesito hacer la corrección en el código respondido arriba para obtener el valor más cercano más alto? Ejemplo: [110, 111, 120, 140, 148, 149, 155, 177, 188, 190] Si busco 150, debería obtener 155, no 149. Lo intenté pero encontré dificultades para resolver esto. Podrias ayudarme por favor. Gracias
user1199842
9

Todas las soluciones están sobredimensionadas.

Es tan simple como:

const needle = 5;
const haystack = [1, 2, 3, 4, 5, 6, 7, 8, 9];

haystack.sort((a, b) => {
  return Math.abs(a - needle) - Math.abs(b - needle);
});

// 5
Gajus
fuente
1
De hecho, mucho más al punto. pero para "obtener el número más cercano fuera de la matriz" aún debe seleccionar el primer elemento de la matriz ordenada.
Shaya Ulman
6

Esta solución utiliza el cuantificador existencial ES5 Array#some, que permite detener la iteración, si se cumple una condición.

Opuesto a Array#reduce, no necesita iterar todos los elementos para un resultado.

Dentro de la devolución de llamada, se toma un absoluto deltaentre el valor buscado y el real itemy se compara con el último delta. Si es mayor o igual, la iteración se detiene, porque todos los demás valores con sus deltas son mayores que el valor real.

Si la deltadevolución de llamada es menor, el elemento real se asigna al resultado y deltase guarda en lastDelta.

Finalmente, se toman valores más pequeños con deltas iguales, como en el siguiente ejemplo de 22, que da como resultado 2.

Si hay una prioridad de valores mayores, la verificación delta debe cambiarse de:

if (delta >= lastDelta) {

a:

if (delta > lastDelta) {
//       ^^^ without equal sign

Esto obtendría con 22el resultado 42(Prioridad de valores mayores).

Esta función necesita valores ordenados en la matriz.

Código con prioridad de valores más pequeños:

function closestValue(array, value) {
    var result,
        lastDelta;

    array.some(function (item) {
        var delta = Math.abs(value - item);
        if (delta >= lastDelta) {
            return true;
        }
        result = item;
        lastDelta = delta;
    });
    return result;
}

var data = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362];

console.log(21, closestValue(data, 21)); // 2
console.log(22, closestValue(data, 22)); // 2  smaller value
console.log(23, closestValue(data, 23)); // 42
console.log(80, closestValue(data, 80)); // 82
Expandir fragmento

Código con prioridad de valores mayores:

function closestValue(array, value) {
    var result,
        lastDelta;

    array.some(function (item) {
        var delta = Math.abs(value - item);
        if (delta > lastDelta) {
            return true;
        }
        result = item;
        lastDelta = delta;
    });
    return result;
}

var data = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362];

console.log(21, closestValue(data, 21)); //  2
console.log(22, closestValue(data, 22)); // 42 greater value
console.log(23, closestValue(data, 23)); // 42
console.log(80, closestValue(data, 80)); // 82
Expandir fragmento

Nina Scholz
fuente
Entonces asumes que la matriz dada está ordenada ... Eso te ahorra muchísimo tiempo.
Reducido
1
la matriz de operaciones parece ordenada, así que sí :)
Nina Scholz
La primera solución se rompe en las entradas que contienen el mismo número dos veces. por ejemploclosestValue([ 2, 2, 42, 80 ], 50) === 2
Sébastien Vercammen
@ SébastienVercammen, los datos de op son únicos y ordenados.
Nina Scholz
@NinaScholz OP solo determinó "Tengo una matriz con números" y "Quiero que el número que tengo cambie al número más cercano de la matriz" . La matriz de ejemplo fue solo un ejemplo. Una matriz no garantiza entradas únicas.
Sébastien Vercammen
4

ES6

Funciona con arreglos ordenados y sin clasificar

Números enteros y flotadores, cadenas bienvenidas

/**
 * Finds the nearest value in an array of numbers.
 * Example: nearestValue(array, 42)
 * 
 * @param {Array<number>} arr
 * @param {number} val the ideal value for which the nearest or equal should be found
 */
const nearestValue = (arr, val) => arr.reduce((p, n) => (Math.abs(p) > Math.abs(n - val) ? n - val : p), Infinity) + val

Ejemplos:

let values = [1,2,3,4,5]
console.log(nearestValue(values, 10)) // --> 5
console.log(nearestValue(values, 0)) // --> 1
console.log(nearestValue(values, 2.5)) // --> 2

values = [100,5,90,56]
console.log(nearestValue(values, 42)) // --> 56

values = ['100','5','90','56']
console.log(nearestValue(values, 42)) // --> 56
Sébastien
fuente
3

No sé si se supone que debo responder una pregunta anterior, pero como esta publicación aparece primero en las búsquedas de Google, esperaba que me perdonara agregar mi solución y mi 2c aquí.

Siendo perezoso, no podía creer que la solución para esta pregunta fuera un LOOP, así que busqué un poco más y regresé con la función de filtro :

var myArray = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362];
var myValue = 80;

function BiggerThan(inArray) {
  return inArray > myValue;
}

var arrBiggerElements = myArray.filter(BiggerThan);
var nextElement = Math.min.apply(null, arrBiggerElements);
alert(nextElement);

Eso es todo !

FrenchieFred
fuente
1
Entonces, ¿qué pasa con el límite inferior? Siempre usa el siguiente valor más alto. Pero su enfoque me recuerda a goog.math.clamp(cierre de google) solo con matrices y sin preocuparse por el límite inferior.
noob
Su solución devuelve el siguiente número más alto de la matriz. No se encuentran ni el valor más cercano ni el valor exacto.
Hubert Grzeskowiak
2

Mi respuesta a una pregunta similar también es responsable de los vínculos y está en Javascript simple, aunque no utiliza la búsqueda binaria, por lo que es O (N) y no O (logN):

var searchArray= [0, 30, 60, 90];
var element= 33;

function findClosest(array,elem){
    var minDelta = null;
    var minIndex = null;
    for (var i = 0 ; i<array.length; i++){
        var delta = Math.abs(array[i]-elem);
        if (minDelta == null || delta < minDelta){
            minDelta = delta;
            minIndex = i;
        }
        //if it is a tie return an array of both values
        else if (delta == minDelta) {
            return [array[minIndex],array[i]];
        }//if it has already found the closest value
        else {
            return array[i-1];
        }

    }
    return array[minIndex];
}
var closest = findClosest(searchArray,element);

https://stackoverflow.com/a/26429528/986160

Michail Michailidis
fuente
2

Me gusta el enfoque de Fusion, pero hay un pequeño error. Así es correcto:

    function closest(array, number) {
        var num = 0;
        for (var i = array.length - 1; i >= 0; i--) {
            if(Math.abs(number - array[i]) < Math.abs(number - array[num])){
                num = i;
            }
        }
        return array[num];
    }

También es un poco más rápido porque utiliza el mejorado for bucle .

Al final escribí mi función así:

    var getClosest = function(number, array) {
        var current = array[0];
        var difference = Math.abs(number - current);
        var index = array.length;
        while (index--) {
            var newDifference = Math.abs(number - array[index]);
            if (newDifference < difference) {
                difference = newDifference;
                current = array[index];
            }
        }
        return current;
    };

Lo probé console.time()y es un poco más rápido que la otra función.

Jon
fuente
Oye, ¿puedes explicar por qué es un improved for loop? Los bucles invertidos no siempre son una mejora del rendimiento.
A1rPun
Evalúa .lengthsolo una vez, cuando declara i, mientras que para este ciclo. Pero creo var i = arr.length;while (i--) {}que sería aún más rápido
Jon
Actualicé mi respuesta. Lo cambié a while. Ahora es aún más rápido.
Jon
0

Una búsqueda binaria ligeramente modificada en la matriz funcionaría.

Holygeek
fuente
3
Vaya, eso es extraño, aparentemente a alguien no le gustan las búsquedas binarias. (Incluso aunque esa sea la mejor solución general.)
Hot Licks
0

Para un rango pequeño, lo más simple es tener una matriz de mapas, donde, por ejemplo, la 80a entrada tendría el valor 82, para usar su ejemplo. Para un rango mucho más amplio y escaso, probablemente el camino a seguir es una búsqueda binaria.

Con un lenguaje de consulta, puede buscar valores a cierta distancia a cada lado de su número de entrada y luego ordenar a través de la lista reducida resultante. Pero SQL no tiene un buen concepto de "siguiente" o "anterior", para darle una solución "limpia".

Hot Licks
fuente
0

Otra variante aquí tenemos un rango circular que conecta la cabeza con los pies y acepta solo el valor mínimo para la entrada dada. Esto me ayudó a obtener valores de código de caracteres para uno de los algoritmos de cifrado.

function closestNumberInCircularRange(codes, charCode) {
  return codes.reduce((p_code, c_code)=>{
    if(((Math.abs(p_code-charCode) > Math.abs(c_code-charCode)) || p_code > charCode) && c_code < charCode){
      return c_code;
    }else if(p_code < charCode){
      return p_code;
    }else if(p_code > charCode && c_code > charCode){
      return Math.max.apply(Math, [p_code, c_code]);
    }
    return p_code;
  });
}
Vikas
fuente
0 
#include <algorithm>
#include <iostream>
#include <cmath>

using namespace std;

class CompareFunctor
{

public:
    CompareFunctor(int n) { _n = n; }
    bool operator()(int & val1, int & val2)
    {
        int diff1 = abs(val1 - _n);
        int diff2 = abs(val2 - _n);
        return (diff1 < diff2);
    }

private:
    int _n;
};

int Find_Closest_Value(int nums[], int size, int n)
{
    CompareFunctor cf(n);
    int cn = *min_element(nums, nums + size, cf);
    return cn;
}

int main()
{
    int nums[] = { 2, 42, 82, 122, 162, 202, 242, 282, 322, 362 };
    int size = sizeof(nums) / sizeof(int);
    int n = 80;
    int cn = Find_Closest_Value(nums, size, n);
    cout << "\nClosest value = " << cn << endl;
    cin.get();
}
Rushikesh
fuente
0

Lo más eficiente sería una búsqueda binaria. Sin embargo, incluso las soluciones simples pueden salir cuando el siguiente número coincide más con el actual . Casi todas las soluciones aquí no tienen en cuenta que la matriz está ordenada e iterando a pesar de todo: /

const closest = (orderedArray, value, valueGetter = item => item) =>
  orderedArray.find((item, i) =>
    i === orderedArray.length - 1 ||
    Math.abs(value - valueGetter(item)) < Math.abs(value - valueGetter(orderedArray[i + 1])));

var data = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362];

console.log('21 -> 2', closest(data, 21) === 2);
console.log('22 -> 42', closest(data, 22) === 42); // equidistant between 2 and 42, select highest
console.log('23 -> 42', closest(data, 23) === 42);
console.log('80 -> 82', closest(data, 80) === 82);
Expandir fragmento

Esto también se puede ejecutar en no primitivos, por ejemplo closest(data, 21, item => item.age)

Cambie finda findIndexpara devolver el índice en la matriz.

Dominic
fuente
¿Qué pasa con la matriz desordenada?
EdG
Para los desordenados, tome una de las soluciones que no sale, sin embargo, si está haciendo el trabajo muchas veces, podría ser más óptimo ordenar la matriz una vez. Como se mencionó si la matriz es realmente grande, entonces una búsqueda binaria será más eficiente que una lineal.
Dominic
0

Para encontrar dos números más cercanos en la matriz

function findTwoClosest(givenList, goal) {
  var first;
  var second;
  var finalCollection = [givenList[0], givenList[1]];
  givenList.forEach((item, firtIndex) => {
    first = item;

    for (let i = firtIndex + 1; i < givenList.length; i++) {
      second = givenList[i];

      if (first + second < goal) {
        if (first + second > finalCollection[0] + finalCollection[1]) {
          finalCollection = [first, second];
        }
      }
    }
  });

  return finalCollection;
}

var counts = [2, 42, 82, 122, 162, 202, 242, 282, 322, 362]
var goal = 80;
console.log(findTwoClosest(counts, goal));
Abdullah
fuente
-5

Aquí está el fragmento de Código para encontrar el elemento más cercano a un número de una matriz en Complejidad O (nlog (n)): -

Entrada: - {1,60,0, -10,100,87,56} Elemento: - 56 Número más cercano en la matriz: - 60

Código fuente (Java):

package com.algo.closestnumberinarray;
import java.util.TreeMap;


public class Find_Closest_Number_In_Array {

    public static void main(String arsg[]) {
        int array[] = { 1, 60, 0, -10, 100, 87, 69 };
        int number = 56;
        int num = getClosestNumber(array, number);
        System.out.println("Number is=" + num);
    }

    public static int getClosestNumber(int[] array, int number) {
        int diff[] = new int[array.length];

        TreeMap<Integer, Integer> keyVal = new TreeMap<Integer, Integer>();
        for (int i = 0; i < array.length; i++) {

            if (array[i] > number) {
                diff[i] = array[i] - number;
                keyVal.put(diff[i], array[i]);
            } else {
                diff[i] = number - array[i];
                keyVal.put(diff[i], array[i]);
            }

        }

        int closestKey = keyVal.firstKey();
        int closestVal = keyVal.get(closestKey);

        return closestVal;
    }
}
Consorcio inactivo
fuente
Post solicitó JavaScript en las etiquetas
Shannon Hochkins