Hi Marc Une tres jolie petite probleme ! Voila une solution brute-force dans une ligne de code. Esseyer ! Hugs> last [ a*b | a <- [1..100], b<- [1..100], (show $ a*b) == reverse ( show $ a*b) ] 9009 Hugs> last [ a*b | a <- [1..1000], b<- [1..1000], (show $ a*b) == reverse ( show $ a*b) ] 90909 Hugs> last [ a*b | a <- [1..1000], b<- [1..1000], (show $ a*b) == reverse ( show $ a*b) ] Hugs> last [ (a,b,a*b) | a <- [1..1000], b<- [1..1000], (show $ a*b) == reverse ( show $ a*b) ] (999,91,90909) Si vous aves des question, n'hesite pas ! :) Dan --- On Sun, 1/31/10, Marc Chantreux wrote:

From: Marc Chantreux Subject: [Haskell-fr] euler 4: vos commentaires ? To: haskell-fr@haskell.org Date: Sunday, January 31, 2010, 11:41 PM Bonjour a tous,

toujours dans mes petites tentatives épisodiques, j'ai résolu ce WE le 4eme pb du euler project. J'imagine que ma résolution sera d'une naiveté touchante pour les plus experimentés d'entre vous et c'est bien le but de ce présent message: pourriez-vous, svp, émettre toutes les critiques qui vous viennent a l'esprit?

cordialement, marc

{- - http://projecteuler.net/index.php?section=problems&id=4 - A palindromic number reads the same both ways. - The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99. - - Find the largest palindrome made from the product of two 3-digit numbers. - -}

products max =     let g = reverse [1..max]     in [ (x,y, show $ x * y ) | x <- g, y <- g ]

is_palindrome x = x == reverse x

palindromes = filter ( \(_,_,x) -> is_palindrome x )

bigger_palindrome x = take 1 $ palindromes x

main = mapM (putStrLn . show) $     map (bigger_palindrome . products ) [99,999,9999] _______________________________________________ Haskell-fr mailing list Haskell-fr@haskell.org http://www.haskell.org/mailman/listinfo/haskell-fr

Salut à tous et un grand merci pour vos réponses instructives. Ce que je retiens en résumé: la derniere expression d'un générateur peut etre un booléen qui sert de filtre, ainsi: main = putStrLn $ show $ take 10 $ filter (==2) [1..10] peut s'écrire main = putStrLn $ show $ take 10 $ [ x | x <- [1..10], x == 2 ] de plus, les evaluations se comprennent les unes dans les autres de gauche a droite. on en arrive a une expression concise et claire: main = putStrLn $ show $ take 1 $ [ (x,y,z) | x <- (reverse [1..999]) -- utilisation de de x pour générer -- le prochain tableau , y <- (reverse [1..x]) -- utilisation de x et x pour calculer le produit z , let z = show $ x * y -- utilisation de z dans le test de filtre , z == (reverse z) ] par contre: une question relative a la lazyness me chagrine: en lisant le résultat [(999,91,"90909")], on constate que seule la premiere valeur de x est nécessaire. hors si j'écris reverse [1..999] (ou last dans la solution de Dan Popa), j'imagine qu'haskell a besoin du tableau complet pour l'inverser (dans le cas de reverse) ou en trouver le dernier élément (dans le cas de last). Mes questions: - mon intuition est-elle juste ? - suis-je en train de chercher la petitte bête ? - si non: comment résoudre le pb ? cordialement Marc