blocks|key|1973115|text|x+=+4.5
w+=+c(1,2,4,6,7)

closestLoc+=+which(min(abs(w-x)))
closestVal+=+w[which(min(abs(w-x)))]

#+On+my+phone-+please+pardon+typos|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1973116|如果向量很长，请尝试两步方法：|unstyled|1973117|x+=+4.5
w+=+c(1,2,4,6,7)

sdev+=+sapply(w,function(v,x)+abs(v-x),+x+=+x)
closestLoc+=+which(min(sdev))|1973118|对于非常长的向量(数百万行，警告--对于不太大、非常大的数据来说，这实际上要慢一些)。|1973119|require(doMC)
registerDoMC()

closestLoc+=+which(min(foreach(i+=+w)+%25dopar%25+{
+++abs(i-x)
}))|1973120|这个例子只是给你一个基本的想法，利用并行处理，当你有巨大的数据。注意，我不建议您将它用于类似abs()这样的简单和快速的函数。|1973121|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|W|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>x = 4.5
w = c(1,2,4,6,7)

closestLoc = which(min(abs(w-x)))
closestVal = w[which(min(abs(w-x)))]

# On my phone- please pardon typos
</code></pre>

If your vector is lengthy, try a 2-step approach:

<pre><code>x = 4.5
w = c(1,2,4,6,7)

sdev = sapply(w,function(v,x) abs(v-x), x = x)
closestLoc = which(min(sdev))
</code></pre>

for maddeningly long vectors (millions of rows!, warning- this will actually be slower for data which is not very, very, very large.)

<pre><code>require(doMC)
registerDoMC()

closestLoc = which(min(foreach(i = w) %dopar% {
 abs(i-x)
}))
</code></pre>

This example is just to give you a basic idea of leveraging parallel processing when you have huge data. Note, I do not recommend you use it for simple &amp; fast functions like abs().

blocks|key|3053315|text|您可以使用data.table进行二进制搜索：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3053316|dt+=+data.table(w,+val+=+w)+#+you'll+see+why+val+is+needed+in+a+sec
setattr(dt,+"sorted",+"w")++#+let+data.table+know+that+w+is+sorted|code-block|syntax|javascript|3053317|注意，如果列w尚未排序，则必须使用setkey(dt,+w)而不是setattr(.)。|3053318|#+binary+search+and+"roll"+to+the+nearest+neighbour
dt[J(x),+roll+=+"nearest"]
#+++++w+val
#1:+4.5+++4|3053319|在最后一个表达式中，val列将包含您要查找的内容。|3053320|#+or+to+get+the+index+as+Josh+points+out
#+(and+then+you+don't+need+the+val+column):
dt[J(x),+.I,+roll+=+"nearest",+by+=+.EACHI]
#+++++w+.I
#1:+4.5++3

#+or+to+get+the+index+alone
dt[J(x),+roll+=+"nearest",+which+=+TRUE]
#[1]+3|3053321|entityMap^0|5|A|0|0|6|1|H|D|X|A|0|0|A|3|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|T|$]]

You can use <code>data.table</code> to do a binary search:

<pre><code>dt = data.table(w, val = w) # you'll see why val is needed in a sec
setattr(dt, "sorted", "w") # let data.table know that w is sorted
</code></pre>

Note that if the column <code>w</code> isn't already sorted, then you'll have to use <code>setkey(dt, w)</code> instead of <code>setattr(.)</code>.

<pre><code># binary search and "roll" to the nearest neighbour
dt[J(x), roll = "nearest"]
# w val
#1: 4.5 4
</code></pre>

In the final expression the <code>val</code> column will have the you're looking for.

<pre><code># or to get the index as Josh points out
# (and then you don't need the val column):
dt[J(x), .I, roll = "nearest", by = .EACHI]
# w .I
#1: 4.5 3

# or to get the index alone
dt[J(x), roll = "nearest", which = TRUE]
#[1] 3
</code></pre>

blocks|key|564023|text|R>findInterval(4.5,+c(1,2,4,5,6))
[1]+3|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|564024|将与价格是正确的匹配(最近而不超过)。|unstyled|564025|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>R&gt;findInterval(4.5, c(1,2,4,5,6))
[1] 3
</code></pre>

will do that with price-is-right matching (closest without going over).

