read - Generar series 1,2,1,3,2,1,4,3,2,1,5,4,3,2,1.

python biopython

Question

Estoy tratando de generar un vector que contenga una serie inversa creciente, como 1,2,1,3,2,1,4,3,2,1,5,4,3,2,1 .

Intenté usar un bucle para esto, pero no sé cómo apilar o concatenar los resultados.

for (i in 1:11)
{
x = rev(seq(i:1))
print(x)
}
[1] 1
[1] 2 1
[1] 3 2 1
[1] 4 3 2 1
[1] 5 4 3 2 1
[1] 6 5 4 3 2 1
[1] 7 6 5 4 3 2 1
[1] 8 7 6 5 4 3 2 1
[1] 9 8 7 6 5 4 3 2 1
[1] 10 9 8 7 6 5 4 3 2 1
[1] 11 10 9 8 7 6 5 4 3 2 1

También he estado experimentando con el rep , rev y seq , que son mi opción favorita pero no llegaron muy lejos.

Answer 1

Con sequence :

rev(sequence(5:1))
# [1] 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1

Answer 2

Otra alternativa es usar tail dentro de lapply , para seleccionar sucesivamente el número de elementos para mantener desde el vector inicial:

unlist(lapply(1:5, tail, x=5:1))
[1] 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1

O, puede ser más rápido construir primero el vector base y luego invocarlo:

vec <- 5:1
unlist(lapply(rev(vec), tail, x=vec))
[1] 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1

Answer 3

Podemos hacer esto con lapply

unlist(lapply(1:11, function(x) rev(seq(x))))

O como @ zx8754 mencionado en los comentarios, en lugar de rev(seq ,: puede usarse

unlist(lapply(1:11, function(x) x:1))

O como sugirió @BrodieG, podemos hacer esto más compacto eliminando la llamada de función anónima

unlist(lapply(1:11, ":", 1))

Answer 4

Y por diversión, usando matrices (e ignorando la advertencia;))

m <- matrix(c(1:5,0), ncol = 5, nrow = 5, byrow = T)
m[ upper.tri(m, diag = T) ]
# [1] 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1

Y podemos simplificar el upper.tri en sus componentes.

m[ row(m) <= col(m)]
# [1] 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1

Y si puede manejar aún más la diversión, entonces, ¿qué hay de algunas evaluaciones comparativas:

library(microbenchmark)
maxValue <- 1000
vec2 <- maxValue:1
m2 <- matrix(c(1:maxValue,0), ncol = maxValue, nrow = maxValue, byrow = T)
microbenchmark(
henrik = {
rev(sequence(maxValue:1))
},
akrun = {
unlist(lapply(1:maxValue, function(x) x:1))
},
symbolix1 = {
m <- matrix(c(1:maxValue,0), ncol = maxValue, nrow = maxValue, byrow = T)
m[ row(m) <= col(m) ]
},
symbolix2 = {
m2[ row(m2) <= col(m2) ]
},
lmo1 = {
unlist(lapply(1:maxValue, tail, x=maxValue:1))
},
lmo2 = {
vec <- maxValue:1
unlist(lapply(rev(vec), tail, x=vec))
},
lmo3 = {
unlist(lapply(rev(vec2), tail, x=vec2))
}
)
# Unit: milliseconds
# expr min lq mean median uq max neval
# henrik 3.342175 4.095287 5.185095 4.960354 5.703463 32.08644 100
# akrun 1.535998 1.761439 2.159954 2.162721 2.292743 10.80862 100
# symbolix1 13.443495 15.145713 16.588118 17.145578 17.896521 20.81460 100
# symbolix2 8.640927 10.245634 11.656378 12.297788 12.791973 14.39691 100
# lmo1 13.124813 14.301375 17.253844 14.795471 15.718820 61.09737 100
# lmo2 13.026593 14.202633 18.042158 14.891164 17.729049 86.18921 100
# lmo3 13.355810 14.424353 18.497383 14.876103 20.100575 76.96622 100

En este ejemplo, akrun (y zx8754 por proxy) es el ganador!

Pero sé lo que estás pensando, ''¿por qué terminar toda la diversión allí?''

Bueno, escribamos nuestra propia función de C ++ y veamos cómo funciona

library(Rcpp)
cppFunction(''NumericVector reverseSequence(int maxValue, int vectorLength){
NumericVector out(vectorLength);
int counter = 0;
for(int i = 1; i <= maxValue; i++){
for(int j = i; j > 0; j--){
out[counter] = j;
counter++;
}
}
return out;
}'')
maxValue <- 5
reverseSequence(maxValue, sum(1:maxValue))
[1] 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1
library(microbenchmark)
maxValue <- 1000
microbenchmark(
akrun = {
unlist(sapply(1:maxValue, function(x) x:1))
},
symbolix3 = {
reverseSequence(maxValue, sum(1:maxValue))
}
)
# Unit: microseconds
# expr min lq mean median uq max neval
# akrun 1522.250 1631.6030 3148.922 1829.9370 3357.493 45576.148 100
# symbolix3 338.626 495.3825 1293.720 950.6635 2169.656 3816.091 100