¿Cómo encontrar la palabra más larga en la lista?

Question

No entiendo mi mentalidad funcional para resolver este problema de una manera simple que también podría funcionar para listas muy largas. Si usted tiene una lista como:

["one", "two", "three", "four", "five"] 

puedo decir lo que la longitud de la palabra más larga es bastante simple con:

maximum $ map length ["one", "two", "three", "four", "five"] 

¿Cómo puedo modificar la declaración anterior a devolver la cadena tres ?

Answer 1

Usando maximumBy, on y compare puede escribir la expresión como esta:

import Data.List (maximumBy) 
import Data.Function (on) 

maximumBy (compare `on` length) ["one", "two", "three", "four", "five"] 

Answer 2

maximumBy(\x -> (x, length x)), fst, y snd en una composición sencilla hacer el truco.

Answer 3

Por cierto, si uno no tenía lista para su uso maximumBy, una forma sencilla sería el patrón de decorar-tipo-Undecorate/idioma (que funciona en otros lenguajes como Python o Esquema también):

snd $ maximum $ map (\x -> (length x, x)) ["one", "two", "three", "four", "five"] 

Pero ya que la carga útil original es también parte de la clave de ordenación, el resultado no siempre es la primera aparición de la palabra más larga (en este caso solo había una palabra con la longitud más larga)

Answer 4

Esta función (o incluso biblioteca) no parece ser conocida, pero Haskell en realidad tiene un módulo llamado Data.Ord que contiene la función comparing que es casi como usar Data.Function.on en la respuesta superior, excepto que el código termina siendo más idiomático.

g>import Data.Ord 
g>import Data.List 
g>let getLongestElement = maximumBy (comparing length) 
getLongestElement :: [[a]] -> [a] 
g>getLongestElement ["one", "two", "three", "four", "five"] 
"three" 

El código prácticamente se lee como en inglés. "Obtener el máximo al comparar la longitud".

Answer 5

Para calcular length a, debe recorrer toda la lista a. En este caso de uso particular, solo está preocupado por la palabra más larga, y no exactamente cuánto tiempo son, por lo que puede escribir una función que solo llegue hasta donde sea necesario en cada lista para determinar cuál es la más larga. Esto le puede ahorrar algo de procesamiento:

module Main where 

main = putStrLn $ longestWordInList ["one", "two", "three", "four"] 

longestWordInList = go "" 
    where go result [] = result 
     go result (x:xs) = let result' = longestWord result x in 
           result' `seq` go result' xs 

longestWord a b = go a b a b 
    where go a _ _ [] = a 
     go _ b [] _ = b 
     go a b (_:as) (_:bs) = go a b as bs 

Answer 6

foldl (\accmax xs -> if length accmax < length xs then xs else accmax) [] ["one", "two", "three", "four", "five"]