Wir lösen Yandex.Interview-Aufgaben in einem funktionalen Stil

Vor einigen Monaten erschien im Yandex-Blog ein Artikel, in dem die Passage des algorithmischen Abschnitts des Interviews erörtert wurde. In diesem Artikel wurde unter anderem ein Link zu einem speziellen Wettbewerb gegeben, der Aufgaben enthält, die denen ähneln, die Yandex seinen Kandidaten anbietet.

Nachdem ich mich im System registriert hatte, wurde ich sofort auf die Fähigkeit aufmerksam, Probleme auf Haskell zu lösen. Tatsache ist, dass ich, obwohl ich gerne in dieser Sprache programmiere, nicht weiter fortgeschritten bin als die Implementierung von Aufgaben aus verschiedenen Kursen von Online-Bildungsplattformen. Nachdem ich entschieden hatte, dass ihre Lösung eine interessante Herausforderung sein kann und mein Niveau als Entwickler verbessern wird, fuhr ich fort, sie zu lösen.

Wen interessiert es, was letztendlich daraus wurde? Willkommen bei Cat.

A. Steine ​​und Schmuck

Es werden zwei Zeilen mit lateinischen Kleinbuchstaben angegeben: Zeichenfolge J und Zeichenfolge S. Die in Zeichenfolge J enthaltenen Zeichen sind „Juwelen“ und in Zeichenfolge S sind „Steine“. Es muss ermittelt werden, wie viele Zeichen aus S gleichzeitig „Juwelen“ sind. Einfach ausgedrückt, müssen Sie überprüfen, wie viele Zeichen von S in J enthalten sind.

Die erste Aufgabe ist ein Aufwärmen, wir werden es „auf der Stirn“ lösen. Wir definieren die FunktionjuwelCount :: String -> String -> Int , die unter Verwendung der Faltung der vom zweiten Argument übergebenen Liste alle Fälle des in der ersten Liste verarbeiteten Elements zusammenfasst. Für diese Zwecke definieren wir die elemInt- Funktion basierend auf der elem- Funktion, die im Gegensatz zur letzten nicht True oder False, sondern die Zahl 0 oder 1 zurückgibt. In der Hauptfunktion müssen Sie nur zwei Zeilen lesen, sie an die entsprechende Funktion übergeben und das Ergebnis drucken. Das Urteil des Testsystems ist in Ordnung, wir gehen zur zweiten Aufgabe über.

jeweleryCount :: String -> String -> Int jeweleryCount j = foldr ((+).(elemInt j)) 0 where elemInt sx = fromEnum $ elem xs main :: IO () main = do j <- getLine s <- getLine print $ jeweleryCount js 

Der Quellcode zum Lösen dieser und anderer Aufgaben ist auch im Github-Repository verfügbar .

B. Aufeinanderfolgende Einheiten

Es ist erforderlich, die längste Folge von Einheiten im Binärvektor zu finden und seine Länge auszudrucken.

Um dieses Problem zu lösen, implementieren wir eine rekursive Funktion, die die übertragene Liste durchläuft und die Länge der erforderlichen Sequenz berechnet. Mit den Argumenten der Funktion übergeben wir zusätzlich zur Liste selbst die aktuelle maximale Länge und die Anzahl der aufeinanderfolgenden Einheiten beim aktuellen Aufruf. Zuerst definieren wir die Rekursionsbasis auf der leeren Liste und dann den Rekursionsschritt selbst.

Um die Eingabedaten zu lesen, definieren wir die Funktion getUserInputs :: IO [Char] , in der wir zuerst die Zahl n - die Größe der Liste - lesen und dann mit dem Kombinator replicateM eine Funktion erhalten, die die Funktion << get> getLine n-mal aufruft und die Ergebnisse zu einer Liste zusammenführt .

 import Control.Monad (replicateM) onesCount :: [Char] -> Int onesCount xs = onesCount' xs 0 0 where onesCount' "" max curr | max > curr = max | otherwise = curr onesCount' (x:xs) max curr | x == '1' = onesCount' xs max $ curr + 1 | curr > max = onesCount' xs curr 0 | otherwise = onesCount' xs max 0 getUserInputs :: IO [Char] getUserInputs = do n <- read <$> getLine :: IO Int replicateM n $ head <$> getLine main :: IO () main = do xs <- getUserInputs print $ onesCount xs 

