从Java翻译成R的代码中的函数调用堆栈问题

Question

我将 Java 代码翻译成 R。我需要检查是否所有行都正确翻译。

某些部分很可能是正确的，因为我运行它并且 R 说：

错误：C 堆栈使用 7970192 太接近限制。

我不确定哪个部分出错了，因为当我编译它时，它不会对所有行显示任何错误，除非我尝试运行它

原始 Java 代码：

  public static void printQueens(int[] q) {
      int n = q.length;
      for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
          if (q[i] == j) StdOut.print("Q ");
          else           StdOut.print("* ");
        }
        StdOut.println();
      }  
      StdOut.println();
    }


  /***************************************************************************/

    public static void enumerate(int n) {
      int[] a = new int[n];
      enumerate(a, 0);
    }

  public static void enumerate(int[] q, int k) {
    int n = q.length;
    if (k == n) printQueens(q);
    else {
      for (int i = 0; i < n; i++) {
        q[k] = i;
        if (isConsistent(q, k)) enumerate(q, k+1);
      }
    }
  }  


  public static void main(String[] args) {
    int n = Integer.parseInt(args[0]);
    enumerate(n);
  }

}

R代码待修正

# Prints n-by-n placement of queens from permutation q
printQueens <- function(q) {
  n = q.length
  for(i in seq_len(n)) {
    for(j in seq_len(n)) {
      if(q[i] == j) print("Q ")
      else{          print("* ")}
    }
    sep="/n"
  }  
  sep="/n"
}

#Try all permutations using backtracking

enumerate <- function(q, k) {
   n = q.length;
   if(k == n) print(Queens(q))
  else {
    for(i in seq_len(n)) {
      q[k] = i
      if (isConsistent(q, k)) enumerate(q, k+1)
    }
  }
}  

enumerate <- function(n) {
  a = n
  enumerate(a);
}

main <- function(args) {
  n =args[0];
  enumerate(n);
}

Answer 1

您指出的错误（堆栈使用）意味着您的代码翻译错误（发生了非常深的递归并且函数堆栈调用耗尽），或者您可能正在尝试解决非常高的 N-queen 问题（N > 30）。

将代码从 Java 直接翻译成 R 存在许多问题：

1. Java 中的数组从0 开始索引，在R 中从1 开始。您将不得不在 R 中重新定义索引函数 []。
2. For-loop 然而相似在 R 中有不同的语义。它更像foreach 功能。要在 R 中为 Java for-loop 建模，您必须使用 while 构造。
3. 提供的源代码不完整（没有isConsistent函数）。

请查看解决上述所有问题的代码：

StdOut.print <- cat
StdOut.println <- function(x) cat("\n")
index1 <- .Primitive('[')
`[.zero-based_vector` <- function(v, i) index1(as.vector(v), i+1)

isConsistent <- function(q, n) {
  i <- 0
  while(i < n) {
    if (q[i] == q[n])           
      return(FALSE)   # same column
    if ((q[i] - q[n]) == (n - i)) 
      return(FALSE)   # same major diagonal
    if ((q[n] - q[i]) == (n - i)) 
      return(FALSE)   # same minor diagonal

    i <- i + 1
  }
  return(TRUE)
}

printQueens <- function(q) {
  n <- length(q)
  for (i in seq.int(n) - 1) {
    for (j in seq.int(n) - 1) {
      if (q[i] == j) 
        StdOut.print("Q ")
      else
        StdOut.print("* ")
    }
    StdOut.println()
  }  
  StdOut.println()
}

enumerate_n <- function(n) {
  a <- integer(n)
  class(a) <- c("zero-based_vector", class(a))

    enumerate_qk(a, 0)
}

enumerate_qk <- function(q, k) {
  n <- length(q)
  if (k == n) {
    printQueens(q)
  } else {
    i <- 0
    while(i < n) {
      q[k + 1] <- i
      if (isConsistent(q, k)) {
        enumerate_qk(q, k + 1)
      }

      i <- i + 1
    }
  }
}  

main <- function(args) {
  n <- as.integer(args[1])
  enumerate_n(n)
}

main(4)

输出：

* Q * * 
* * * Q 
Q * * * 
* * Q * 

* * Q * 
Q * * * 
* * * Q 
* Q * * 

供参考： 完整源代码发布于Queens.java