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存在很多问题：

Java中的数组从0开始索引，在R中从1开始索引。并且您将不得不重新定义R中的索引函数[]。
对于For循环，类似的语言在R中具有不同的语义。它更像foreach功能。要在R中为Java for循环建模，您必须使用while构造。
提供的源代码不完整（缺少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

从Java转换为R的代码中的函数调用堆栈问题

1 个答案: