Racket Bootcamp

;---------[RACKET-BOOTCAMP]----------


;-----------[1. EINFÜHRUNG]------------
; --> Lektion 1.1: Elementare Ausdrücke <--
; (operator operand-1 operand-2 ... operand-n)
(+ 1 2 3)
(* 3 4 5)
(/ 9 3)
(/ 3 9)
(* (+ 2 2) (/ (* (+ 3 5) (/ 30 10)) 2))

; --> Lektion 1.2: Einfache Funktionen <--
; Eigene Funktion definieren:
; - (define <FunktionsName> (lambda [operand-1 operand-2 ...] (...Logik...) ))
; Eine Funktion aufrufen:
; - (function operand-1 operand-2 operand-3)

; Ökosteuer berechnen bei Ökosteueranteil von 7 Cent
(define oeko-steuer
  (lambda [preis-fuer-tankfuellung preis-pro-liter]
          (* (/ preis-fuer-tankfuellung preis-pro-liter) 7)))

; Eigene Funktion aufrufen
(oeko-steuer 4500 150)

; --> Spezial 1.3: Operatoren vs. Operanden <--
; Operatoren sind:
; - Standardfunktionen wie z. B: +, /, *, - für die vier Grundrechenarten
; - eigenen Funktionen: oeko-steuer
; - Pseudofunktionen: define, lambda
; - namenlose Funktionen (lambda-Ausdrücke)

; Operanden sind:
; - Zahlen: 3.14, 4500, 2/3
; - Variable: preis-pro-liter
; - Ausdrücke: (f ...)
; - boolesche Werte: #true und #false


