r-功能，具有两个参数相等时返回的参数

Question

我正在尝试创建一个需要两个参数的函数。它将反复调用第一个论点，在我的情况下

f()

直到f连续返回相同的3倍。然后将调用第二个参数

g()

，如果g返回与f返回的f相同的值，则该函数必须返回此值。否则，它将返回并再次调用第一个参数f((并重复周期。

这就是我到目前为止所拥有的。

call_until = function(f, g) {
    while(1) {
        n = f %>% chunk(3) %>% filter(f, function(v) length(unique(v)) == 1)
        x = n()[1]
        if (x == g()) {
            return(x)
        }
    }
}

例如，如果F连续返回4次4次，则转到G。如果g等于f连续返回三次(在此示例中为4(；因此，如果g == 4，则call_until应该返回4。

Answer 1

这是您如何做的另一个示例

call_until = function(f, g) {
  while(TRUE) {
    value <- f()
    seen <- 1
    while(seen < 3) {
      next_value <- f()
      if (next_value == value) {
        seen <- seen + 1
      } else {
        value <- next_value
        seen <- 1
      }
    }
    if (value == g()) {
        return(value)
    }
  }
}

，如果您应该绘制三个新的f值，如果g不匹配或仅一个新值，则很重要。

这是一些有用的测试功能。他们只是按顺序从向量返回值，必要时重复。

cycler <- function(vals) {
  i <- 1
  function() {
    i<<-i+1
    vals[(i-2) %% length(vals)+1]
  }
}
f <- cycler(c(1,2,2,2,3,4,5,5,5,1,1))
g <- cycler(c(5,4))

我们得到

call_until(f, g)
# [1] 5

Answer 2

递归功能可能不是最佳选择，请将此答案视为选项。

f <- function(){
    sample(1:2, 1)
}
g <- function(){
    sample(1:2, 1)
}
fg <- function(f, g){
    res <- c(replicate(3, f()), g()) 
    message(paste("[-] f():", paste(res[1:3], collapse = ","), 
                  "g():", res[4], "n"))
    if(var(res) == 0){
        message(paste("[+] Magic value is ", res[1]))
        return(invisible(res[1]))
    }
    return(fg(f, g))
}
fg(f,g)
[-] f(): 1,1,1 g(): 2 
[-] f(): 1,1,1 g(): 2 
[-] f(): 1,2,2 g(): 1 
[-] f(): 2,1,1 g(): 2 
[-] f(): 1,1,1 g(): 2 
[-] f(): 1,2,2 g(): 1 
[-] f(): 1,1,1 g(): 1 
[+] Magic value is  1

Answer 3

这是一个可以实现的示例：

f <- function(){
  return(sample(1:10,1))
}
g <- f
call_until <- function(f, g){
  results <- c(f(), f(), f())
  test <- g()
  while(length(unique(results)) > 1 || test != results[3]){
    results <- c(results[2:3], f())
    test <- g()
  }
  return(test)
}

现在，我创建了一些简单的函数f;g，这些功能将随机选择1-10(甚至不需要参数作为输入(。因此，可能需要适应。这是一些输出：

> call_until(f,g)
[1] 3
> call_until(f,g)
[1] 7
> call_until(f,g)
[1] 10
> call_until(f,g)
[1] 9