我有一个从-1000到1000的数字，我有一个带数字的数组。像这样：
[2, 42, 82, 122, 162, 202, 242, 282, 322, 362]
我希望我的号码更改为最接近的数组。
例如，我将80作为号码，我希望它获得82。
答案 0 :(得分：153)
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);
答案 1 :(得分：137)
这是伪代码，应该可以转换为任何过程语言：
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
它只是计算出给定数字和每个数组元素之间的绝对差异，并返回其中一个差异最小的那些。
示例值：
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.
作为一个概念证明，这里是我用来展示这个代码的Python代码：
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)
而且，如果您真的需要在Javascript中使用它，请参阅下面的完整HTML文件，该文件演示了该功能的实际应用：
<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>
现在请记住，例如，如果对数据项进行排序（可以从示例数据中推断出但您没有明确说明它），则可能存在提高效率的余地。例如，您可以使用二进制搜索来查找最近的项目。
您还应该记住，除非您需要每秒许多次，否则效率提升几乎是不可察觉的，除非您的数据集多更大
如果你做想以这种方式尝试（并且可以保证数组按升序排序），这是一个很好的起点：
<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>
它基本上使用bracketing并检查中间值，以便每次迭代将解空间减少一半，这是一种经典的O(log N)算法，而上面的顺序搜索是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
如上所述，对于小型数据集或不需要需要的事情来说，这应该不会产生太大的影响，但这是您可能需要考虑的选项。
答案 2 :(得分：31)
ES6（2015）版本：
const counts = [4, 9, 15, 6, 2];
const goal = 5;
counts
.reduce((prev, curr) => Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev);
对于可重用性，您可以包含支持占位符（http://ramdajs.com/0.19.1/docs/#curry或https://lodash.com/docs#curry）的咖喱函数。根据您的需要，这提供了很大的灵活性：
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]);
答案 3 :(得分：20)
工作代码如下：
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;
}
alert(closest(array,88));
答案 4 :(得分：14)
虽然这里发布了一些很好的解决方案，但JavaScript是一种灵活的语言，它为我们提供了以多种不同方式解决问题的工具。 当然，这完全取决于你的风格。如果您的代码更具功能性，您会发现reduce variation合适，即：
arr.reduce(function (prev, curr) {
return (Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev);
});
但是，有些人可能会发现难以阅读，具体取决于他们的编码风格。因此，我提出了解决问题的新方法：
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
与other approaches使用Math.min.apply找到最小值相反，这一点不需要对输入数组arr进行排序。我们不需要关心索引或事先对其进行排序。
为了清晰起见，我将逐行解释代码：
arr.map(function(k) { return Math.abs(k - x) })创建一个新数组，主要存储给定数字的绝对值（arr中的数字）减去输入数字（x）。我们将寻找下一个最小的数字（也是最接近输入数字）Math.min.apply(Math, indexArr)这是找到我们之前创建的数组中最小数字的合法方式（仅此而已）arr[indexArr.indexOf(min)]这可能是最有趣的部分。我们找到了最小的数字，但我们不确定是否应该添加或减去初始数字（x）。那是因为我们使用Math.abs()来找出差异。但是，array.map创建（逻辑上）输入数组的映射，使索引保持在同一位置。因此，要找出最接近的数字，我们只返回给定数组indexArr.indexOf(min)中找到的最小值的索引。我已经创建了bin来证明它。
答案 5 :(得分：10)
到目前为止，所有答案都集中在搜索整个数组。 考虑到你的数组已经排序，你真的只想要最接近的数字，这可能是最快的解决方案：
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(arr, target) );
请注意，该算法可以大大改善，例如使用二叉树。
答案 6 :(得分：6)
此解决方案使用ES5 existential quantifier Array#some，如果满足条件，则允许停止迭代。
Array#reduce的对面，它不需要为一个结果迭代所有元素。
在回调中，搜索到的值与实际delta之间的绝对值item，并与最后一个delta进行比较。如果大于或等于，则迭代停止，因为其增量的所有其他值都大于实际值。
如果回调中的delta较小，则会将实际项目分配给结果，而delta会保存在lastDelta中。
最后，采用具有相等增量的较小值，如下面的22示例，结果为2。
如果优先级值更高，则必须从以下位置更改增量检查：
if (delta >= lastDelta) {
为：
if (delta > lastDelta) {
// ^^^ without equal sign
这将使用22，结果为42（更高值的优先级）。
此函数需要在数组中排序值。
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
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
答案 7 :(得分：3)
我不知道我是否应该回答一个旧问题，但由于这篇文章首先出现在谷歌搜索上，我希望你能原谅我添加我的解决方案＆amp;我的2c在这里。
懒惰，我无法相信这个问题的解决方案将是一个循环，所以我搜索了一点，然后回来filter function：
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);
这就是全部！
答案 8 :(得分：2)
ES6
/**
* 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
示例：
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
答案 9 :(得分：2)
我喜欢Fusion的方法，但它有一个小错误。这是正确的：
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];
}
它也快一点，因为它使用改进的for循环。
最后我写了这样的函数：
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;
};
我用console.time()测试了它，它比其他功能稍快。
答案 10 :(得分：2)
我对一个类似问题的回答也是关系，它是普通的Javascript，虽然它不使用二进制搜索，所以它是O（N）而不是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);
答案 11 :(得分：1)
O（n）时间复杂度的一种更简单的方法是在数组的一次迭代中执行此操作。此方法适用于未排序的数组。
以下是一个JavaScript示例，在数组中，我们找到了最接近“ 58”的数字。
var inputArr = [150, 5, 200, 50, 30];
var search = 58;
var min = Math.min();
var result = 0;
for(i=0;i<inputArr.length;i++) {
let absVal = Math.abs(search - inputArr[i])
if(min > absVal) {
min=absVal;
result = inputArr[i];
}
}
console.log(result); //expected output 50 if input is 58
这同样适用于正，负，十进制数字。
Math.min()将返回Infinity。
result将存储最接近搜索元素的值。
答案 12 :(得分：1)
所有解决方案都经过精心设计。
这很简单：
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
答案 13 :(得分：0)
对阵列进行略微修改的二进制搜索是可行的。
答案 14 :(得分：0)
要在数组中找到两个最近的数字
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));
答案 15 :(得分：0)
最有效的方法是二进制搜索。但是，当 下一个数字与当前数字进一步匹配 时，即使是简单的解决方案也可以退出。这里几乎所有的解决方案都没有考虑到数组是有序的并且遍历整个过程：/
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);
这也可以在非原始元素上运行，例如closest(data, 21, item => item.age)
将find更改为findIndex以返回数组中的索引。
答案 16 :(得分：0)
如果数组已排序，那么不要只是迭代，而是使用二进制搜索算法。 这将返回索引。
function findClosestIndex(arr, element) {
let from = 0, until = arr.length - 1
while (true) {
const cursor = Math.floor((from + until) / 2);
if (cursor === from) {
const diff1 = element - arr[from];
const diff2 = arr[until] - element;
return diff1 <= diff2 ? from : until;
}
const found = arr[cursor];
if (found === element) return cursor;
if (found > element) {
until = cursor;
} else if (found < element) {
from = cursor;
}
}
}
结果：
console.log(findClosestIndex([0, 1, 2, 3.5, 4.5, 5], 4));
// output: 3
console.log(findClosestIndex([0, 1, 2, 3.49, 4.5, 5], 4));
// output: 4
console.log(findClosestIndex([0, 1, 2, 3.49, 4.5, 5], 90));
// output: 5
console.log(findClosestIndex([0, 1, 2, 3.49, 4.5, 5], -1));
// output: 0
如果您想计算一组数据中某个元素的百分位数（例如股票交易价格）或在数组中插入元素而无需事后对整个数组进行排序，则此函数很有用。 （例如缓存算法）
答案 17 :(得分：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();
}
答案 18 :(得分：0)
这里的另一个变体我们有圆形范围连接头到脚，并且只接受给定输入的最小值。这有助于我获得其中一种加密算法的char代码值。
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;
});
}
答案 19 :(得分：0)
对于小范围，最简单的方法是使用一个地图数组，例如，第80个条目中的值为82，以使用您的示例。对于更大，更稀疏的范围，可能的方法是二元搜索。
使用查询语言，您可以在输入数字的任意一侧查询值，然后对生成的缩减列表进行排序。但SQL没有“下一个”或“前一个”的好概念，为您提供“干净”的解决方案。
答案 20 :(得分：-4)
以下是用于在Complexity O（nlog（n））中从数组中找到与数字最接近的元素的代码片段： -
输入： - {1,60,0，-10,100,87,56} 元素： - 56 数组中最接近的数字： - 60
源代码（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;
}
}