Update of exercises

Assignment_002/solution/readme.md

@@ -1,3 +1,18 @@
 # Lösung: Erste Schritte
 
-!INCLUDESRC "../src/scalper.clj" clojure
+
+```$2#!/usr/bin/env -S clojure -M
+
+(println "Produktname: ")
+(def produkt (read-line))
+
+(println "Einkauspreis:")
+(def preis-einkauf (Integer/parseInt (read-line)))
+
+(def preis-verkauf (max (* 2.5 preis-einkauf) 995))
+
+(println "")
+(print "Sonderangebot: ")
+(println produkt "für nur" preis-verkauf "EUR")
+
+```

Assignment_003/solution/readme.md

@@ -1,3 +1,28 @@
 # Lösung: Maps: Lagerverwaltung
 
-!INCLUDESRC "../src/abzock-lager.clj" clojure
+
+```$2#!/usr/bin/env -S clojure -M
+
+(def lager {
+    :PS5      10
+    :GTX1090  20
+    :OEL     300
+})
+
+(println "Lagerverwaltung Abzock GmbH")
+(println "Welcher Artikel wurde geliefert: ")
+(def artikel (keyword (read-line)))
+(println "Wieviel wurde ausgeliefert?")
+(def menge (Integer/parseInt (read-line)))
+
+(def bestand-alt (get lager artikel))
+(def bestand-neu (- bestand-alt menge))
+
+(def lager (dissoc lager artikel))
+(def lager (assoc  lager artikel bestand-neu))
+
+(println "")
+(println "Neuer Lagerbestand")
+(println lager)
+
+```

Assignment_004/solution/readme.md

@@ -1,3 +1,31 @@
 # Lösung: Kontrolltrukturen: Lagerverwaltung, Teil 2
 
-!INCLUDESRC "../src/abzock-lager-2.clj" clojure
+
+```$2#!/usr/bin/env -S clojure -M
+
+(def lager {
+    :PS5      10
+    :GTX1090  20
+    :OEL     300
+})
+
+(println "Lagerverwaltung Abzock GmbH")
+(println "Welcher Artikel wurde geliefert: ")
+(def artikel (keyword (read-line)))
+(println "Wieviel wurde ausgeliefert?")
+(def menge (Integer/parseInt (read-line)))
+
+(def bestand-alt (get lager artikel))
+(def bestand-neu (- bestand-alt menge))
+
+(if (< bestand-neu 0)
+  (println "Nicht genug Artikel vorhanden, du unwissendes Frischfleisch")
+  (do
+    (def lager (dissoc lager artikel))
+    (def lager (assoc  lager artikel bestand-neu))))
+
+(println "")
+(println "Neuer Lagerbestand")
+(println lager)
+
+```

Assignment_005/solution/readme.md

@@ -1,3 +1,26 @@
 # Lösung: Map und Reduce: Gewinnermittlung für die Abzock GmbH
 
-!INCLUDESRC "../src/abzock-gewinn.clj" clojure
+
+```$2#!/usr/bin/env -S clojure -M
+
+(def verkaeufe-stueckzahlen {
+    :PS5      [ 10, 5, 8, 13, 22, 42, 110 ],
+    :GTX1090  [ 5, 7, 11, 54, 90 ],
+    :OEL      [ 10, 44, 100, 343, 66, 52, 23 ]})
+
+(def verkaufspreise {
+    :PS5      1239,
+    :GTX1090  1699,
+    :OEL      9 })
+
+(println "Gewinnermittlung Abzock GmbH")
+
+(defn summiere [stueckzahlen preise]
+    (doseq [[key values] stueckzahlen]
+      (println key
+               (reduce + (map #(* % (key preise)) values))
+               "EUR")))
+
+(summiere verkaeufe-stueckzahlen verkaufspreise)
+
+```

Assignment_006/solution/readme.md

@@ -1,3 +1,9 @@
 # Lösung: Multi-Arity-Funktion
 
-!INCLUDESRC "../src/my-average.clj" clojure
+
+```$2(defn my-average
+  ([a b]         (/ (+ a b) 2))
+  ([a b c d]     (/ (+ a b c d) 4))
+  ([a b c d e f] (/ (+ a b c d e f) 6)))
+
+```

Assignment_007/solution/readme.md

@@ -1,3 +1,11 @@
 # Lösung: Funktion als Rückgabewert
 
-!INCLUDESRC "../src/plus-n-fn.clj" clojure
+
+```$2(defn plus-n-fn
+  "Liefert eine Funktion zurück, die genau ein
+  Argument nimmt und dieses Argument zu
+  `n` addiert."
+  [n]
+  #(+ % n))
+
+```

Assignment_008/solution/readme.md

@@ -1,3 +1,10 @@
 # Lösung: apply und Funktionen als Übergabewerte
 
-!INCLUDESRC "../src/triple-apply.clj" clojure
+
+```$2(defn triple-apply
+  "Wendet die Funktion `f` drei mal hintereinander auf die Argumente 
+  `args` an und gibt die Summe der Ergebnisse zurück."
+  [f & args]
+  (+ (apply f args) (apply f args) (apply f args)))
+
+```

Assignment_009/solution/readme.md

@@ -1,3 +1,9 @@
 # Lösung: Vor- und Nachbedingung
 
