blocks|key|699722|text|对于较小的范围，最简单的事情是有一个映射数组，例如，第80个条目将包含值82，以使用您的示例。对于更大、更稀疏的范围，可能的方法是二进制搜索。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|699723|使用查询语言，您可以查询输入数字两边的某个距离的值，然后对得到的简化列表进行排序。但是SQL没有好的“下一步”或“前一步”的概念，给你一个“干净”的解决方案。|699724|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

<p>For a small range, the simplest thing is to have a map array, where, eg, the 80th entry would have the value 82 in it, to use your example.  For a much larger, sparse range, probably the way to go is a binary search.</p>

<p>With a query language you could query for values some distance either side of your input number and then sort through the resulting reduced list.  But SQL doesn't have a good concept of "next" or "previous", to give you a "clean" solution.</p>


blocks|key|483902|text|工作代码如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|483903|​|483904|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));|code-block|syntax|javascript|483905|483906|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Working code as below:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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 &lt; minDiff) {
      minDiff = m;
      ans = array[i];
    }
  }
  return ans;
}
console.log(closest(array, 88));</code></pre>
</div>
</div>
</p>


blocks|key|483911|text|ES5版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|483912|​|483913|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);|code-block|syntax|javascript|483914|483915|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>ES5 Version:</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var counts = [4, 9, 15, 6, 2],
  goal = 5;

var closest = counts.reduce(function(prev, curr) {
  return (Math.abs(curr - goal) &lt; Math.abs(prev - goal) ? curr : prev);
});

console.log(closest);</code></pre>
</div>
</div>
</p>


blocks|key|483974|text|我不知道我是否应该回答一个老问题，但当这篇文章第一次出现在谷歌搜索上时，我希望你能原谅我在这里添加我的解决方案&我的2c。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|483975|由于懒惰，我不敢相信这个问题的解决方案会是一个循环，所以我进行了更多的搜索，并返回了filter+function|offset|length|483976|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);|code-block|syntax|javascript|483977|这就是全部！|483978|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter^0|0|16|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

<p>I don't know if I'm supposed to answer an old question, but as this post appears first on Google searches, I hoped that you would forgive me adding my solution &amp; my 2c here.</p>

<p>Being lazy, I couldn't believe that the solution for this question would be a LOOP, so I searched a bit more and came back with <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter" rel="nofollow">filter function</a>:</p>

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

function BiggerThan(inArray) {
  return inArray &gt; myValue;
}

var arrBiggerElements = myArray.filter(BiggerThan);
var nextElement = Math.min.apply(null, arrBiggerElements);
alert(nextElement);
</code></pre>

<p>That's all !</p>


blocks|key|484046|text|对于排序的数组(线性搜索)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|484047|到目前为止，所有答案都集中在整个数组中进行搜索。考虑到您的数组已经排序，并且您真的只想要最近的数字，这可能是最简单(但不是最快)的解决方案：|484048|​|484049|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)+%7C%7C+arr.length+==+0)
++++return+null;
++if+(arr.length+==+1)
++++return+arr[0];

++for+(var+i+=+1;+i+<+arr.length;+i%2B%2B)+{
++++//+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));|code-block|syntax|javascript|484050|484051|请注意，该算法可以大大改进，例如使用二叉树。|484052|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|S|8|@]|9|@]|A|$I|J]]|$1|K|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|U|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|O|$]]

<h1>For sorted arrays (linear search)</h1>
<p>All answers so far concentrate on searching through the whole array.
Considering your array is sorted already and you really only want the nearest number this is probably the easiest (but not fastest) solution:</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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 &lt; 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] &gt; target) {
      var p = arr[i - 1];
      var c = arr[i]
      return Math.abs(p - target) &lt; 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));</code></pre>
</div>
</div>
</p>
<p>Note that the algorithm can be vastly improved e.g. using a binary tree.</p>


