Haskell - Merge-Sort, Sortieren von Wörtern und zahlen

Habe ich geschrieben, merge-sort in Haskell, es funktioniert, wenn mit zahlen, aber nicht mit Worten, und ich dachte, es würde. Ich bekomme nur "not in scope" bei der Verwendung von Worten und Buchstaben. Was mache ich falsch?

Hier ist mein code:

merge :: Ord a => [a] -> [a] -> [a]
merge [] ys = ys
merge xs [] = xs
merge (x:xs) (y:ys)
    | x <= y = x : merge xs (y:ys)
    | otherwise = y : merge (x:xs) ys

mergeSort :: Ord a => [a] -> [a]
mergeSort [] = []
mergeSort [x] = [x]
mergeSort xs
    = merge (mergeSort top) (mergeSort bottom)
    where
    (top, bottom) = splitAt (length xs `div` 2) xs
  • Dies funktioniert mit Strings, f.e. mergeSort ["banana", "candy", "apple"]
  • Dein code sieht okay aus. Es könnte hilfreich sein, um zu sehen, die genaue Eingabe und die vollständige Fehlermeldung. Ist es nicht gerade hilfreich, dass etwas ist nicht im Lieferumfang...
InformationsquelleAutor user940599 | 2011-09-26
  1. 4

    Sind Sie mit der Eingabe Ihrer Worte so?

    [this,is,an,example,sentence]

    Die syntax ist nicht korrekt. Wenn Sie möchten, um die Eingabe einer Zeichenkette, die Sie haben, um encapsulte es in doppelte Anführungszeichen ("):

    ["this","is","an","example","sentence"]

    Wenn das ist nicht Ihr Fehler, fühlen Sie sich frei, dies zu ignorieren beantworten.

    • Um sicher zu sein, die syntax ist richtig, das ist, warum bekommt er ein "nicht im Bereich" Fehler und nicht um einen syntax-Fehler.
    • Natürlich die syntax ist formal korrekt, aber es ist nicht das, was der OP will.
    InformationsquelleAutor fuz
  2. 3

    Dein code funktioniert einwandfrei.

    Allerdings würde ich vorschlagen, teilen Sie die Liste in einem Durchgang, ohne length. Natürlich, die Reihenfolge ist nicht wichtig hier, nur, dass wir zwei Listen von etwa der gleichen Größe. Sie könnten es genau so machen:

    splitList [] = ([],[])
splitList [x] = ([x],[])
splitList (x:y:zs) = let (xs,ys) = splitList zs in (x:xs, y:ys)

    ... oder tail-rekursive ...

    splitList zs = go zs [] [] where
   go [] xs ys = (xs, ys)
   go [x] xs ys = (x:xs, ys)
   go (x:y:zs) xs ys = go zs (x:xs) (y:ys)

    ... oder mit Indizes ...

    splitList xs = (go even, go odd) where
   go f = map snd $ filter (f.fst) $ indexed
   indexed = zip [0..] xs

    ... oder mit einem Fach ...

    import Data.List

splitList zs = snd $ foldl' go (True,([],[])) zs where
   go (True,(xs,ys)) x = (False,(x:xs,ys))   
   go (False,(xs,ys)) x = (True,(xs,x:ys))
    • Da wies mich auf #haskell, wenn ich schlug eine ähnliche Lösung gibt es einen Kompromiss: mit dieser Lösung, die Sortierung ist nicht stabil.
    • Gut, dann berechnen Sie die Länge der ursprünglichen Liste wieder. Dann übergeben Sie die Länge der Listen, die Sie senden an die Helfer, die getan werden kann mit eine einfache division durch 2 den Betrieb. Ich persönlich denke, dass der Ansatz, wo man map, die jedes element der ursprünglichen Liste in einem singleton-Liste ist cool.
    InformationsquelleAutor Landei
Schreibe einen Kommentar