blocks|key|565698|text|为了在字符向量上这样做，Martin在R-帮助上建议了这个函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|565699|bsearch7+<-
+++++function(val,+tab,+L=1L,+H=length(tab))
{
+++++b+<-+cbind(L=rep(L,+length(val)),+H=rep(H,+length(val)))
+++++i0+<-+seq_along(val)
+++++repeat+{
+++++++++updt+<-+M+<-+b[i0,"L"]+%2B+(b[i0,"H"]+-+b[i0,"L"])+%25/%25+2L
+++++++++tabM+<-+tab[M]
+++++++++val0+<-+val[i0]
+++++++++i+<-+tabM+<+val0
+++++++++updt[i]+<-+M[i]+%2B+1L
+++++++++i+<-+tabM+>+val0
+++++++++updt[i]+<-+M[i]+-+1L
+++++++++b[i0+%2B+i+*+length(val)]+<-+updt
+++++++++i0+<-+which(b[i0,+"H"]+>=+b[i0,+"L"])
+++++++++if+(!length(i0))+break;
+++++}
+++++b[,"L"]+-+1L
}+|code-block|syntax|javascript|565700|entityMap|0|LINK|mutability|MUTABLE|url|http://r.789695.n4.nabble.com/General-binary-search-td3426478.html^0|J|4|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

To do this on character vectors, Martin Morgan suggested this function on <a href="http://r.789695.n4.nabble.com/General-binary-search-td3426478.html" rel="nofollow">R-help</a>:

<pre><code>bsearch7 &lt;-
 function(val, tab, L=1L, H=length(tab))
{
 b &lt;- cbind(L=rep(L, length(val)), H=rep(H, length(val)))
 i0 &lt;- seq_along(val)
 repeat {
 updt &lt;- M &lt;- b[i0,"L"] + (b[i0,"H"] - b[i0,"L"]) %/% 2L
 tabM &lt;- tab[M]
 val0 &lt;- val[i0]
 i &lt;- tabM &lt; val0
 updt[i] &lt;- M[i] + 1L
 i &lt;- tabM &gt; val0
 updt[i] &lt;- M[i] - 1L
 b[i0 + i * length(val)] &lt;- updt
 i0 &lt;- which(b[i0, "H"] &gt;= b[i0, "L"])
 if (!length(i0)) break;
 }
 b[,"L"] - 1L
} 
</code></pre>

blocks|key|1973323|text|您可以始终实现自定义二进制搜索算法来查找最接近的值。或者，您可以利用libc+()的标准实现。您也可以使用其他二进制搜索实现，但它不会改变这样一个事实:您必须仔细地实现比较函数才能在数组中找到最接近的元素。标准二进制搜索实现的问题是，它是用于精确比较的。这意味着您的临时比较函数需要执行某种exactification来确定数组中的元素是否足够接近。为了实现它，比较函数需要了解数组中的其他元素，特别是以下几个方面：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1973324|当前元素的位置(一个正在与键进行比较)。|unordered-list-item|1973325|键的距离以及它与邻居的比较方式(前一个或下一个元素)。|1973326|为了在比较功能方面提供额外的知识，键需要打包附加信息(而不仅仅是键值)。一旦比较函数了解了这些方面，它就可以确定元素本身是否最近。当它知道它是最近的，它返回“匹配”。|1973327|下面的C代码查找最接近的值。|1973328|#include+<stdio.h>
#include+<stdlib.h>

struct+key+{
++++++++int+key_val;
++++++++int+*array_head;
++++++++int+array_size;
};

