Comment inverser une chaîne dans R

À partir de ?strsplit, une fonction qui va inverser chaque chaîne dans un vecteur de chaînes:

## 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 a eu cette fonction depuis assez longtemps:

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

Notez Également qu'il est vectorisé:

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

Vous pouvez également utiliser le paquet IRanges.

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

Vous pouvez également utiliser le paquet Biostrings.

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

Ce qui suit peut être un moyen utile d'inverser un vecteur de chaînes x, et est légèrement plus rapide (et plus efficace en mémoire) car il évite de générer une liste (comme dans l'utilisation strsplit):

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

Si vous savez que vous allez travailler avec des caractères ASCII et des questions de vitesse, il existe une implémentation C rapide pour inverser un vecteur de chaînes intégré à Kmisc:

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

Si vos données sont dans un data.frame, vous pouvez utiliser 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

Voici une fonction qui retourne toute la chaîne inversée, ou éventuellement la chaîne inverse en ne gardant que les éléments spécifiés par index, en comptant en arrière à partir du dernier caractère.

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

Tout d'abord, définissez une chaîne facilement reconnaissable comme exemple:

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

[1] "abcdefghijklmnopqrstuvwxyz"

Maintenant essayer la fonction revString, avec et sans index:

revString(myString)

[1] "zyxwvutsrqponmlkjihgfedcba"

revString(myString, 1:5)

[1] "zyxwv"

Le Code suivant prendra l'entrée de l'utilisateur et inversera la chaîne entière -

revstring=function(s)
print(paste(rev(strsplit(s,"")[[1]]),collapse=""))

str=readline("Enter the string:")
revstring(str)

Voici une solution avec gsub. Bien que je convienne que c'est plus facile avec strsplit et paste (comme indiqué dans les autres réponses), il peut être intéressant de voir que cela fonctionne aussi avec des expressions régulières:

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"))
}

Le moyen le plus simple d'inverser la chaîne:

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

#example:
revString("abcdef")

Voici une autre solution de 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"

Solution a été inspiré par ces diapositives U. Auckland .

Vous pouvez faire avec la fonction rev() comme mentionné dans un post précédent.

`X <- "MyString"

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

Sortie: "gnirtSyM"

Merci,

Donc, apparemment, les développeurs JS frontaux sont invités à le faire (pour des interviews) dans JS sans utiliser les fonctions inverses intégrées. Cela m'a pris quelques minutes, mais je suis venu avec:

string <- 'hello'

foo <- vector()

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

Qui pourraient tous être enveloppés dans une fonction...

Qu'en est-il des fonctions d'ordre supérieur? Réduire?