Question

如果我有一个像x <-c(1,2,3,4,5,6,7,8,9)这样的向量，我想要一个函数f f(vector,index,num)它采用向量并在索引上为num“最接近”的元素提供了f(x,3,4) = c(1,2,4,5)个“最近”元素例子： f(x,1,5) = c(2,3,4,5,6) f(x,8,3) = c(6,7,9) f(x,4,5) = c(1,2,3,5,6) and f(x,7,3) = c(5,6,8)

因为还有一个问题，如果我们有一个奇数，我们将需要选择是否通过对称选择左侧或右侧，让我们选择左侧（但右侧也可以）即c(1:9)

我希望我的问题很清楚，谢谢你的帮助/回复！

编辑：c(1,7,4,2,3,7,2,6,234,56,8)的原始向量是任意的，向量可以是字符串向量，或长度为1000的向量，带有带重复的混洗数字等。

即{ "name": "newjs", "version": "1.0.0", "description": "nothing", "main": "index.html", "scripts": { "test": "echo \"Error: no test specified\" && exit 1", "start" : "npm run lite", "lite" : "lite-server" }, "author": "", "license": "ISC", "devDependencies": { "lite-server": "^2.3.0" } }

Answer 1

num_closest_by_indices <- function(v, idx, num) {
  # Try the base case, where idx is not within (num/2) of the edge
  i <- abs(seq_along(x) - idx)
  i[idx] <- +Inf # sentinel

  # If there are not enough elements in the base case, incrementally add more
  for (cutoff_idx in seq(floor(num/2), num)) {
    if (sum(i <= cutoff_idx) >= num) {
      # This will add two extra indices every iteration. Strictly if we have an even length, we should add the leftmost one first and `continue`, to break ties towards the left.
      return(v[i <= cutoff_idx])
    }
  }
}

以下是此算法的示例：我们按照合意性的顺序对索引进行排名，然后选择最低num合法的索引：

> seq_along(x)
  1 2 3 4 5 6 7 8 9
> seq_along(x) - idx
  -2 -1  0  1  2  3  4  5  6
> i <- abs(seq_along(x) - idx)
   2  1  0  1  2  3  4  5  6
> i[idx] <- +Inf # sentinel to prevent us returning the element itself
   2   1 Inf   1   2   3   4   5   6

现在我们可以找到具有最小值的num元素（任意断开关系，除非你有一个偏好（左））。我们的第一个猜测是所有指数＆lt; =（num / 2）;如果index在开始/结束的(num/2)范围内，这可能还不够。

> i <= 2
  TRUE  TRUE FALSE  TRUE  TRUE FALSE FALSE FALSE FALSE
> v[i <= 2]
  1 2 4 5

因此，调整@ dash2的代码来处理某些索引是非法的（非正态或>长度（x）），即! %in% 1:L的极端情况。然后min(elems)将是我们无法选择的非法指数的数量，因此我们必须选择abs(min(elems))更多。

注意：

最后，代码通过三个分段情况更简单，更快速地处理它。噢。
如果我们选择(num+1)索引，然后在返回答案之前移除idx，它实际上似乎简化了一些事情。使用result[-idx]将其删除。

Answer 2

像这样：

f <- function (vec, elem, n) {
  elems <- seq(elem - ceiling(n/2), elem + floor(n/2))
  if (max(elems) > length(vec)) elems <- elems - (max(elems) - length(vec))
  if (elems[1] < 1) elems <- elems + (1 - elems[1])
  elems <- setdiff(elems, elem)
  vec[elems]
}

给出结果：

> f(1:9, 1, 5)
[1] 2 3 4 5 6
> f(1:9, 9, 5)
[1] 4 5 6 7 8
> f(1:9, 2, 5)
[1] 1 3 4 5 6
> f(1:9, 4, 5)
[1] 1 2 3 5 6
> f(1:9, 4, 4)
[1] 2 3 5 6
> f(1:9, 2, 4)
[1] 1 3 4 5
> f(1:9, 1, 4)
[1] 2 3 4 5
> f(1:9, 9, 4)
[1] 5 6 7 8

