Question

我最近看到了一个关于Ackermann函数的有趣Computerphile Video，并试图在R中重新创建它，这是我想出的：

export default
{
data(){
   return{
      products:{}
   }    
},
created() {
   this.loadProducts();

    Fire.$on('searching', () => {
       let query = this.$parent.search;
       axios.get('/api/findProduct?q=' + query )
           .then( ({data}) => {
               this.products= data;
            })
           .catch(()=>{

          });
       })
   }    
}

在视频中，他们实现了自己的代码版本（我认为是C），并解释说，它需要对特定值对（例如4,1）进行大量的递归计算，并且花了3分钟的时间才能计算出那个价值。如果尝试使用算法在R中重新创建此代码，则会出现堆栈溢出：

Ackermann <- function(m,n){

  if (m == 0){

    return(n+1)

  } else if (m > 0 & n == 0){

    return(Ackermann(m-1,1))

  } else if (m > 0 & n > 0){

    return(Ackermann(m-1,Ackermann(m,n-1)))

  }

}

有没有办法在R中获得Ackermann（4,1）的结果？

Answer 1

我认为有可能，但可能非常复杂。如果您这样写（请参见下文），则不会出错，但是会花费一些时间：

sub_Ackermann1 <- function(df){
  i <- nrow(df)
  m <- df$m[i]
  n <- df$n[i]
  if (m == 0){
    r <- n+1
    df$r[i] <- r
    df_i <- df} 
  else if (m > 0 & n == 0){
    r <- NA
    m <- m-1
    n <- 1
    df_i <- df
    newrow <- data.frame(m=m,n=n,r=r)
    df_i <- rbind(df_i,newrow)} 
  else if (m > 0 & n > 0){
    r1 <- NA
    m1 <- m-1
    n1 <- NA
    df_i <- df
    newrow1 <- data.frame(m=m1,n=n1,r=r1)
    df_i <- rbind(df_i,newrow1)

    r2 <- NA
    m2 <- m
    n2 <- n-1
    newrow2 <- data.frame(m=m2,n=n2,r=r2)
    df_i <- rbind(df_i,newrow2)}

  return(df_i)
}

sub_Ackermann2 <- function(df){
  r <- df$r[nrow(df)]
  if (is.na(df$n[nrow(df)-1])){ 
    df$n[nrow(df)-1] <- r }
  else if (is.na(df$r[nrow(df)-1])){ df$r[nrow(df)-1] <- r}
  df_i <- df[-nrow(df),] 
  return(df_i)
}
Ackermann <- function(m,n){
  df <- data.frame(m=m,n=n,r=NA)
  if (m == 0){df$r <- n+1} 
  while (is.na(df$r[1])){
    if (is.na(df$r[nrow(df)])){ df <- sub_Ackermann1(df)}
    else if (is.na(df$r[1])){ df <- sub_Ackermann2(df)}
  }
  return(df$r[1])

}

它至少在较小的值上有效，并且在较大的值上不会崩溃。也许有人可以证明这行不通，或者反之亦然，对如何优化它有想法...

使用R中的Ackermann函数避免堆栈溢出

1 个答案: