Comment trouver le mot le plus long dans la liste?

Question

Je n'arrive pas à trouver un état d'esprit fonctionnel pour résoudre ce problème d'une manière simple qui pourrait aussi fonctionner pour de très longues listes. Si vous avez une liste comme:

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

Je peux dire ce que la longueur du mot le plus long est assez simplement avec:

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

Comment puis-je modifier la déclaration précédente pour retourner la chaîne trois ?

Answer 1

En utilisant maximumBy, on et compare vous pouvez écrire l'expression comme ceci:

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, et snd dans une composition simple font l'affaire.

Answer 3

BTW, si l'on avait pas prêt à l'emploi maximumBy, une façon simple serait le motif undecorate décorez tri/idiome (qui fonctionne dans d'autres langues comme Python ou Scheme, ainsi):

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

Mais puisque la charge utile d'origine fait également partie du type clé en main, le résultat est pas toujours la première occurrence du mot le plus long (dans ce cas, il n'y avait qu'un mot avec la plus grande longueur)

Answer 4

Cette fonction (ou même la bibliothèque) ne semble pas être bien connue, mais Haskell a en fait un module appelé Data.Ord qui contient la fonction comparing qui est presque comme en utilisant Data.Function.on dans la première réponse, sauf que le code se termine plus idiomatique.

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" 

Le code se lit pratiquement comme l'anglais. "Obtenez le maximum en comparant la longueur."

Answer 5

Pour calculer length a, vous devez parcourir toute la liste a. Dans ce cas d'utilisation particulier, vous n'êtes préoccupé que par le mot le plus long, et pas exactement par sa durée, vous pouvez donc écrire une fonction qui ne va pas plus loin que nécessaire dans chaque liste pour déterminer celle qui est la plus longue. Cela peut vous sauver un certain traitement:

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"]