Answer 3

首先使用变量参数x启动一个函数，然后在

之后启动参考table和n

.nearest_n <- function(x, table, n) {

该算法假设table是数字，没有任何重复，并且所有值都是有限的; n必须小于或等于表的长度

    ## assert & setup
    stopifnot(
        is.numeric(table), !anyDuplicated(table), all(is.finite(table)),
        n <= length(table)
    )

对表格进行排序，然后“钳制”最大值和最小值

    ## sort and clamp
    table <- c(-Inf, sort(table), Inf)
    len <- length(table)

在table中查找发生x的时间间隔; findInterval()使用高效搜索。使用区间索引作为初始较低索引，并为较高索引添加1，确保保持在入口。

    ## where to start?
    lower <- findInterval(x, table)
    upper <- min(lower + 1L, len)

通过比较n的下部和上部索引距离来查找最近的x个邻居，记录最近的值，并根据需要增加下部或上部索引，并确保保持入边< / p>

    ## find
    nearest <- numeric(n)
    for (i in seq_len(n)) {
        if (abs(x - table[lower]) < abs(x - table[upper])) {
            nearest[i] = table[lower]
            lower = max(1L, lower - 1L)
        } else {
            nearest[i] = table[upper]
            upper = min(len, upper + 1L)
        }
    }

然后返回解决方案并完成功能

    nearest
}

代码可能看起来很冗长，但实际上相对有效，因为整个向量（sort()，findInterval()）上的唯一操作在R中有效实现。

这种方法的一个特殊优点是它可以在它的第一个参数中进行矢量化，计算使用lower（use_lower = ...）作为向量并使用pmin() / pmax()作为测试的测试夹具。

.nearest_n <- function(x, table, n) {
    ## assert & setup
    stopifnot(
        is.numeric(table), !anyDuplicated(table), all(is.finite(table)),
        n <= length(table)
    )

    ## sort and clamp
    table <- c(-Inf, sort(table), Inf)
    len <- length(table)

    ## where to start?
    lower <- findInterval(x, table)
    upper <- pmin(lower + 1L, len)

    ## find
    nearest <- matrix(0, nrow = length(x), ncol = n)
    for (i in seq_len(n)) {
        use_lower <- abs(x - table[lower]) < abs(x - table[upper])
        nearest[,i] <- ifelse(use_lower, table[lower], table[upper])
        lower[use_lower] <- pmax(1L, lower[use_lower] - 1L)
        upper[!use_lower] <- pmin(len, upper[!use_lower] + 1L)
    }

    # return
    nearest
}

例如

> set.seed(123)
> table <- sample(100, 10)
> sort(table)
 [1]  5 29 41 42 50 51 79 83 86 91
> .nearest_n(c(30, 20), table, 4)
     [,1] [,2] [,3] [,4]
[1,]   29   41   42   50
[2,]   29    5   41   42

通过获取任何参数并使用引用查找表table0将其强制转换为所需表单并将其编入table1

来对其进行概括

nearest_n <- function(x, table, n) {
    ## coerce to common form
    table0 <- sort(unique(c(x, table)))
    x <- match(x, table0)
    table1 <- match(table, table0)

    ## find nearest
    m <- .nearest_n(x, table1, n)

    ## result in original form
    matrix(table0[m], nrow = nrow(m))
}

作为一个例子......

> set.seed(123)
> table <- sample(c(letters, LETTERS), 30)
> nearest_n(c("M", "Z"), table, 5)
     [,1] [,2] [,3] [,4] [,5]
[1,] "o"  "L"  "O"  "l"  "P" 
[2,] "Z"  "z"  "Y"  "y"  "w"

在列表/向量中按索引选择最接近的x元素

3 个答案: