Cómo invertir una cadena en R

Intento enseñarme a mí mismo R y al hacer algunos problemas de muestra me encontré con la necesidad de invertir una cuerda.

Esto es lo que he intentado hasta ahora, pero la operación de pegar no parece tener ningún efecto.

Debe haber algo que no entiendo acerca de las listas? (Tampoco entiendo por qué necesito el [[1]] después de strsplit).

> test  test [1] "g" "r" "e" "g" > test_rev  test_rev [1] "g" "e" "r" "g" > paste(test_rev) [1] "g" "e" "r" "g" 

Como señala @mplourde, quiere el argumento de collapse :

 paste(test_rev, collapse='') 

La mayoría de los comandos en R están vectorizados, pero la forma en que el comando maneja los vectores depende del comando. paste operará sobre múltiples vectores, combinando el elemento i ésimo de cada uno:

 > paste(letters[1:5],letters[1:5]) [1] "aa" "bb" "cc" "dd" "ee" 

collapse le dice que opere dentro de un vector en su lugar.

From ?strsplit , una función que invertirá cada cadena en un vector de cadenas:

 ## a useful function: rev() for strings strReverse <- function(x) sapply(lapply(strsplit(x, NULL), rev), paste, collapse="") strReverse(c("abc", "Statistics")) # [1] "cba" "scitsitatS" 

stringi ha tenido esta función durante bastante tiempo:

 stringi::stri_reverse("abcdef") ## [1] "fedcba" 

También tenga en cuenta que está vectorizado:

 stringi::stri_reverse(c("a", "ab", "abc")) ## [1] "a" "ba" "cba" 

Lo siguiente puede ser una forma útil de invertir un vector de cadenas x , y es ligeramente más rápido (y más eficiente en la memoria) porque evita generar una lista (como al usar strsplit ):

 x <- rep( paste( collapse="", LETTERS ), 100 ) str_rev <- function(x) { sapply( x, function(xx) { intToUtf8( rev( utf8ToInt( xx ) ) ) } ) } str_rev(x) 

Si sabe que va a trabajar con caracteres ASCII y la velocidad importa, hay una implementación C rápida para invertir un vector de cadenas integrado en Kmisc :

 install.packages("Kmisc") str_rev(x) 

También puede usar el paquete IRanges .

 library(IRanges) x <- "ATGCSDS" reverse(x) # [1] "SDSCGTA" 

También puede usar el paquete Biostrings .

 library(Biostrings) x <- "ATGCSDS" reverse(x) # [1] "SDSCGTA" 

Si sus datos están en un data.frame , puede usar sqldf :

 myStrings <- data.frame(forward = c("does", "this", "actually", "work")) library(sqldf) sqldf("select forward, reverse(forward) `reverse` from myStrings") # forward reverse # 1 does seod # 2 this siht # 3 actually yllautca # 4 work krow 

Aquí hay una función que devuelve toda la cadena invertida u opcionalmente la cadena inversa manteniendo solo los elementos especificados por index , contando hacia atrás desde el último carácter.

 revString = function(string, index = 1:nchar(string)){ paste(rev(unlist(strsplit(string, NULL)))[index], collapse = "") } 

Primero, defina una cadena fácilmente reconocible como ejemplo:

(myString <- paste(letters, collapse = ""))

[1] "abcdefghijklmnopqrstuvwxyz"

Ahora prueba la función revString con y sin el índice:

revString(myString)

[1] "zyxwvutsrqponmlkjihgfedcba"

revString(myString, 1:5)

[1] "zyxwv"

Aquí hay una solución con gsub . Aunque estoy de acuerdo en que es más fácil con strsplit y paste (como se señala en las otras respuestas), puede ser interesante ver que también funciona con expresiones regulares:

 test <- "greg" n <- nchar(test) # the number of characters in the string gsub(paste(rep("(.)", n), collapse = ""), paste("", seq(n, 1), sep = "\\", collapse = ""), test) # [1] "gerg" 
 ##function to reverse the given word or sentence reverse <- function(mystring){ n <- nchar(mystring) revstring <- rep(NA, n) b <- n:1 c <- rev(b) for (i in 1:n) { revstring[i] <- substr(mystring,c[(n+1)- i], b[i]) } newrevstring <- paste(revstring, sep = "", collapse = "") return (cat("your string =", mystring, "\n", ("reverse letters = "), revstring, "\n", "reverse string =", newrevstring,"\n")) } 

La forma más fácil de invertir la secuencia:

 #reverse string---------------------------------------------------------------- revString <- function(text){ paste(rev(unlist(strsplit(text,NULL))),collapse="") } #example: revString("abcdef") 

Aquí hay una solución más base-R:

 # Define function strrev <- function(x) { nc <- nchar(x) paste(substring(x, nc:1, nc:1), collapse = "") } # Example strrev("Sore was I ere I saw Eros") [1] "sorE was I ere I saw eroS" 

La solución se inspiró en estas diapositivas de U. Auckland .

El siguiente código tomará la información del usuario y revertirá toda la cadena-

 revstring=function(s) print(paste(rev(strsplit(s,"")[[1]]),collapse="")) str=readline("Enter the string:") revstring(str) 

Puede hacerlo con la función rev () como se menciona en una publicación anterior.

 `X <- "MyString" 

RevX <- paste(rev(unlist(strsplit(X,NULL))),collapse="")

Salida: "gnirtSyM"

Gracias,

Por lo tanto, al parecer, los desarrolladores JS front-end tienen que hacer esto (para entrevistas) en JS sin usar funciones inversas incorporadas. Me tomó unos minutos, pero se me ocurrió:

 string <- 'hello' foo <- vector() for (i in nchar(string):1) foo <- append(foo,unlist(strsplit(string,''))[i]) paste0(foo,collapse='') 

Que todo podría estar envuelto en una función ...

¿Qué hay de los funcionales de orden superior? ¿Reducir?