#lang racket

(display "Musterlösung für Übungsblatt 5 - Strings")
(newline)
;Aufgabe 1 - ohne vordefinierte Prozedur char-downcase
(define (toLower string)
  (list->string (toLower-lst (string->list string)))
  )

(define (toLower-lst lst)
  (cond ((null? lst) '())
        ((isUpperCase (car lst)) (cons (lowerChar (car lst)) (toLower-lst (cdr lst))))
        (else (cons (car lst) (toLower-lst (cdr lst))))
        )
  )

(define (lowerChar c) (integer->char (+ (char->integer c) 32)))

(define (isUpperCase c)
  (and (>= (char->integer c) 65) (<= (char->integer c) 90)) ; A - Z
  )

(display "Beispiele - Aufgabe 1")
(newline)
(toLower "HALLO")
(toLower "Das ist Ein TeST")

;Aufgabe 2
(define (countchar string char)
  (countchar-lst (string->list string) char)
  )

(define (countchar-lst lst char)
  (cond ((null? lst) 0)
        ((char=? (car lst) char) (+ 1 (countchar-lst (cdr lst) char)))
        (else (countchar-lst (cdr lst) char))
        )
  )


(display "Beispiele - Aufgabe 2")
(newline)
(countchar "Hallo" #\l)
(countchar "Ein ganz normaler Satz." #\n)

;Aufgabe 3
(define (custom-substring string index length)
  (list->string (substring-lst (string->list string) index length))
  )

(define (substring-lst lst index length)
  (cond ((null? lst) '())
        ((= length 0) '())
        ((> index 0) (substring-lst (cdr lst) (- index 1) length))
        ((> length 0) (cons (car lst) (substring-lst (cdr lst) 0 (- length 1))))
        (else '())
        )
  )

(display "Beispiele - Aufgabe 3")
(newline)
(custom-substring "Hallo wie gehts?" 6 3)
(custom-substring "Test" 42 10)
(custom-substring "Test" 0 10)

;Aufgabe 4
(define (hasPrefix string prefix)
  (hasPrefix-lst (string->list string) (string->list prefix))
  )

(define (hasPrefix-lst lst plst)
  (cond ((and (null? lst) (not (null? plst))) #f) ; wenn Ende von lst erreicht aber nicht von plst
        ((null? plst) #t)
        ((not (char=? (car lst) (car plst))) #f)
        (else (hasPrefix-lst (cdr lst) (cdr plst)))
        )
  )

(display "Beispiele - Aufgabe 4")
(newline)
(hasPrefix "my_test" "my_")
(hasPrefix "mx_test" "my_")
(hasPrefix "he" "hey")
(hasPrefix "test" "test")

;Aufgabe 5 + 6
(define (caeser-encrypt string n)
  (list->string (caeser-encrypt-lst (string->list string) n))
  )

(define (caeser-encrypt-lst lst n)
  (cond ((null? lst) '())
        (else (cons (integer->char (modulo (+ (char->integer (car lst)) n) 128))
                    (caeser-encrypt-lst (cdr lst) n)))
        )
  )

(define (caeser-decrypt string n)
  (list->string (caeser-decrypt-lst (string->list string) n))
  )

(define (caeser-decrypt-lst lst n)
  (cond ((null? lst) '())
        (else (cons (integer->char (modulo (- (char->integer (car lst)) n) 128))
                    (caeser-decrypt-lst (cdr lst) n)))
        )
  )

(display "Beipsiele - Aufgabe 5 und 6")
(newline)
(define geheim (caeser-encrypt "Ein Test" 5))
(display "Ergebnis aus caesar encrypt wird als geheim definiert: Ein Test -> ")geheim(display " -> geheim -> ")(caeser-decrypt geheim 5)


;Aufgabe 7
(define (transform operation . args )
  (transform-lst operation args)
  )

(define (transform-lst operation lst)
    (cond ((null? lst) '())
        (else (cons (operation (car lst)) (transform-lst operation (cdr lst))))
        )
  )


(display "Beispiele - Aufgabe 7")
(newline)
(transform (lambda (y) (* y y)) 1 2 3 4 5)
(define (machGerade y) (if (odd? y) (+ y 1) y))
(transform machGerade 1 2 3 4 5)

;Aufgabe 8 iterativ
(define (stringformat-iter format . x)
  (list->string (stringformat-iter-lst (string->list format) x '() )))

(define (stringformat-iter-lst format lst new)
  (cond ((null? format)new)
        ((not(char=? (car format) #\*))(stringformat-iter-lst (cdr format)
                                                              lst
                                                              (append  new (list(car format) ))))
        (else (stringformat-iter-lst (cdr format)
                                     (cond ((> (length lst) 1) (cdr lst))
                                           (else lst))
                                     (append new (string->list (car lst)))))))

;Aufgabe 8 rekursiv
(define (stringformat-rek format . x)
  (list->string (stringformat-rek-lst (string->list format) x)))

(define (stringformat-rek-lst format lst)
  (cond ((null? format) '())
        ((char=? (car format) #\*)(stringformat-rek-lst (append (string->list (car lst))(cdr format))
                                                        (cond ((> (length lst) 1) (cdr lst))
                                                              (else lst))))
        (else (cons (car format)
                    (stringformat-rek-lst (cdr format) lst)))))


(display "Beipsiele - Aufgabe 8")
(newline)
(stringformat-rek "Hallo * heute ist es *" "Welt" "schoen")
(stringformat-rek "* ist ein * Fach, das ist *" "Algorithmik" "super")
(stringformat-rek "* ist ein * Fach, das ist *" "Chemie" "blödes" "schade")