-!INCLUDESRC "../src/sqrt.clj" clojure
+
+```$2(defn sqrt [n]
+  { :pre [(>= n 0)]
+    :post [(> % 0)]}
+    (Math/sqrt n))
+ 
+```

Assignment_010/solution/readme.md

@@ -1,3 +1,14 @@
 # Lösung: Tail-Recursion
 
-!INCLUDESRC "../src/prod-recur.clj" clojure
+
+```$2(defn prod-recur
+  "Berechnet das Produkt einer Reihe von Zahlen `zahlen` unter
+  Verwendung von loop und recur."
+  [zahlen]
+  (loop [produkt    0
+         rest-liste zahlen]
+    (if (seq rest-liste)
+      (recur (* produkt (first rest-liste)) (rest rest-liste))
+      produkt)))
+
+```

Assignment_011/solution/readme.md

@@ -1,3 +1,36 @@
 # Lösung: Was hoppelt den da?
 
-!INCLUDESRC "../src/kaninchen.clj" clojure
+
+```$2#!/usr/bin/env -S clojure -M
+
+(def generationen 14)
+
+(defn fib
+  "Berechnet die Fibonacci-Zahl nach `n` Schritten."
+  [n]
+  { :pre  [(>= n 0)]
+    :post [(>= % 0)] }
+    (loop [n_2 0 n_1 1 step n]
+      (cond
+        (= step 0)
+          n_2
+        :else
+          (recur n_1 (+ n_2 n_1) (dec step)))))
+
+(defn fibs
+  "Berechnet alle Fibonacci-Zahlen bis `n` einschießlich
+   und gibt sie als Vektor zurück."
+   [n]
+   { :pre  [(>= n 0)] }
+
+   (let [v (range (inc n))]
+     (map #(fib %) v)))
+
+(defn kaninchen
+  []
+  (println "Nach" generationen "Generationen haben wir" (fib generationen) "Kaninchen")
+  (println "Die Population entwickelt sich so:" (fibs generationen)))
+
+(kaninchen)
+
+```

Assignment_012/solution/readme.md

@@ -1,3 +1,13 @@
 # Lösung: cond
 
-!INCLUDESRC "../src/test-positive.clj" clojure
+
+```$2(defn test-positive
+  "Vergleicht eine Zahl mit 0 gibt einen Hinweis-Text.
+  Der Hinweistext erklärt, ob die Zahl `number` größer, kleiner
+  oder gleich zur Zahl 0 ist."
+  [correct guess]
+  (cond (= guess 0) "gleich"
+        (< guess 0) "kleiner"
+        (> guess 0) "größer"))
+
+```

Assignment_013/solution/readme.md

@@ -1,3 +1,13 @@
 # Lösung: Ausnahmebehandlung
 
-!INCLUDESRC "../src/number-formatter.clj" clojure
+
+```$2(defn number-formatter
+  "Konvertiert den String `string` in einen Integer-Wert.
+  Wenn die Konvertierung fehlschlägt, wird -1 zurück
+  gegeben."
+  [string]
+  (try
+    (Integer/parseInt string)
+    (catch NumberFormatException nfe -1)))
+
+```

Assignment_014/solution/readme.md

@@ -1,3 +1,10 @@
 # Lösung: reduce
 
-!INCLUDESRC "../src/prod-reduce.clj" clojure
+
+```$2(defn prod-reduce
+  "Berechnet das Produkt einer Reihe von Zahlen `zahlen` unter
+  Verwendung von reduce."
+  [zahlen]
+  (reduce * zahlen))
+
+```

Assignment_015/solution/readme.md

@@ -1,3 +1,12 @@
 # Lösung: mapping und cycle
 
-!INCLUDESRC "../src/map-cycle.clj" clojure
+
+```$2(defn map-cycle
+  "Erzeugt eine unendliche Sequenz der Zahlen `zahlen`
+  und berechnet für jede Zahl deren Doppeltes und zieht dann 
+  1 ab. Vom Ergebnis werden `n` Elemente zurück
+  gegeben."
+  [n & zahlen]
+  (take n (map #(dec (* % 2)) (cycle zahlen))))
+
+```

Assignment_016/solution/readme.md

@@ -1,3 +1,11 @@
 # Lösung: take-while
 
-!INCLUDESRC "../src/below-zero.clj" clojure
+
+```$2(defn below-zero
+  "Läuft über `data` und gibt die Elemente bis zum ersten
+   Auftreten eines Wertes >= 0 zurück."
+  [data]
+  [data]
+  (take-while #(< % 0) data))
+
+```

Assignment_017/solution/readme.md

@@ -1,3 +1,14 @@
 # Lösung: filter
 
-!INCLUDESRC "../src/filter-positive.clj" clojure
+
+```$2(defn filter-positive
+    "Läuft über `data` und gibt die Elemente, deren Wert >= 0 ist zurück."
+    [data]
+    (filter #(>= % 0) data))
+
+; Testfälle
+(assert (= [1 2 3 4 0 5 6] (filter-positive [1 2 3 4 0 5 6])))
+(assert (= [2 3]           (filter-positive '(-1 2 3 -4))))
+(assert (= [42 0 42]       (filter-positive '(42 -23 0 -23 42))))
+
+```