blocks|key|699972|text|我对一个类似问题的回答也是考虑到平局，它是用普通的Javascript编写的，尽管它没有使用二进制搜索，所以它是O(N)而不是O(logN)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|699973|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%2B%2B){
++++++++var+delta+=+Math.abs(array[i]-elem);
++++++++if+(minDelta+==+null+%7C%7C+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);|code-block|syntax|javascript|699974|https://stackoverflow.com/a/26429528/986160|offset|length|699975|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|17|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

<p>My answer to a similar question is accounting for ties too and it is in plain Javascript, although it doesn't use binary search so it is O(N) and not O(logN):</p>

<pre><code>var searchArray= [0, 30, 60, 90];
var element= 33;

function findClosest(array,elem){
    var minDelta = null;
    var minIndex = null;
    for (var i = 0 ; i&lt;array.length; i++){
        var delta = Math.abs(array[i]-elem);
        if (minDelta == null || delta &lt; 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);
</code></pre>

<p><a href="https://stackoverflow.com/a/26429528/986160">https://stackoverflow.com/a/26429528/986160</a></p>


blocks|key|700051|text|ES6+(ECMAScript+2015)版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|700052|​|700053|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);|code-block|syntax|javascript|700054|700055|为了提高可重用性，您可以封装一个支持占位符(http://ramdajs.com/0.19.1/docs/#curry或https://lodash.com/docs#curry)的curry函数。这根据您的需求提供了很大的灵活性：|offset|length|700056|700057|const+getClosest+=+_.curry((counts,+goal)+=>+{
++return+counts.reduce((prev,+curr)+=>+Math.abs(curr+-+goal)+<+Math.abs(prev+-+goal)+?+curr+:+prev);
});

const+closestToFive+=+getClosest(_,+5);
const+output+=+closestToFive([4,+9,+15,+6,+2]);

console.log(output);|700058|<script+src="https://cdn.jsdelivr.net/npm/lodash@4.17.20/lodash.min.js"></script>|700059|700060|entityMap|0|LINK|mutability|MUTABLE|url|http://ramdajs.com/0.19.1/docs/#curry|1|https://lodash.com/docs#curry^0|0|0|0|0|M|11|0|1O|T|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|17|8|@]|9|@$L|18|M|19|1|1A]|$L|1B|M|1C|1|1D]]|A|$]]|$1|N|3|C|5|6|7|1E|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1F|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|F|7|1G|8|@]|9|@]|A|$G|H]]|$1|S|3|C|5|6|7|1H|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]|11|$5|W|X|Y|A|$Z|12]]]]

<p>ES6 (ECMAScript 2015) Version:</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const counts = [4, 9, 15, 6, 2];
const goal = 5;

const output = counts.reduce((prev, curr) =&gt; Math.abs(curr - goal) &lt; Math.abs(prev - goal) ? curr : prev);

console.log(output);</code></pre>
</div>
</div>
</p>
<p>For reusability you can wrap in a curry function that supports placeholders (<a href="http://ramdajs.com/0.19.1/docs/#curry" rel="noreferrer">http://ramdajs.com/0.19.1/docs/#curry</a> or <a href="https://lodash.com/docs#curry" rel="noreferrer">https://lodash.com/docs#curry</a>). This gives lots of flexibility depending on what you need:</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const getClosest = _.curry((counts, goal) =&gt; {
  return counts.reduce((prev, curr) =&gt; Math.abs(curr - goal) &lt; Math.abs(prev - goal) ? curr : prev);
});

const closestToFive = getClosest(_, 5);
const output = closestToFive([4, 9, 15, 6, 2]);

console.log(output);</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;script src="https://cdn.jsdelivr.net/npm/lodash@4.17.20/lodash.min.js"&gt;&lt;/script&gt;</code></pre>
</div>
</div>
</p>


blocks|key|700135|text|我喜欢Fusion的方法，但其中有一个小错误。这是正确的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|700136|++++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];
++++}|code-block|syntax|javascript|700137|它的速度也更快，因为它使用了改进的for循环。|offset|length|style|CODE|700138|最后，我把我的函数写成这样：|700139|++++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;
++++};|700140|我用console.time()对它进行了测试，它比其他函数稍微快一点。|700141|entityMap^0|0|0|H|3|0|0|0|2|E|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@$I|12|J|13|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

<p>I like the approach from Fusion, but there's a small error in it. Like that it is correct:</p>

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

<p>It it also a bit faster because it uses the improved <code>for</code> loop.</p>

<p>At the end I wrote my function like this:</p>

<pre><code>    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 &lt; difference) {
                difference = newDifference;
                current = array[index];
            }
        }
        return current;
    };
</code></pre>

<p>I tested it with <code>console.time()</code> and it is slightly faster than the other function.</p>


