texto - Cuenta el número de todas las palabras en una cadena
contar palabras repetidas en c++ (14)
¿Hay una función para contar la cantidad de palabras en una cadena? por ejemplo
str1 <- "How many words are in this sentence"
para devolver un resultado de 7
Gracias.
La solución 7 no da el resultado correcto en el caso de que solo haya una palabra. No debe simplemente contar los elementos en el resultado de gregexpr (que es -1 si no coincide) pero cuente los elementos> 0.
Es decir:
sapply(gregexpr("//W+", str1), function(x) sum(x>0) ) + 1
Prueba esto
length(unlist(strsplit(str1," ")))
Pruebe esta función desde el paquete stringi
require(stringi)
> s <- c("Lorem ipsum dolor sit amet, consectetur adipisicing elit.",
+ "nibh augue, suscipit a, scelerisque sed, lacinia in, mi.",
+ "Cras vel lorem. Etiam pellentesque aliquet tellus.",
+ "")
> stri_stats_latex(s)
CharsWord CharsCmdEnvir CharsWhite Words Cmds Envirs
133 0 30 24 0 0
Puede eliminar espacios dobles y contar el número de " " en la cadena para obtener el recuento de palabras. Use stringr y rm_white { qdapRegex }
str_count(rm_white(s), " ") +1
Puede usar str_match_all , con una expresión regular que identificaría sus palabras. Lo siguiente funciona con espacios iniciales, finales y duplicados.
library(stringr)
s <- "
Day after day, day after day,
We stuck, nor breath nor motion;
"
m <- str_match_all( s, "//S+" ) # Sequences of non-spaces
length(m[[1]])
Puede usar funciones strsplit y sapply
sapply(strsplit(str1, " "), length)
Puede usar la función wc en la biblioteca qdap :
> str1 <- "How many words are in this sentence"
> wc(str1)
[1] 7
También del paquete de stringi , la función directa stri_count_words
stringi::stri_count_words(str1)
#[1] 7
Usa nchar
si el vector de cadenas se llama x
(nchar(x) - nchar(gsub('' '','''',x))) + 1
Descubre la cantidad de espacios y luego agrega uno
Use el símbolo de expresión regular //W para gregexpr caracteres que no sean palabras, usando + para indicar uno o más en una fila, junto con gregexpr para encontrar todas las coincidencias en una cadena. Las palabras son el número de separadores de palabras más 1.
lengths(gregexpr("//W+", str1)) + 1
Esto fallará con cadenas en blanco al principio o al final del vector de caracteres, cuando una "palabra" no satisface la noción //W de no palabra (se podría trabajar con otras expresiones regulares, //S+ , [[:alpha:]] , etc., pero siempre habrá casos límite con un enfoque regex), etc. Es probable que sea más eficiente que strsplit soluciones strsplit , que asignarán memoria para cada palabra. Las expresiones regulares se describen en ?regex .
Actualización Como se señaló en los comentarios y en una respuesta diferente de @Andri, el enfoque falla con (cero) y cadenas de una palabra, y con la puntuación final
> str1 = c("", "x", "x y", "x y!" , "x y! z")
> lengths(gregexpr("[A-z]//W+", str1)) + 1L
[1] 2 2 2 3 3
Muchas de las otras respuestas también fallan en estos casos o en casos similares (por ejemplo, espacios múltiples). Creo que la advertencia de mi respuesta sobre "noción de una palabra" en la respuesta original cubre problemas de puntuación (solución: elija una expresión regular diferente, por ejemplo, [[:space:]]+ ), pero los casos de cero y una palabra son un problema; La solución de @ Andri no distingue entre cero y una palabra. Entonces, adoptando un enfoque "positivo" para encontrar palabras, uno podría
sapply(gregexpr("[[:alpha:]]+", str1), function(x) sum(x > 0))
Llevando a
> sapply(gregexpr("[[:alpha:]]+", str1), function(x) sum(x > 0))
[1] 0 1 2 2 3
De nuevo, la expresión regular podría refinarse para diferentes nociones de ''palabra''.
Me gusta el uso de gregexpr() porque es eficiente desde el punto de vista de la memoria. Una alternativa que utiliza strsplit() (como @usuario813966, pero con una expresión regular para delimitar palabras) y que hace uso de la noción original de delimitación de palabras es
> lengths(strsplit(str1, "//W+"))
[1] 0 1 2 2 3
Esto necesita asignar nueva memoria para cada palabra que se crea, y para la lista de palabras intermedia. Esto podría ser relativamente costoso cuando los datos son "grandes", pero probablemente sea efectivo y comprensible para la mayoría de los propósitos.
Utilizo la función str_count de la biblioteca stringr con la secuencia de escape /w que representa:
cualquier carácter de ''palabra'' (letra, dígito o guión bajo en la configuración regional actual: en modo UTF-8 solo se consideran letras y dígitos ASCII)
Ejemplo:
> str_count("How many words are in this sentence", ''//w+'')
[1] 7
De las otras nueve respuestas que pude probar, solo dos (por Vincent Zoonekynd y por petermeissner) funcionaron para todas las entradas presentadas hasta ahora, pero también requieren stringr .
Pero solo esta solución funciona con todas las entradas presentadas hasta el momento, más entradas como "foo+bar+baz~spam+eggs" o "Combien de mots sont dans cette phrase ?" .
Punto de referencia:
library(stringr)
questions <-
c(
"", "x", "x y", "x y!", "x y! z",
"foo+bar+baz~spam+eggs",
"one, two three 4,,,, 5 6",
"How many words are in this sentence",
"How many words are in this sentence",
"Combien de mots sont dans cette phrase ?",
"
Day after day, day after day,
We stuck, nor breath nor motion;
"
)
answers <- c(0, 1, 2, 2, 3, 5, 6, 7, 7, 7, 12)
score <- function(f) sum(unlist(lapply(questions, f)) == answers)
funs <-
c(
function(s) sapply(gregexpr("//W+", s), length) + 1,
function(s) sapply(gregexpr("[[:alpha:]]+", s), function(x) sum(x > 0)),
function(s) vapply(strsplit(s, "//W+"), length, integer(1)),
function(s) length(strsplit(gsub('' {2,}'', '' '', s), '' '')[[1]]),
function(s) length(str_match_all(s, "//S+")[[1]]),
function(s) str_count(s, "//S+"),
function(s) sapply(gregexpr("//W+", s), function(x) sum(x > 0)) + 1,
function(s) length(unlist(strsplit(s," "))),
function(s) sapply(strsplit(s, " "), length),
function(s) str_count(s, ''//w+'')
)
unlist(lapply(funs, score))
Salida:
6 10 10 8 9 9 7 6 6 11
require (stringr) str_count (x, "/ w +") # estará bien con espacios dobles / triples entre palabras
Todas las otras respuestas tienen problemas con más de un espacio entre las palabras.
La forma más simple sería:
require(stringr)
str_count("one, two three 4,,,, 5 6", "//S+")
... contando todas las secuencias en caracteres no espaciales ( //S+ ).
¿Pero qué hay de una pequeña función que nos permite también decidir qué tipo de palabras nos gustaría contar y cuáles también funcionan en vectores completos ?
require(stringr)
nwords <- function(string, pseudo=F){
ifelse( pseudo,
pattern <- "//S+",
pattern <- "[[:alpha:]]+"
)
str_count(string, pattern)
}
nwords("one, two three 4,,,, 5 6")
# 3
nwords("one, two three 4,,,, 5 6", pseudo=T)
# 6
str2 <- gsub('' {2,}'','' '',str1)
length(strsplit(str2,'' '')[[1]])
El gsub('' {2,}'','' '',str1) se asegura de que todas las palabras estén separadas por un solo espacio, reemplazando todas las ocurrencias de dos o más espacios con un espacio.
El strsplit(str,'' '') divide la oración en cada espacio y devuelve el resultado en una lista. El [[1]] toma el vector de palabras de esa lista. La length cuenta cuántas palabras.
> str1 <- "How many words are in this sentence"
> str2 <- gsub('' {2,}'','' '',str1)
> str2
[1] "How many words are in this sentence"
> strsplit(str2,'' '')
[[1]]
[1] "How" "many" "words" "are" "in" "this" "sentence"
> strsplit(str2,'' '')[[1]]
[1] "How" "many" "words" "are" "in" "this" "sentence"
> length(strsplit(str2,'' '')[[1]])
[1] 7