int+compar(const+void+*k,+const+void+*e)+{
++++++++struct+key+*key+=+(struct+key*)k;
++++++++int+*elem+=+(int*)e;
++++++++int+*arr_first+=+key->array_head;
++++++++int+*arr_last+=+key->array_head+%2B+key->array_size+-1;
++++++++int+kv+=+key->key_val;
++++++++int+dist_left;
++++++++int+dist_right;

++++++++if+(kv+==+*elem)+{
++++++++++++++++/*+easy+case:+if+both+same,+got+to+be+closest+*/
++++++++++++++++return+0;
++++++++}+else+if+(key->array_size+==+1)+{
++++++++++++++++/*+easy+case:+only+element+got+to+be+closest+*/
++++++++++++++++return+0;
++++++++}+else+if+(elem+==+arr_first)+{
++++++++++++++++/*+element+is+the+first+in+array+*/
++++++++++++++++if+(kv+<+*elem)+{
++++++++++++++++++++++++/*+if+keyval+is+less+the+first+element+then
+++++++++++++++++++++++++*+first+elem+is+closest.
+++++++++++++++++++++++++*/
++++++++++++++++++++++++return+0;
++++++++++++++++}+else+{
++++++++++++++++++++++++/*+check+distance+between+first+and+2nd+elem.
+++++++++++++++++++++++++*+if+distance+with+first+elem+is+smaller,+it+is+closest.
+++++++++++++++++++++++++*/
++++++++++++++++++++++++dist_left+=+kv+-+*elem;
++++++++++++++++++++++++dist_right+=+*(elem%2B1)+-+kv;
++++++++++++++++++++++++return+(dist_left+<=+dist_right)+?+0:1;
++++++++++++++++}
++++++++}+else+if+(elem+==+arr_last)+{
++++++++++++++++/*+element+is+the+last+in+array+*/
++++++++++++++++if+(kv+>+*elem)+{
++++++++++++++++++++++++/*+if+keyval+is+larger+than+the+last+element+then
+++++++++++++++++++++++++*+last+elem+is+closest.
+++++++++++++++++++++++++*/
++++++++++++++++++++++++return+0;
++++++++++++++++}+else+{
++++++++++++++++++++++++/*+check+distance+between+last+and+last-but-one.
+++++++++++++++++++++++++*+if+distance+with+last+elem+is+smaller,+it+is+closest.
+++++++++++++++++++++++++*/
++++++++++++++++++++++++dist_left+=+kv+-+*(elem-1);
++++++++++++++++++++++++dist_right+=+*elem+-+kv;
++++++++++++++++++++++++return+(dist_right+<=+dist_left)+?+0:-1;
++++++++++++++++}
++++++++}

++++++++/*+condition+for+remaining+cases+(other+cases+are+handled+already):
+++++++++*+-+elem+is+neither+first+or+last+in+the+array
+++++++++*+-+array+has+atleast+three+elements.
+++++++++*/

++++++++if+(kv+<+*elem)+{
++++++++++++++++/*+keyval+is+smaller+than+elem+*/

++++++++++++++++if+(kv+<=+*(elem+-1))+{
++++++++++++++++++++++++/*+keyval+is+smaller+than+previous+(of+"elem")+too.
+++++++++++++++++++++++++*+hence,+elem+cannot+be+closest.
+++++++++++++++++++++++++*/
++++++++++++++++++++++++return+-1;
++++++++++++++++}+else+{
++++++++++++++++++++++++/*+check+distance+between+elem+and+elem-prev.
+++++++++++++++++++++++++*+if+distance+with+elem+is+smaller,+it+is+closest.
+++++++++++++++++++++++++*/
++++++++++++++++++++++++dist_left+=+kv+-+*(elem+-1);
++++++++++++++++++++++++dist_right+=+*elem+-+kv;
++++++++++++++++++++++++return+(dist_right+<=+dist_left)+?+0:-1;
++++++++++++++++}
++++++++}

++++++++/*+remaining+case:+(keyval+>+*elem)+*/

++++++++if+(kv+>=+*(elem%2B1))+{
++++++++++++++++/*+keyval+is+larger+than+next+(of+"elem")+too.
+++++++++++++++++*+hence,+elem+cannot+be+closest.
+++++++++++++++++*/
++++++++++++++++return+1;
++++++++}

++++++++/*+check+distance+between+elem+and+elem-next.
+++++++++*+if+distance+with+elem+is+smaller,+it+is+closest.
+++++++++*/
++++++++dist_right+=+*(elem%2B1)+-+kv;
++++++++dist_left+=+kv+-+*elem;
++++++++return+(dist_left+<=+dist_right)+?+0:1;
}


