+ Répondre à la discussion
Affichage des résultats 1 à 4 sur 4
  1. #1
    Membre émérite
    Homme Profil pro
    Inscrit en
    avril 2004
    Messages
    770
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : avril 2004
    Messages : 770
    Points : 911
    Points
    911

    Par défaut avis ma 1ere fonction: replace

    bonjour,

    je débute avec haskell,
    j'ai écrit ma 1ère fonction qui ... fonctionne.

    Code :
    1
    2
    3
    4
    5
    6
    replace :: [Char] -> [Char] -> [Char] -> [Char]
    replace str substr substit
        | null str = []
        | null substr = head str : if tail str /= [] then substit ++ replace (tail str) substr substit else []
        | take (length substr) str == substr = substit ++ replace (drop (length substr) str) substr substit
        | otherwise = head str : replace (tail str) substr substit
    c'est l'équivalent de str.replace() en python.

    j'aimerai vos avis ...

    sinon,
    j'essaye
    Code :
    intercalate "foo" "bar"
    et je m'attends à "bfooafoor" mais c'est pas le cas.
    "bar" c'est pas comme une liste ?

  2. #2
    Membre actif Avatar de Ptival
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2004
    Messages
    70
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 26
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : juin 2004
    Messages : 70
    Points : 168
    Points
    168

    Par défaut

    Voilà ce que j'aurais écrit pour replace :

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    replace :: String -> String -> String -> String
    replace [] _ _          = []
    replace s [] substitute = intercalate substitute (map (\x -> [x]) s)
    replace (c:cs)@s pattern substitute
      | sbegin == pattern   = substitute ++ (replaceRec srest)
      | otherwise           = c : (replaceRec cs)
      where
        replaceRec s = replace s pattern substitute
        (sbegin, srest) = splitAt (length pattern) s
    Ca me semble plus simple à lire que ce que tu écrivais. Notamment, je déconstruis la liste par pattern-matching, plutôt qu'avec des tests comme null str et des appels à head et tail. En général, on n'utilise pas ces fonctions comme tu le fais.

    Quant à intercalate, son type est http://www.haskell.org/hoogle/?hoogle=intercalate :
    Code :
    intercalate :: [a] -> [[a]] -> [a]
    Le deuxième argument doit être une liste d'éléments du type du premier. Aussi, tu dois transformer "bar" en ["b", "a", "r"]. C'est ce que fait le (map (\x -> [x]) s) dans mon code. J'aurais pensé qu'une telle fonction existait, mais je ne l'ai pas trouvée.

  3. #3
    Membre émérite
    Homme Profil pro
    Inscrit en
    avril 2004
    Messages
    770
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : avril 2004
    Messages : 770
    Points : 911
    Points
    911

    Par défaut

    ok, je comprends pour intercalate ...

    et j'ai appris ce que sont @ et splitAt, bien pratique ...

    Code :
    1
    2
    3
    4
    5
    6
    7
    replace :: [Char] -> [Char] -> [Char] -> [Char]
    replace [] _ _   = []
    replace str@(h:t) substr substit
        | null substr      = h : if t /= [] then substit ++ replace t substr substit else []
        | start  == substr = substit ++ replace end substr substit
        | otherwise        = h : replace t substr substit
        where (start,end)  = splitAt (length substr) str
    merci pour les conseils; j'essaye de faire un pendu, si j'ai d'autre questions je les poserai ici.

  4. #4
    Membre éclairé
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    mai 2009
    Messages
    98
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Finance

    Informations forums :
    Inscription : mai 2009
    Messages : 98
    Points : 304
    Points
    304

    Par défaut

    Il y a la fonction stripPrefix dans le module Data.List qui est pas mal

    Code Haskell :
    1
    2
    3
    4
    5
    6
    7
    replace :: String -> String -> String -> String
    replace _ _ [] = [] 
    replace toBeReplaced substitute s@(x:xs) = 
      case stripPrefix toBeReplaced s of
        Nothing         -> x : replace toBeReplaced substitute xs
        (Just stripped) -> substitute ++ replace toBeReplaced substitute stripped

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •