Add solutions

10/Queue.hs

-{--
-Funktionale Programmierung - Wintersemester 2022/2023
-Vorlesung am 04.01.2023
-Katharina Klost
+module Queue(Queue(F), enqueue, dequeue, isEmpty, hasElem, count) where
 
-Verschiedene Implementierungen von Queues
---}
-
--- Typklasse für die Queue
 class Queuelike s where
+  {-
+  Voraussetzung: Keine
+  Ergebnis: Eine neue Queue in die das Element hinten eingefügt ist, ist geliefert
+  -}
   enqueue :: a -> s a -> s a
+
+  {-
+  Voraussetzung: Keine
+  Ergebnis: Wenn die Queue leer ist, ist Nothing geliefert, sonst Just ein Tupel
+            aus dem vordesten Element und der Queue ohne das vorderste Element
+  -}
   dequeue :: s a -> Maybe (a, s a)
+
+  {-
+  Voraussetzung: Keine
+  Ergebnis: Wenn die Queue leer ist, ist False geliefert, sonst ist True geliefert
+  -}
   isEmpty :: s a -> Bool
 
-data Queue a = Q [a] [a] deriving Show
---(Q inp out) in die erste Liste werden die Element eingefügt, aus der zweiten Liste entfernt
+  hasElem :: (Eq a) => a -> s a -> Bool
+  count :: (Eq a) => a -> s a -> Int
+
+
+data Queue a = F [a] [a] deriving Show
 
 instance Queuelike Queue where
-  enqueue x (Q inp out ) = Q (x:inp) out
+    enqueue x (F inp out ) = (F (x:inp) out)
 
-  dequeue (Q [] [])       = Nothing
-  dequeue (Q inp [])      = dequeue (Q [] (reverse inp))
-  dequeue (Q inp (x:out)) = Just (x, Q inp out)
+    dequeue (F [] []) = Nothing
+    dequeue (F inp []) = dequeue (F [] (reverse inp))
+    dequeue (F inp (x:out)) = Just (x, (F inp out))
 
-  isEmpty (Q [] []) = True
+    isEmpty (F [] []) = True
     isEmpty _         = False
+
+    hasElem :: (Eq a) => a -> Queue a -> Bool
+    hasElem e (F inp out) = elem e inp || elem e out
+
+    count ::  (Eq a) => a -> Queue a -> Int
+    count e (F inp out) = count' inp + count' out
+        where
+            count' xs = foldr (\x acc -> if x == e then acc + 1 else acc) 0 xs

10/tut10.hs

+import Queue
+import Data.Maybe
+
+data Produkt = Produkt String Int deriving Show
+type Einkaufswagen = [Produkt]
+type Schlange = Queue Einkaufswagen
+
+anstellen :: Schlange -> Einkaufswagen -> Schlange
+anstellen schlange wagen = enqueue wagen schlange
+
+kassieren :: Schlange -> (Int, Schlange)
+kassieren schlange = (preis, neueSchlange)
+    where
+        leereSchlange = F [] []
+        leererEinkaufswagen = []
+
+        (produkte, neueSchlange) = fromMaybe (leererEinkaufswagen, leereSchlange) $ dequeue schlange
+
+        preis = foldr (\(Produkt _ preis) acc -> acc + preis) 0 produkte