int+main(int+argc,+char+**argv)+{
++++++++int+arr[]+=+{10,+20,+30,+40,+50,+60,+70};
++++++++int+*found;
++++++++struct+key+k;

++++++++if+(argc+<+2)+{
++++++++++++++++return+1;
++++++++}

++++++++k.key_val+=+atoi(argv[1]);
++++++++k.array_head+=+arr;
++++++++k.array_size+=+sizeof(arr)/sizeof(int);

++++++++found+=+(int*)bsearch(&k,+arr,+sizeof(arr)/sizeof(int),+sizeof(int),
++++++++++++++++compar);

++++++++if(found)+{
++++++++++++++++printf("found+closest:+%25d\n",+*found);
++++++++}+else+{
++++++++++++++++printf("closest+not+found.+absurd!+\n");
++++++++}

++++++++return+0;
}|code-block|syntax|javascript|1973329|不用说，上述示例中的bsearch()绝对不会失败(除非数组大小为零)。|1973330|如果您实现了您自己的自定义二进制搜索，本质上您必须在二进制搜索代码的主体中嵌入相同的比较逻辑(而不是在上面的示例中使用此逻辑比较函数)。|1973331|entityMap^0|3D|5|41|E|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$]]|$1|I|3|J|5|H|7|15|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|17|8|@]|D|@]|E|$]]|$1|O|3|P|5|Q|7|18|8|@]|D|@]|E|$R|S]]|$1|T|3|U|5|6|7|19|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|1A|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|Y|$]]

You can always implement custom binary search algorithm to find the closest value. Alternately, you can leverage standard implementation of libc bsearch(). You can use other binary search implementations as well, but it does not change the fact that you have to implement the comparing function carefully to find the closest element in array. The issue with standard binary search implementation is that it is meant for exact comparison. That means your improvised comparing function needs to do some kind of exactification to figure out if an element in array is close-enough. To achieve it, the comparing function needs to have awareness of other elements in the array, especially following aspects:

<ul>
<li>position of the current element (one which is being compared with the
key).</li>
<li>the distance with key and how it compares with neighbors (previous
or next element).</li>
</ul>

To provide this extra knowledge in comparing function, the key needs to be packaged with additional information (not just the key value). Once the comparing function have awareness on these aspects, it can figure out if the element itself is closest. When it knows that it is the closest, it returns "match".

The the following C code finds the closest value.

<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

struct key {
 int key_val;
 int *array_head;
 int array_size;
};

int compar(const void *k, const void *e) {
 struct key *key = (struct key*)k;
 int *elem = (int*)e;
 int *arr_first = key-&gt;array_head;
 int *arr_last = key-&gt;array_head + key-&gt;array_size -1;
 int kv = key-&gt;key_val;
 int dist_left;
 int dist_right;

 if (kv == *elem) {
 /* easy case: if both same, got to be closest */
 return 0;
 } else if (key-&gt;array_size == 1) {
 /* easy case: only element got to be closest */
 return 0;
 } else if (elem == arr_first) {
 /* element is the first in array */
 if (kv &lt; *elem) {
 /* if keyval is less the first element then
 * first elem is closest.
 */
 return 0;
 } else {
 /* check distance between first and 2nd elem.
 * if distance with first elem is smaller, it is closest.
 */
 dist_left = kv - *elem;
 dist_right = *(elem+1) - kv;
 return (dist_left &lt;= dist_right) ? 0:1;
 }
 } else if (elem == arr_last) {
 /* element is the last in array */
 if (kv &gt; *elem) {
 /* if keyval is larger than the last element then
 * last elem is closest.
 */
 return 0;
 } else {
 /* check distance between last and last-but-one.
 * if distance with last elem is smaller, it is closest.
 */
 dist_left = kv - *(elem-1);
 dist_right = *elem - kv;
 return (dist_right &lt;= dist_left) ? 0:-1;
 }
 }

 /* condition for remaining cases (other cases are handled already):
 * - elem is neither first or last in the array
 * - array has atleast three elements.
 */

 if (kv &lt; *elem) {
 /* keyval is smaller than elem */

 if (kv &lt;= *(elem -1)) {
 /* keyval is smaller than previous (of "elem") too.
 * hence, elem cannot be closest.
 */
 return -1;
 } else {
 /* check distance between elem and elem-prev.
 * if distance with elem is smaller, it is closest.
 */
 dist_left = kv - *(elem -1);
 dist_right = *elem - kv;
 return (dist_right &lt;= dist_left) ? 0:-1;
 }
 }

 /* remaining case: (keyval &gt; *elem) */

 if (kv &gt;= *(elem+1)) {
 /* keyval is larger than next (of "elem") too.
 * hence, elem cannot be closest.
 */
 return 1;
 }

 /* check distance between elem and elem-next.
 * if distance with elem is smaller, it is closest.
 */
 dist_right = *(elem+1) - kv;
 dist_left = kv - *elem;
 return (dist_left &lt;= dist_right) ? 0:1;
}