blocks|key|700182|text|这里的另一个变体，我们有连接头部和脚趾的圆形范围，并且只接受给定输入的最小值。这帮助我获得了其中一个加密算法的字符代码值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|700183|function+closestNumberInCircularRange(codes,+charCode)+{
++return+codes.reduce((p_code,+c_code)=>{
++++if(((Math.abs(p_code-charCode)+>+Math.abs(c_code-charCode))+%7C%7C+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;
++});
}|code-block|syntax|javascript|700184|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Another variant here we have circular range connecting head to toe and accepts only min value to given input. This had helped me get char code values for one of the encryption algorithm.</p>

<pre><code>function closestNumberInCircularRange(codes, charCode) {
  return codes.reduce((p_code, c_code)=&gt;{
    if(((Math.abs(p_code-charCode) &gt; Math.abs(c_code-charCode)) || p_code &gt; charCode) &amp;&amp; c_code &lt; charCode){
      return c_code;
    }else if(p_code &lt; charCode){
      return p_code;
    }else if(p_code &gt; charCode &amp;&amp; c_code &gt; charCode){
      return Math.max.apply(Math, [p_code, c_code]);
    }
    return p_code;
  });
}
</code></pre>


blocks|key|484394|text|以下是从复杂度为O(nlog(n))的数组中查找与数字最接近的元素的代码片段：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|484395|输入:-+{1,+60+,0，-10,100,87,+56+}元素：-56数组中最近的数字：-60|484396|源代码(Java)：|484397|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="+%2B+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%2B%2B)+{

++++++++++++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;
++++}
}|code-block|syntax|javascript|484398|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>Here is the Code snippet to find the closest element to a number from an array in Complexity O(nlog(n)) :-</p>

<p>Input :- {1,60,0,-10,100,87,56}
Element:- 56
Closest Number in Array:- 60</p>

<p>Source Code (Java):</p>

<pre><code>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&lt;Integer, Integer&gt; keyVal = new TreeMap&lt;Integer, Integer&gt;();
        for (int i = 0; i &lt; array.length; i++) {

            if (array[i] &gt; 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;
    }
}
</code></pre>


blocks|key|484429|text|所有的解决方案都是过度设计的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|484430|它就像这样简单：|484431|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);
})[0];

//+5|code-block|syntax|javascript|484432|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>All of the solutions are over-engineered.</p>
<p>It is as simple as:</p>
<pre><code>const needle = 5;
const haystack = [1, 2, 3, 4, 5, 6, 7, 8, 9];

haystack.sort((a, b) =&gt; {
  return Math.abs(a - needle) - Math.abs(b - needle);
})[0];

// 5
</code></pre>


blocks|key|700267|text|#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+%2B+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();
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|700268|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;cmath&gt;

using namespace std;

class CompareFunctor
{

public:
    CompareFunctor(int n) { _n = n; }
    bool operator()(int &amp; val1, int &amp; val2)
    {
        int diff1 = abs(val1 - _n);
        int diff2 = abs(val2 - _n);
        return (diff1 &lt; 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 &lt;&lt; "\nClosest value = " &lt;&lt; cn &lt;&lt; endl;
    cin.get();
}
</code></pre>


blocks|key|484507|text|您可以使用以下逻辑来查找最接近的数字，而不使用reduce函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|484508|let+arr+=+[0,+80,+10,+60,+20,+50,+0,+100,+80,+70,+1];
const+n+=+2;
let+closest+=+-1;
let+closeDiff+=+-1;

for+(let+i+=+0;+i+<+arr.length;+i%2B%2B)+{
++if+(Math.abs(arr[i]+-+n)+<+closeDiff+%7C%7C+closest+===+-1)+{
++++closeDiff+=+Math.abs(arr[i]+-+n);
++++closest+=+arr[i];
++}
}
console.log(closest);|code-block|syntax|javascript|484509|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>You can use below logic to find closest number without using reduce function</p>
<pre><code>let arr = [0, 80, 10, 60, 20, 50, 0, 100, 80, 70, 1];
const n = 2;
let closest = -1;
let closeDiff = -1;

for (let i = 0; i &lt; arr.length; i++) {
  if (Math.abs(arr[i] - n) &lt; closeDiff || closest === -1) {
    closeDiff = Math.abs(arr[i] - n);
    closest = arr[i];
  }
}
console.log(closest);
</code></pre>


<p>I have a number from minus 1000 to plus 1000 and I have an array with numbers in it. Like this:</p>

<pre><code>[2, 42, 82, 122, 162, 202, 242, 282, 322, 362]
</code></pre>

<p>I want that the number I've got changes to the nearest number of the array.</p>

<p>For example I get <code>80</code> as number I want it to get <code>82</code>.</p>


Get the closest number out of an array

Java

我有一个从- 1000到+ 1000的数字，我有一个包含数字的数组。如下所示：[2, 42, 82, 122, 162, 202, 242, 282, 322, 362]我想把我得到的数字改成数组中最接近的数字。例如，我将80作为数字，我想让它获得82。

问从数组中获取最接近的数字
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从数组中获取最接近的数字EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从数组中获取最接近的数字
EN