;-----------[2. Aufschreiben von Funktionen]------------
; Regeln zum Aufschreiben von Funktionen (alle: https://johbra.github.io/EidP17/Regeln.pdf)

; --> Regel 1 <--
; Regel 1: Verwende aussagekräftige Namen für Funktionen und Variablen („sprechende Bezeichner”)!
(define endkapital
  (lambda [anfangskapital jahreszinssatz laufzeit-in-monaten]
    (+ anfangskapital
       (* anfangskapital
          (/ jahreszinssatz 100 12) laufzeit-in-monaten))))

; --> Regel 2 <--
; Regel 2: Beschreibe den Zweck der Funktion durch einen Satz, der das Resultat der Funktion in Abhängigkeit von ihren Argumenten beschreibt.
;; Aus dem anfangskapital, einem jahreszinssatz  und einer laufzeit-in-monaten wird
;; das Endkapital ermittelt, wobei die Zinsgutschrift einmalig am Ende der Laufzeit
;; erfolgt.
(define endkapital2
  (lambda [anfangskapital jahreszinssatz laufzeit-in-monaten]
    (+ anfangskapital
       (* anfangskapital
          (/ jahreszinssatz 100 12) laufzeit-in-monaten))))

; --> Regel 3 <--
; Regel 3: Schreibe Beispielanwendungen der Funktion auf, die das Resultat der Funktion mit dem Erwartungswert vergleicht. Die Auswertung der Ausdrücke muss dabei immer den Wahrheitswert #true liefern:
;; Aus dem anfangskapital, einem jahreszinssatz  und einer laufzeit-in-monaten wird
;; das Endkapital ermittelt, wobei die Zinsgutschrift einmalig am Ende der Laufzeit
;; erfolgt.
(define endkapital3
  (lambda [anfangskapital jahreszinssatz laufzeit-in-monaten]
    (+ anfangskapital
       (* anfangskapital
          (/ jahreszinssatz 100 12) laufzeit-in-monaten))))
;; Beispielanwendungen:
(= (endkapital 1000 0 24) 1000)   ;; => #true
(= (endkapital 1000 12 12) 1120)  ;; => #true
(= (endkapital 1000 12 24) 1240)  ;; => #true

; --> Regel 4 <--
; Regel 4: Definiere für jeden Zusammenhang zwischen Größen, die sich aus der Problembeschreibung ergeben, eine Funktion.
;; Ausgangsfunktion
(define kreisring-flaeche
  (lambda [radius-aussen radius-innen]
    (- (* 3.14 (* radius-aussen radius-aussen))
       (* 3.14 (* radius-innen  radius-innen)))))
;; Nun kann die Hilfsfunktion *kreis-flaeche definiert und genutzt werden
(define kreis-flaeche
  (lambda [radius]
    (* 3.14 (* radius radius))))
;; Daraus ergibt sich:
(define kreisring-flaeche2
  (lambda [radius-aussen radius-innen]
    (- (kreis-flaeche radius-aussen)
       (kreis-flaeche radius-innen))))

; --> Regel 5 <--
; Regel 5: Ersetze jede Konstante, deren Bedeutung sich nicht aus dem Kontext ergibt, durch einen sprechenden Variablennamen.
; (define <variablenname> <funktion|wert>)
(define myPI 3.14)
; Die Variable myPI kann nun genutzt werden
(define kreis-flaeche3
  (lambda [radius]
    (* myPI (* radius radius))))

; --> Operatoren zum Vergleich von Zahlen <--
; <, >, <=, >= (wie in Mathe)
(< 3 5)  ;; => #true, da 3 kleiner als 5
(> 3 5)  ;; => #false, da 3 nicht größer als 5
(>= 4 4) ;; => #true, da 4 größer gleich 4


;-----------[3. Fallunterscheidungen]------------

; --> Vergleichsausdrücke und Boolesche Ausdrücke <--
;; Wir kennen bereits <, >, <= und >=. Damit verbundene Ausdrücke können
;; nun aucg logisch miteinander verbunden werden mit den logische Operatoren:
;; - (and bool-1 bool-2) => logisched "und", gibt #true zurück, wenn ALLE bools #true sind
(and #true #true) ; => #true
(and (> 3 2) (< 2 3)) ; => #true
(and (> 3 2) (< 3 2)) ; => #false (nicht ALLE Ausdrücke sind #true)
;; - (or bool-1 bool-2)  => logisched "oder", gibt #true zurück, wenn MINDESTENS EIN bool #true ist
(or #true #true) ; => #true
(or (> 3 2) (< 2 3)) ; => #true
(or (> 3 2) (< 3 2)) ; => #true (MINDESTENS EIN Ausdruck ist #true)
(or (< 3 2) (> 2 3)) ; => #false (KEIN Ausdruck ist #true)
;; - (not bool-1) => logisches "nicht", negiert den boolschen Wert (#true -> #false) und (#false -> #true)
(not (> 3 2)) ; => #false, da der Ausdruck #true ergibt und das negiert wird
(not (< 3 2)) ; => #true, da der Ausdruck #false ergibt und das negiert wird

; --> COND (Fallunterscheidung) <--

; Grundlage (wenn frage-1 ist #true, dann antwort 1, sonst zu frage-2...)
; (cond
;   [frage-1 antwort-1]
;   [frage-2 antwort-2]
;   ...
;   [else antwort-n]) ; nicht notwendig


; Das cond-Skelett
;; berechnet aus einer gegebenen Stueckzahl
;; den Stueckpreis gemaess Preisstaffel
(define stueckpreis
  (lambda [stueckzahl]
    (cond
      [... ...]
      [... ...]
      [... ...])))

; Funktion: Wenn Stückzahl eine bestimmte Menge hat, gibt es MENGENRABATT
;; berechnet aus einer gegebenen Stueckzahl
;; den Stueckpreis gemaess Preisstaffel
(define stueckpreis2
  (lambda [stueckzahl]
    (cond
      [(and (>= stueckzahl 0)
            (<= stueckzahl 1000))  ...]
      [(and (> stueckzahl 1000)
            (<= stueckzahl 10000)) ...]
      [(> stueckzahl 10000)        ...])))

; Die Ausdrücke für die Berechnung der Antworten ergeben sich direkt aus der Tabelle für die Preisstaffelung:
;; berechnet aus einer gegebenen Stueckzahl
;; den Stueckpreis gemaess Preisstaffel
(define stueckpreis3
  (lambda [stueckzahl]
    (cond
      [(and (>= stueckzahl 0)
            (<= stueckzahl 1000))  1500]
      [(and (> stueckzahl 1000)
            (<= stueckzahl 10000)) 1250]
      [(> stueckzahl 10000)        975])))

; Nachdem die Funktion getestet wurde, können die Bedingungen vereinfacht werden:
(define stueckpreis4
  (lambda [stueckzahl]
    (cond
      [(<= stueckzahl 1000) 1500]
      [(<= stueckzahl 10000) 1250]
      [else 975])))


;-----------[4. Nicht-numerische Daten]------------

; ---> Symbole (Strings?) <---
; - Symbole sind eine einfache Möglichkeit für die Repräsentation nicht-numerischer Daten.
; - Symbole sind aufgebaut wie Variablennamen; damit sie nicht als solche interpretiert werden, ist ein Hochkomma voranzustellen.
; - Symbole dürfen Buchstaben, Ziffern und ein paar Sonderzeichen (keine Leerzeichen!) enthalten.
; - Symbole sind – wie Zahlen – atomare Daten.
; - Symbole werden – wie Zahlen – zu sich selbst ausgewertet.
'symbol 'KarlMarx 'Dies-ist-auch-ein-Symbol 'x1
(equal? 'Hallo 'Hallo) ;;=> #true
(equal? 'Karl 'Rosa)   ;;=> #false
(define hallo 'Hallo)
(equal? 'Hallo hallo)  ;;=> #true, wenn hallo für 'Hallo steht

; ---> 4.2: S-Ausdrücke (Strings + Zeichenketten) <---
; Ein S-Ausdruck ist
; - ein Atom, z.B. 27, ’Karl, ’ist
; - eine Folge von S-Ausdrücken, eingeschlossen in (), z.B.
     '(Karl ist 27) ; Liste mit 3 Elementen
     '((Dies ist) (eine Liste) (mit 3 Listen)) ; Liste mit 3 Listen
;   -> Solche S-Ausdrücke heißen LISTEN. (Man beachte die Rekursivität dieser Definition!)
; Atome sind entweder numerisch, boolesch oder symbolisch

; ---> 4.3: Darstellung von Formeln als S-Ausdrücke <---

; Die Formel x^2+3y-5
; wird beschrieben, durch den S-Ausdruck
'(ADD (EXP x 2) (SUB (MUL 3 y ) 5))

; ---> 4.4 : Konstruktion von Listen <---
; Ausgangspunkt für die Konstruktion einer Liste ist die leere Liste, die durch
span class="kw3"> empty
; oder
'()
; repräsentiert wird.

; Mit der Funktion cons kann ein Element als neues erstes Element einer Liste hinzugefügt werden.
(cons 'Karl empty)                            ;;=> (Karl)
(cons 'Rosa (cons 'Karl empty))               ;;=> (Rosa Karl)
(cons 'Klara (cons 'Rosa (cons 'Karl empty))) ;;=> (Klara Rosa Karl)

; Die Standardfunktion cons erwartet zwei Argumente:
; - ein neues erstes Element
; - eine Liste
; jede Liste kann man sich aus zwei Teilen bestehend vorstellen:
; - das erste Element
; - die Restliste

; ---> 4.5: Zerlegung von Listen <---
; Racket stellt zwei Funktionen bereit zum Zugriff auf die beiden Komponenten einer Liste:
; - first liefert – angewendet auf eine nicht leere Liste – das erste Element.
; - rest liefert – angewendet auf eine nicht leere Liste – die Restliste.
; Der Zusammenhang zwischen cons, first und rest kann durch die folgenden Gleichungen beschrieben werden:
; -> (first(cons elem liste))=elem
; -> (rest(cons elem liste))=liste
(first (cons 1 (cons 2 (cons 3 empty))))        ;;=> 1
(first (rest (cons 1 (cons 2 (cons 3 empty))))) ;;=> 2
(first empty) ;;=> first: expects a non-empty list; given: ()


; ---> 4.6: Rekursivität (Arbeit mit Listen) <---
;; Listen können beliebig lang werden. Eine LISTE-VON-SYMBOLEN (lvs) kann als
;; Datenstruktur wie folgt rekursiv definiert werden:
;; -> Eine LISTE-VON-SYMBOLEN ist entweder
;;    1. die leere Liste: empty ODER
;;    2. (cons s lvs), wobei s ein Symbol und lvs eine LISTE-VON-SYMBOLEN ist
;; -> Erkennen einer leeren Liste:
;;    - (empty? lvz)
;; -> Erkennen einer nicht-leeren Liste:
;;    - (cons? lvz)


; ---> 4.7: Verträge für Funktionen <---
;; Es soll geprüft werden können, ob in der Liste mit den Automarken 'BMW vorkommt
;; ermittelt, ob das Symbol 'BMW in der liste-von-symbolen auftritt
(define enthaelt-bmw1?
  (lambda [lvs] ...))

;; Ein Vertrag beschreibt, welche Arten von Daten (Datentypen) die Funktion als
;; Argumente/Parameter erwartet und welche Datenart die Funktion als Resultat liefert:
;; -> <Typ von Argument 1> ... <Typ von Argument n> -> <Typ des Resultats>
;; Für enthaelt-bmw? entspricht das:
;; -> enthaelt-bmw? : (list-of symbol) -> boolean

;; Überarbeitete Funktion:
;; ermittelt, ob das Symbol 'BMW in der liste-von-symbolen auftritt
;; enthaelt-bmw? : (list-of symbol) -> boolean
(define enthaelt-bmw?
  (lambda [lvs] ...))


; ---> 4.8: Angabe von Tests für enthaelt-bmw? <---
(check-expect (enthaelt-bmw? empty) #false)

(check-expect
 (enthaelt-bmw?
  (cons 'VW (cons 'Opel (cons 'Toyota empty))))
 #false)

(check-expect
 (enthaelt-bmw?
  (cons 'VW (cons 'BMW (cons 'Toyota empty))))
 #true)

; ---> 4.9: Anlegen einer Funktionsschablone <---
;; Da diese zwei Fälle, die leere und die nicht-leere Liste, unterscheidet, ergibt sich folgende Schablone:
 (define f
   (lambda [lvs]
     (cond [(empty? lvs) ...]
           [(cons? lvs)  ...])))

;; Eine nicht-leere Liste ist eine aus zwei Komponenten zusammengesetzte Datenstruktur:
;;   1. dem ersten Element
;;   2. der Restliste (ohne das erste Element)

;; Aus diesen Überlegungen ergibt sich folgende Schablone:
(define f
  (lambda [lvs]
    (cond
      [(empty? lvs) ...]
      [(cons? lvs)  ... (first lvs)
                    ... (rest lvs) ...])))

; ---> 4.10: Ausfüllen der Schablone für enthaelt-bmw? <---
;; Nun betrachten wir die Komponenten der nicht-leeren Liste. Falls das erste Element das gesuchte ist, muss die Funktion #true liefern:
(define enthaelt-bmw?
  (lambda [lvs]
    (cond
      [(empty? lvs) #false]
      [(cons? lvs)
       (cond [(equal? (first lvs) 'BMW) #true]
             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
             [else ... (rest lvs) ...])])))

;; Falls das gesuchte Symbol nicht das erste in der Liste ist, hängt das Ergebnis der Funktion davon ab,
;; ob es in der Restliste gefunden wird. Da die Restliste ja selbst wieder eine Liste-von-Symbolen ist, ist auf sie die Funktion enthaelt-bmw? anwendbar:
(define enthaelt-bmw?
  (lambda [lvs]
    (cond
      [(empty? lvs) #false]
      [(cons? lvs)
       (cond [(equal? (first lvs) 'BMW) #true]
             [else (enthaelt-bmw? (rest lvs))])])))


; ---> 4.11: Erweiterte rekursive Funktionsschablone <---
(define listen-funktion
  (lambda [lvs]
    (cond
      [(empty? lvs) ...]
      [else ... (first lvs) ...
            ... (listen-funktion (rest lvs)) ...])))
                 ;;;Rekursiver Aufruf;;;

; ---> 4.12: Liste als Resultate <---
;; Anwendung der Regeln für die Entwicklung rekursiver Funktionen auf Funktionen, die eine Liste als Resultat liefern.
;; Dem Gebrauchtwagenhändler soll eine Funktion zur Verfügung gestellt werden, mit dem er ein Modell aus seiner Angebotspalette entfernen kann.

;; -> Vertrag,Funktionskopf, Zweckbestimmung <-
;; entfernt eine Modell (symbol) aus der
;; Modellpalette (liste-von-symbolen)
;; entferne-modell: (list-of symbol) symbol -> (list-of symbol)
(define entferne-modell
  (lambda [modellpalette modell] ...))

;; -> Hinzufügen der Tests <-
;; entfernt eine Modell (symbol) aus der
;; Modellpalette (liste-von-symbolen)
;; entferne-modell: (list-of symbol) symbol -> (list-of symbol)
(check-expect (entferne-modell empty 'BMW) empty)
(check-expect (entferne-modell '(BMW) 'BMW) empty)
(check-expect (entferne-modell '(BMW) 'OPEL) '(BMW))
(check-expect (entferne-modell '(BMW OPEL FORD) 'TOYOTA) '(BMW OPEL FORD))
(check-expect (entferne-modell '(BMW OPEL FORD) 'OPEL) '(BMW FORD))
(define entferne-modell
   (lambda [modellpalette modell] ...))

;; -> Hinzufügen der Funktionsschablone <-
;; entfernt eine Modell (symbol) aus der
;; Modellpalette (liste-von-symbolen)
;; entferne-modell: (list-of symbol) symbol -> (list-of symbol)
(check-expect (entferne-modell empty 'BMW) empty)
(check-expect (entferne-modell '(BMW) 'BMW) empty)
(check-expect (entferne-modell '(BMW) 'OPEL) '(BMW))
(check-expect (entferne-modell '(BMW OPEL FORD) 'TOYOTA) '(BMW OPEL FORD))
(check-expect (entferne-modell '(BMW OPEL FORD) 'OPEL) '(BMW FORD))
(define entferne-modell
  (lambda [modellpalette modell]
    (cond
      [(empty? modellpalette) ...]
      [else ... (first modellpalette) ...
            ... (entferne-modell (rest modellpalette)  modell) ...])))

;; -> Vervollständigung des Funktionsrumpfs <-
;; entfernt eine Modell (symbol) aus der Modellpalette (liste-von-symbolen)
;; entferne-modell: (list-of symbol) symbol -> (list-of symbol)
(check-expect (entferne-modell empty 'BMW) empty)
(check-expect (entferne-modell '(BMW) 'BMW) empty)
(check-expect (entferne-modell '(BMW) 'OPEL) '(BMW))
(check-expect (entferne-modell '(BMW OPEL FORD) 'TOYOTA) '(BMW OPEL FORD))
(check-expect (entferne-modell '(BMW OPEL FORD) 'OPEL) '(BMW FORD))
(define entferne-modell
  (lambda [modellpalette modell]
    (cond [(empty? modellpalette) empty]
          [(equal? (first modellpalette) modell) (rest modellpalette)]
          [else (cons (first modellpalette)
                      (entferne-modell (rest modellpalette) modell))])))