Wir senden die Entscheidung, das Urteil ist in Ordnung. Wir gehen weiter.

C. Doppelte Entfernung

Es wird ein Array von 32-Bit-Ganzzahlen angegeben, die in nicht abnehmender Reihenfolge angeordnet sind. Sie möchten alle Wiederholungen daraus entfernen.

Beginnen wir mit einer einfachen Implementierung. Wir definieren eine Anfangsfunktion, die eine Zahl liest, druckt und in die E / A-Monade eingeschlossen zurückgibt. Wir definieren auch die Funktion deleteDoubles :: Int -> Int -> IO () , die eine Zahl liest und nur druckt, wenn sie nicht dem zweiten Argument entspricht (wir übergeben dort die im vorherigen Schritt gelesene Zahl). Danach ruft sich die Funktion rekursiv auf und fährt damit mit der nächsten Nummer im Eingabestream fort. Die Rekursionsbasis ist die Anzahl der zu lesenden Zahlen. Wir werden das erste Argument übergeben.

 import Control.Monad initial :: IO Int initial = do a <- read <$> getLine print a return a deleteDoubles :: Int -> Int -> IO() deleteDoubles 0 _ = return () deleteDoubles ta = do b <- read <$> getLine unless (a == b) $ print b deleteDoubles (t-1) b main :: IO () main = do t <- read <$> getLine unless (t < 1) $ initial >>= deleteDoubles (t-1) 

Wir senden die Lösung, sie besteht alle Tests und es scheint, dass wir mit der nächsten Aufgabe fortfahren können, aber meiner Meinung nach ist der rekursive Aufruf der in der E / A-Monade arbeitenden Funktion eher verwirrend als prägnant. Versuchen wir es zu verbessern.