int main(int argc, char **argv) {
 int arr[] = {10, 20, 30, 40, 50, 60, 70};
 int *found;
 struct key k;

 if (argc &lt; 2) {
 return 1;
 }

 k.key_val = atoi(argv[1]);
 k.array_head = arr;
 k.array_size = sizeof(arr)/sizeof(int);

 found = (int*)bsearch(&amp;k, arr, sizeof(arr)/sizeof(int), sizeof(int),
 compar);

 if(found) {
 printf("found closest: %d\n", *found);
 } else {
 printf("closest not found. absurd! \n");
 }

 return 0;
}
</code></pre>

Needless to say that bsearch() in above example should never fail (unless the array size is zero).

If you implement your own custom binary search, essentially you have to embed same comparing logic in the main body of binary search code (instead of having this logic in comparing function in above example).

blocks|key|3053484|text|NearestValueSearch+=+function(x,+w){
++##+A+simple+binary+search+algo
++##+Assume+the+w+vector+is+sorted+so+we+can+use+binary+search
++left+=+1
++right+=+length(w)
++while(right+-+left+>+1){
++++middle+=+floor((left+%2B+right)+/+2)
++++if(x+<+w[middle]){
++++++right+=+middle
++++}
++++else{
++++++left+=+middle
++++}
++}
++if(abs(x+-+w[right])+<+abs(x+-+w[left])){
++++return(right)
++}
++else{
++++return(left)
++}
}


x+=+4.5
w+=+c(1,2,4,6,7)
NearestValueSearch(x,+w)+#+return+3|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3053485|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>NearestValueSearch = function(x, w){
 ## A simple binary search algo
 ## Assume the w vector is sorted so we can use binary search
 left = 1
 right = length(w)
 while(right - left &gt; 1){
 middle = floor((left + right) / 2)
 if(x &lt; w[middle]){
 right = middle
 }
 else{
 left = middle
 }
 }
 if(abs(x - w[right]) &lt; abs(x - w[left])){
 return(right)
 }
 else{
 return(left)
 }
}


x = 4.5
w = c(1,2,4,6,7)
NearestValueSearch(x, w) # return 3
</code></pre>

blocks|key|564121|text|请参见match.closest()包中的MALDIquant：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|564122|>+library(MALDIquant)
>+match.closest(x,+w)
[1]+3|code-block|syntax|javascript|564123|entityMap^0|3|F|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

See <code>match.closest()</code> from the MALDIquant package:

<pre><code>&gt; library(MALDIquant)
&gt; match.closest(x, w)
[1] 3
</code></pre>

As a silly toy example, suppose

<pre><code>x=4.5
w=c(1,2,4,6,7)
</code></pre>

I wonder if there is a simple R function that finds the index of the closest match to <code>x</code> in <code>w</code>. So if <code>foo</code> is that function, <code>foo(w,x)</code> would return <code>3</code>. The function <code>match</code> is the right idea, but seems to apply only for exact matches. 

Solutions <a href="http://r.789695.n4.nabble.com/Find-the-closest-value-in-a-list-or-matrix-td838131.html" rel="noreferrer">here</a> (e.g. <code>which.min(abs(w - x))</code>, <code>which(abs(w-x)==min(abs(w-x)))</code>, etc.) are all <code>O(n)</code> instead of <code>log(n)</code> (I'm assuming that <code>w</code> is already sorted).

Find closest value in a vector with binary search

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

作为一个愚蠢的玩具例子，假设x=4.5w=c(1,2,4,6,7)我想知道是否有一个简单的R函数可以在x中找到与w最接近的索引。因此，如果foo是该函数，foo(w,x)将返回3。函数match是正确的想法，但似乎只适用于精确匹配。解决方案 (例如which.min(abs(w - x))、which(abs(w-x)...

问用二进制搜索在向量中找到最近的值
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问用二进制搜索在向量中找到最近的值EN