R 如何将while循环的结果存储在列表中？

我知道这是一个非常基本的问题，但我想我在语法方面有困难。 我正在做一个while循环，我想稍后使用结果。但是，我不知道如何将结果存储在列表中

下面是我正在尝试的while循环的“简短版本”

z <- 0
 while(z < 10) { 
    z <- z + 1
    print(z)  
 }

z
listy
listy
listy
listy
listy也许这有帮助

z <- 0 
res <- c()
while(z<10) { 
    z <- z+1
    res <- c(res, z)
}

z也许这有帮助

z <- 0 
res <- c()
while(z<10) { 
    z <- z+1
    res <- c(res, z)
}

z也许这有帮助

z <- 0 
res <- c()
while(z<10) { 
    z <- z+1
    res <- c(res, z)
}

z也许这有帮助

z <- 0 
res <- c()
while(z<10) { 
    z <- z+1
    res <- c(res, z)
}

z你在用什么语言编程

Java示例：

int List<String> = new List<>();

while(z < 10) { List.add(z); z++ }

int List=new List（）；
而（z<10）{List.add（z）；z++}
你在用什么语言编程

Java示例：

int List<String> = new List<>();

while(z < 10) { List.add(z); z++ }

int List=new List（）；
而（z<10）{List.add（z）；z++}
你在用什么语言编程

Java示例：

int List<String> = new List<>();

while(z < 10) { List.add(z); z++ }

int List=new List（）；
而（z<10）{List.add（z）；z++}
你在用什么语言编程

Java示例：

int List<String> = new List<>();

while(z < 10) { List.add(z); z++ }

int List=new List（）；
而（z<10）{List.add（z）；z++}
R答案都令人失望，因为它们使用了帕特里克·伯恩（Patrick Burn）第二章中可怕的“复制和附加”模式。问题是，当向量被迫增长时，这会生成n*（n-1）/2个元素副本。第一个改进是预分配和填充，第二个改进是让R使用lappy（list）或vapply（vector）为您管理事情，第三个改进是使用实现所需操作的“矢量化”函数

下面是一些糟糕的实现

f1 <- function(n) {
    ## BAD, copy and append
    res <- c()
    for (i in seq_len(n))
        res <- c(res, i)
   res
}
f2 <- function(n) {
    ## BAD, copy and append
    res <- c()
    for (i in seq_len(n))
        res[[i]] <- i
    res
}
f3 <- function(n) {
    ## BAD copy and append
    res <- c()
    i <- 0
    while (i < n) {
        i <- i + 1
        res <- c(res, i)
    }
}

R答案都令人失望，因为它们使用了可怕的“复制和附加”模式，这是帕特里克·伯恩的第二章。问题是，当向量被迫增长时，这会生成n*（n-1）/2个元素副本。第一个改进是预分配和填充，第二个改进是让R使用lappy（list）或vapply（vector）为您管理事情，第三个改进是使用实现所需操作的“矢量化”函数

下面是一些糟糕的实现

f1 <- function(n) {
    ## BAD, copy and append
    res <- c()
    for (i in seq_len(n))
        res <- c(res, i)
   res
}
f2 <- function(n) {
    ## BAD, copy and append
    res <- c()
    for (i in seq_len(n))
        res[[i]] <- i
    res
}
f3 <- function(n) {
    ## BAD copy and append
    res <- c()
    i <- 0
    while (i < n) {
        i <- i + 1
        res <- c(res, i)
    }
}

R答案都令人失望，因为它们使用了可怕的“复制和附加”模式，这是帕特里克·伯恩的第二章。问题是，当向量被迫增长时，这会生成n*（n-1）/2个元素副本。第一个改进是预分配和填充，第二个改进是让R使用lappy（list）或vapply（vector）为您管理事情，第三个改进是使用实现所需操作的“矢量化”函数

下面是一些糟糕的实现

f1 <- function(n) {
    ## BAD, copy and append
    res <- c()
    for (i in seq_len(n))
        res <- c(res, i)
   res
}
f2 <- function(n) {
    ## BAD, copy and append
    res <- c()
    for (i in seq_len(n))
        res[[i]] <- i
    res
}
f3 <- function(n) {
    ## BAD copy and append
    res <- c()
    i <- 0
    while (i < n) {
        i <- i + 1
        res <- c(res, i)
    }
}

R答案都令人失望，因为它们使用了可怕的“复制和附加”模式，这是帕特里克·伯恩的第二章。问题是，当向量被迫增长时，这会生成n*（n-1）/2个元素副本。第一个改进是预分配和填充，第二个改进是让R使用lappy（list）或vapply（vector）为您管理事情，第三个改进是使用实现所需操作的“矢量化”函数

下面是一些糟糕的实现

f1 <- function(n) {
    ## BAD, copy and append
    res <- c()
    for (i in seq_len(n))
        res <- c(res, i)
   res
}
f2 <- function(n) {
    ## BAD, copy and append
    res <- c()
    for (i in seq_len(n))
        res[[i]] <- i
    res
}
f3 <- function(n) {
    ## BAD copy and append
    res <- c()
    i <- 0
    while (i < n) {
        i <- i + 1
        res <- c(res, i)
    }
}

是的，这看起来像我要找的！伟大的好吧，如果是这样的话，那么你应该把它标记为已接受，以结束这个问题：）是的，这看起来像是我要找的！伟大的好吧，如果是这样的话，那么你应该把它标记为已接受，以结束这个问题：）是的，这看起来像是我要找的！伟大的好吧，如果是这样的话，那么你应该把它标记为已接受，以结束这个问题：）是的，这看起来像是我要找的！伟大的好吧，如果是这样的话，那么你应该把它标记为接受来结束这个问题：）
，而
循环在R中是非常不规则的。如果我每年需要一次，那通常是。所以，无论你想做什么，都可能有一个更好（更有效）的选择。
而
循环在R中是非常单一的。如果我每年需要一次，那通常是。所以，无论你想做什么，都可能有一个更好（更有效）的选择。
而
循环在R中是非常单一的。如果我每年需要一次，那通常是。所以，无论你想做什么，都可能有一个更好（更有效）的选择。
而
循环在R中是非常单一的。如果我每年需要一次，那通常是。所以，无论你想做什么，都可能有一个更好（更有效）的选择。注意，这是一个糟糕的做法，以这种方式生长一个向量可能会非常慢。如果您提前知道结果长度，那么最好在循环之前分配结果向量，并在执行过程中进行填充。但是在R中确实有更好的方法来做这类事情。请注意，这是一种可怕的做法，以这种方式生长一个向量可能会非常缓慢。如果您提前知道结果长度，那么最好在循环之前分配结果向量，并在执行过程中进行填充。但是在R中确实有更好的方法来做这类事情。请注意，这是一种可怕的做法，以这种方式生长一个向量可能会非常缓慢。如果您提前知道结果长度，那么最好在循环之前分配结果向量，并在执行过程中进行填充。但是在R中确实有更好的方法来做这类事情。请注意，这是一种可怕的做法，以这种方式生长一个向量可能会非常缓慢。如果您提前知道结果长度，那么最好在循环之前分配结果向量，并在执行过程中进行填充。但在R中确实有更好的方法来做这类事情。