Beachten Sie, dass Sie im Allgemeinen zuerst die gesamte Liste der Zahlen lesen können (wir verwenden den replicateM-Kombinator, der bereits mit der zweiten Aufgabe vertraut ist), ihn dann an eine reine Funktion übergeben, die alle Wiederholungen herausfiltert, und schließlich das Ergebnis drucken.

 import Control.Monad deleteDoubles' _ [] = [] deleteDoubles' prev (x:xs) | prev /= x = x:(deleteDoubles' x xs) | otherwise = deleteDoubles' x xs deleteDoubles (x:xs) = x:deleteDoubles' x xs getUserInputs :: Int -> IO [Int] getUserInputs t = replicateM t $ read <$> getLine main :: IO () main = do t <- read <$> getLine unless (t < 1) $ (deleteDoubles <$> getUserInputs t) >>= mapM_ print 

Ich sende eine Lösung, und die erste Enttäuschung ist, dass das Programm den 193-Test nicht besteht, da die Grenze des verwendeten Speichers überschritten wird. Der Hauptfehler besteht darin, die gesamte Liste in den gesamten Speicher einzulesen. Wir werden versuchen, dies zu vermeiden und einen bestimmten Hybrid aus der ersten und zweiten Version implementieren.

Beachten Sie, dass das Entfernen von Duplikaten etwas an eine linksassoziative Faltung erinnert: Bei jedem Schritt berechnen wir eine Funktion, die abhängig vom aktuell gelesenen Element und einem Teil des Ergebnisses im vorherigen Schritt zum Drucken entscheidet und dann zum nächsten Wertepaar übergeht.

Eine Funktion, die das Ergebnis abhängig von ihren Argumenten druckt oder nicht druckt und danach ihr zweites Argument zurückgibt, das in die E / A-Monade eingeschlossen ist, ist recht einfach. Nennen wir es Schritt:

 step :: Int -> Int -> IO Int step fst snd = unless (fst == snd) (print snd) >> return snd 

Wir haben herausgefunden, ob abhängig von den übergebenen Werten gedruckt wird oder nicht, aber wie organisiert man das Lesen? Dazu verwenden wir die monadische Faltungsfunktion foldM :: (faltbar t, Monade m) => (b -> a -> mb) -> b -> ta -> mb , die auf die Liste der Lesefunktionen anwendbar ist.
Nach Art der Funktion foldM stellen wir fest, dass bei jedem Schritt das „Auspacken“ des Ergebnisses der vorherigen Anwendung der Funktion unter der Haube von foldM selbst erfolgt. Daher müssen wir bei jedem Schritt nur eine monadische Berechnung des aktuellen Listenelements starten (tatsächlich die nächste Nummer lesen), indem wir den Bindungsoperator ( >> = ) verwenden und diese zusammen mit der vorherigen Nummer an Schritt übergeben. Als Ergebnis erhalten wir das folgende Programm

 step :: Int -> Int -> IO Int step fst snd = unless (fst == snd) (print snd) >> return snd initial :: IO Int initial = do a <- read <$> getLine print a return a getUserInputs t = replicate t $ read <$> getLine main :: IO () main = do t <- read <$> getLine unless (t < 1) $ do init <- initial foldM_ ((=<<) . step) init $ getUserInputs (t-1) 

D. Erzeugung von Klammersequenzen

Gegeben eine ganze Zahl n. Es ist erforderlich, alle korrekten Klammersequenzen der Länge 2 ⋅ n abzuleiten, die lexikografisch geordnet sind (siehe https://ru.wikipedia.org/wiki/Lexographic_order ).
In der Aufgabe werden nur Klammern verwendet.
Es ist ratsam, eine Lösung zu erhalten, die in einer Zeit arbeitet, die proportional zur Gesamtzahl der korrekten Klammersequenzen in der Antwort ist, und gleichzeitig eine Speicherkapazität proportional zu n verwendet.

Diese Aufgabe wird, wie viele andere, bei der es notwendig ist, Sequenzen abzuleiten, die bestimmte Bedingungen erfüllen (z. B. Aufgaben des Münztauschs, des Arrangierens von acht Königinnen und anderer, die hier ausführlicher gelesen werden können ), mit der Listenmonade kurz und bündig gelöst. Kurz gesagt, dieser Ansatz basiert auf der monadischen Bindung für Listen, deren Bedeutung darin besteht, die für jedes Element der Liste ausgeführten Operationen zusammenzufügen.

Definieren Sie eine rekursive Funktion, die ':: Int -> Int -> [[Char]] generiert. Dabei wird die Anzahl der Klammern als zweites Argument und die Anzahl der offenen Klammern, die bereits als erstes Argument festgelegt wurden, verwendet. Für den Rekursionsschritt benötigen wir zwei Hilfsfunktionen: möglich - gibt eine Liste der Klammern zurück, die im nächsten Schritt platziert werden können, und Schritt - ruft die Funktion generate 'mit den erforderlichen Parametern rekursiv auf.

 import Control.Monad(mapM_) generate :: Int -> [String] generate = generate' 0 where generate' _ 0 = [[]] generate' an = [x:xs | x <- possible, xs <- step x] where step '(' = generate' (a + 1) (n - 1) step ')' = generate' (a - 1) (n - 1) possible | n == a = ")" | a == 0 = "(" | otherwise = "()" main :: IO () main = do n <- read <$> getLine let result = generate $ n * 2 mapM_ putStrLn result 

Wir senden die Lösung und verstehen, dass wir die Einschränkung der vom Programm verwendeten Speichermenge nicht berücksichtigt haben. Die Lösung besteht den 14. Test nicht, da die Grenze des verwendeten Speichers überschritten wurde.

Wir ändern die Funktion generate 'so, dass die gesamte Liste der korrekten Klammersequenzen nicht erstellt, sondern sofort auf dem Bildschirm angezeigt wird. Dazu müssen wir der Funktion das dritte Argument hinzufügen - ein Fragment der Sequenz, die für den aktuellen Schritt erstellt wurde. Ich stelle fest, dass wir in dieser Implementierung die Sequenz in umgekehrter Reihenfolge erstellen werden - dies ermöglicht es uns, den Listenkonstruktor ( :) anstelle des teureren Verkettungsoperators ( ++ ) zu verwenden.

 import Control.Monad(mapM_) generate :: Int -> IO() generate = generate' "" 0 where generate' xs _ 0 = putStrLn $ reverse xs generate' xs an | n == a = step ')' | a == 0 = step '(' | otherwise = step '(' >> step ')' where step '(' = generate' ('(':xs) (a + 1) (n - 1) step ')' = generate' (')':xs) (a - 1) (n - 1) main :: IO () main = do n <- read <$> getLine generate $ n * 2 

E. Anagramme

Es werden zwei Zeilen angegeben, die aus lateinischen Kleinbuchstaben bestehen. Es ist erforderlich zu bestimmen, ob diese Zeilen Anagramme sind, d. H. Sie unterscheiden sich nur in der Zeichenfolge.

Um dieses Problem zu lösen, werden wir zählen, wie oft ein Buchstabe in jeder Zeile vorkommt, und die Ergebnisse vergleichen. Wir verstehen sofort, dass Standardlisten für uns nicht geeignet sind, und es ist erforderlich, eine Datenstruktur zu verwenden, die es uns ermöglicht, über den Index effektiv auf das Element zuzugreifen. Es gibt verschiedene Arten von Daten, die unsere Bedingungen erfüllen würden, aber wir werden das unveränderliche Standardarray Data.Array verwenden (es gibt immer noch mindestens verschiedene veränderbare Arrays sowie Data.Vector ).

Um die notwendigen Arrays zu konstruieren, verwenden wir die Funktion hist :: (Ix a, Num b) => (a, a) -> [a] -> Array ab , die gemäß der übertragenen Liste der Elemente und dem Bereich, zu dem diese Elemente gehören sollen, ein Array bildet. Hier wird die Anzahl der Wiederholungen von Elementen aus der Liste gespeichert. Diese Funktion ist zwar nicht im Data.Array-Modul enthalten, wird jedoch häufig als Beispiel für die Verwendung einer anderen, bereits Bibliotheksfunktion, accumArray, angegeben. Wir können nur die Implementierung kopieren und main schreiben - der Vorteil des Gleichheitsvergleichs für Array Char Int ist bereits definiert. Ich mache Sie auf eine nette Funktion aufmerksam - als Index können wir nicht nur ganze Zahlen verwenden, sondern jeden Vertreter der Klasse Ix . In unserem Fall spielt Char eine natürliche Rolle in dieser Rolle.

 import Data.Array hist :: (Ix a, Num b) => (a,a) -> [a] -> Array ab hist bnds is = accumArray (+) 0 bnds [(i, 1) | i<-is, inRange bnds i] main = do arr1 <- hist ('a','z') <$> getLine arr2 <- hist ('a','z') <$> getLine if (arr1 == arr2) then print 1 else print 0 

F. Führen Sie k sortierte Listen zusammen

Bei k Arrays nicht negativer Ganzzahlen, die in nicht abnehmender Reihenfolge sortiert sind, von denen jede 100 nicht überschreitet. Es ist erforderlich, das Ergebnis ihrer Fusion zu konstruieren: ein Array, das in nicht abnehmender Reihenfolge sortiert ist und alle Elemente der ursprünglichen k Arrays enthält.
Die Länge jedes Arrays überschreitet 10 ⋅ k nicht.
Versuchen Sie, die Lösung für die Zeit k ⋅ log (k) ⋅ n zum Laufen zu bringen, wenn wir annehmen, dass die Eingabearrays die Länge n haben.

Das Zusammenführen von zwei sortierten Listen ist eine klassische Listenaufgabe und wird in vielen Kursen zur Haskell-Programmierung behandelt. Zum Beispiel kann es wie folgt gelöst werden.

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

Nun, wir können zwei Listen zusammenführen. Und was sollen wir mit der Liste der Listen machen? Falten Sie es mit dieser Funktion! So werden wir alle Listen zu einer zusammenfassen und müssen sie nur ausdrucken.

 import Control.Monad merge :: [Int] -> [Int] -> [Int] merge [] ys = ys merge xs [] = xs merge (x:xs) (y:ys) | x < y = x:merge xs (y:ys) | otherwise = y:merge (x:xs) ys mergeLists :: [[Int]] -> [Int] mergeLists = foldl merge [] getUserInputs :: Int -> IO [[Int]] getUserInputs t = replicateM t $ do n <- getLine return $ tail $ read <$> words n main :: IO () main = do k <- read <$> getLine lists <- getUserInputs k let res = mergeLists lists mapM_ (putStrLn . show) res 

Diese Lösung weist jedoch zwei schwerwiegende Probleme auf: Der Rechenaufwand ist höher als der erforderliche - O (k ^ 2 ⋅ n) anstelle von O (k ⋅ log (k) ⋅ n) , und es wird viel zusätzlicher Speicher verwendet. Infolgedessen besteht diese Lösung den Test Nr. 17 nicht, da die Grenze des verwendeten Speichers überschritten wurde - 17,27 MB anstelle der zulässigen 10 MB.

Wir werden zwar nicht darauf achten, dass die an die Eingabe gelieferten Zahlen zu einem begrenzten Wertebereich gehören, und wir suchen weiterhin nach Lösungen für einen allgemeineren Fall.

Der nächste Schritt besteht darin, zu versuchen, den im ursprünglichen Artikel vorgeschlagenen Ansatz mit einer Analyse dieser Aufgaben umzusetzen. Ich möchte Sie daran erinnern, dass es auf der Verwendung einer Datenstruktur basiert, die eine effiziente Möglichkeit zum Extrahieren des Mindestelements bietet. Wählen Sie als solche Struktur Data.Set aus . Wir initialisieren Set mit der Liste der ersten Elemente, extrahieren und drucken dann bei jedem Schritt das minimale Element und fügen dann das nächste Element aus der entsprechenden Liste hinzu. Zusätzlich benötigen wir eine Data.Sequence- Struktur, um die Listen selbst zu speichern. Es wurde aus Gründen ausgewählt, dass bei jedem Schritt sowohl ein schneller Zugriff auf die Liste über ihren Index (den die Liste nicht bereitstellen kann) als auch das Element dieses Elements geändert werden müssen, ohne dass die gesamte Struktur kopiert werden muss (die im Allgemeinen keine unveränderlichen Daten bereitstellen kann) . Array ).

Somit haben wir folgendes Programm:

 import qualified Data.Sequence as Seq import qualified Data.Set as Set import Control.Monad import Data.Foldable mergeLists :: Set.Set (Int, Int) -> Seq.Seq [Int] -> IO () mergeLists set seq | Set.null set = return () | otherwise = do let ((val, idx), set') = Set.deleteFindMin set print val if null (Seq.index seq idx) then mergeLists set' seq else mergeLists (Set.insert (head (Seq.index seq idx), idx) set') (Seq.adjust tail idx seq) getUserInputs :: Int -> IO [[Int]] getUserInputs t = replicateM t $ do n <- getLine return $ tail $ read <$> words n main :: IO () main = do t <- read <$> getLine lists <- getUserInputs t let init_seq = Seq.fromList (filter (not . null) lists) let init_heap = Set.fromList (zipWith (,) (toList (fmap head init_seq)) [0..]) mergeLists init_heap $ tail <$> init_seq 

Wir senden die Lösung und stellen fest, dass das Programm zwar viel weniger Speicher verbraucht (10,26 MB anstelle von 17,27 MB beim 17. Test), das Limit jedoch immer noch nicht erreicht hat. Der Grund dafür liegt in der Tatsache, dass wir bei dieser Entscheidung auf die eine oder andere Weise die gesamten Eingabedaten in den Speicher lesen müssen. Versuchen wir dies mit Hilfe der dritten Lösung für dieses Problem zu vermeiden - Sortieren durch Zählen.

Wir haben bereits die Anzahl der eingehenden Zeichen gezählt, als wir das vorherige Anagrammproblem gelöst haben. Ebenso wie bei der Lösung werden wir Data.Array verwenden . Zuerst implementieren wir die Funktion addToArray :: Array Int Int -> [Int] -> Array Int Int , die ein Array basierend auf dem vorhandenen bildet, indem wir die Werte an den Indizes erhöhen, die den Werten aus der Liste entsprechen.

 addToArray :: Array Int Int -> [Int] -> Array Int Int addToArray acc elems = accum (+) acc [(i, 1) | i<-elems] 

Dann werden wir den uns bekannten Ansatz für das Problem des Entfernens von Wiederholungen verwenden - unter Verwendung der monadischen Faltung, wobei die Funktion addToArray nacheinander auf k Quellarrays angewendet wird . Und ... wir erhalten das gleiche Ergebnis von 10,26 MB beim 17. Test. Und dann ist es Zeit, sich daran zu erinnern, dass foldl (dessen Analogold foldM ist ) gemäß der akzeptierten Reduktionsreihenfolge zuerst die gesamte Kette verschachtelter Ausdrücke erweitert und erst dann mit ihrer aktiven Berechnung fortfährt. Wie Sie wissen, implementiert das Data.List- Modul zur Bekämpfung dieser Tatsache die Funktion foldl ' , die die Funktion seq :: a -> b -> b verwendet , die zuerst das erste Argument in die Normalform des schwachen Kopfes umwandelt, dh es auf den äußeren Teil reduziert - den Wert der Funktion oder des Konstruktors und gibt dann den zweiten zurück ( https://www.ibm.com/developerworks/ru/library/l-haskell4/index.html ). Wir haben keine andere Wahl, als die Funktion foldM 'unabhängig zu implementieren.

 foldM' :: (Monad m) => (a -> b -> ma) -> a -> [b] -> ma foldM' _ z [] = return z foldM' fz (x:xs) = do z' <- fzx z' `seq` foldM' fz' xs 

Infolgedessen hat sich die Menge des verwendeten Speichers beim 17. Test fast halbiert und betrug 5,64 MB! Obwohl der 17. und 18. Test erfolgreich bestanden wurden, bestand diese Implementierung den 19. Test nicht aus demselben Grund, aus dem das Speicherlimit überschritten wurde - 10,25 MB.

Okay, mach weiter - wir haben Data.Array.Unboxed noch nicht ausprobiert. Diese Art von Arrays ist insofern bemerkenswert, als sie im Gegensatz zum Standard die Werte selbst speichern können, anstatt auf sie zu verweisen ( https://wiki.haskell.org/Arrays#Unboxed_arrays ). Aus diesem Grund benötigen solche Arrays weniger Speicherplatz und sind effizienter. Um sie zu verwenden, müssen wir nur die Import- und Funktionstypen ändern, da Data.Array und Data.Array.Unboxed eine Schnittstelle unveränderlicher IArray- Arrays implementieren .

Wir senden eine Lösung - der Speicherverbrauch hat sich um das 4,5-fache auf 2,26 MB verringert, aber das Zeitlimit nicht überschritten - die Ausführungszeit betrug 1,09 Sekunden. Womit könnte dies verbunden sein? Gemessen an der Tatsache, dass die Ausführungszeit der verbleibenden Tests gleich bleibt, liegt der Grund meines Erachtens nicht darin, dass sich das Array ohne Box als langsamer als das mit Box herausstellte, sondern insbesondere das Testsystem. Es scheint, dass die Aufgabe unterbrochen wird, sobald eine der Einschränkungen verletzt wird. In sehr seltenen Fällen besteht diese Implementierung jedoch immer noch den 19. Test mit einem Ergebnis von 0,98 Sekunden, scheitert jedoch an Test Nummer 20, auch weil das Zeitlimit überschritten wurde.

Danach habe ich versucht, das unsichere Analogon der Accum-Funktion zu verwenden, das theoretisch schneller sein sollte, verschiedene Puffermethoden ( hSetBuffering :: Handle -> BufferMode -> IO () -Funktion), veränderbare IOArray- Arrays, aber keine dieser Methoden brachte Ergebnisse .

Ich bin nicht geneigt zu glauben, dass die Grenzen für Haskell zu eng festgelegt sind, und ich hoffe, dass es noch eine Lösung gibt, die alle Tests besteht. Im Projekt-Repository habe ich verschiedene Versionen des Codes zur Lösung dieses Problems veröffentlicht (mit Array und IOArray). Vielleicht ist dies der Ausgangspunkt für eine Lösung, die alle Tests besteht.

Fazit

Trotz der Tatsache, dass mir nur fünf von sechs Aufgaben erlegen waren, erledigte ich meine Hauptaufgabe - das Üben der funktionalen Programmierung. Nicht zuletzt spielten strenge Einschränkungen des Ressourcenverbrauchs des Programms eine Rolle, was uns dazu zwang, nach immer neuen Ansätzen zur Lösung von Problemen zu suchen. Ich hoffe, dass ihre Beschreibung für diejenigen nützlich sein wird, die gerade ihre Reise in die funktionale Programmierung beginnen

War der funktionale Ansatz zur Lösung solcher Probleme geeignet? Ehrlich gesagt habe ich einen doppelten Eindruck. Einerseits erwiesen sich die Lösungen für die meisten Probleme als sehr präzise, ​​und die Ausdrucksmittel von Haskell selbst sowie seine umfangreiche Standardbibliothek spielten dabei eine bedeutende Rolle. Andererseits kann man nur zugeben, dass die Verwaltung der verbrauchten Ressourcen in den meisten Fällen ein bestimmtes Problem sein kann, das es nicht ermöglicht, das Problem unter den gegebenen Einschränkungen zu lösen.