BuK/IIm11/Studenten/sirorose

Wiki-Quelltext dieser Seite.

<language>Scheme</language>
= Übung 1=

<code id="4f61f9267be2b">

(define inf 
  (lambda () 
    (inf)))

(define q 
  (lambda (x) 
    (if (= x 3) 
      (inf) 
      (/ 35 (- x 3)))))
</code>

<run id="4f61f9267be8f">(q 5)</run>

Programmcode bitte strukturieren. Am besten in einem externen Scheme-Editor bearbeiten und dann ins PW kopieren. 

<tt>inf</tt> musste in Klammern gesetzt werden.

Die BuK IIm11 Seite ist sehr schön angelegt. Danke. Habe Kleinigkeiten modofiziert.

= Übung 2 =

=== Prinzipell Unlösbares ===

# Unzugängliches (wenigstens) für Computer
# Praktisch Unmögliches

==== Aufgabe 1 <tt>(Robert Rosenberger, Stefan Scheumann)</tt> ====

===== Unzugängliches (wenigstens) für Computer =====
* Durch fehlende Beschreibungssprache nicht maschinell verarbeitbar / formalisierbar.
* Viele Probleme vielschichtig und mit vielen (abhängigen) Parametern.
* Simulationen und KI ermöglichen ein Erschließen dieses Problembereichs und tragen somit zur Verkleinerung dieser Problemklasse bei.
* Beispiele: "Mag sie mich?", "Wer gewinnt am Samstag das Fussballspiel?"

===== Praktisch Unmögliches =====
* Probleme, die maschinell beschreibar jedoch nicht effizient lösbar sind (Grenzen vorhandener Ressourcen).
* Beispiele: Leistungsfähiges Schachprogramm, n-Queens-Problem und Rundreiseproblem in größeren Dimensionen und im letzteren Fall mit mehreren Parametern.


==== Aufgabe 5 ====

<code id="4f71e429cb6ad">
(define f 
  (lambda (n) 
    (cond
      ((= n 1) 1)
      ((even? n) (+ (f (/ n 2)) 1)) 
      ((odd? n) (/ 1 (f (- n 1))))
      )
    )
 )   


(define f_umkehr 
  (lambda (y) 
    (cond
      ((= y 1) 1)
      ((> y 1) (* 2 (f_umkehr (- y 1)))) 
      (else (+ (f_umkehr (/ 1 y)) 1))
       
    )
   )
)
(define memvalues (make-hashtable))
(define f_mem
  (lambda (x)
   (cond
    ((hashtable/contains? memvalues x) (hashtable/get memvalues x))
    ((= x 1) (hashtable/put! memvalues x 1))
    ((even? x) (hashtable/put! memvalues x (+ (f_mem (/ x 2)) 1)))
    ((odd? x) (hashtable/put! memvalues x (/ 1 (f_mem (- x 1))))))
    (hashtable/get memvalues x)
   )
)
</code>
<run id="4f71e429cb76a">
(f_mem 5)
</run>

= Hilbert-Hotel =

Herzlich willkommen im Hilbert Hotel, wir haben immer ein Zimmer für Sie bereit - mit uns werden Sie unendlich viel Spaß haben.


[[BuK/IIm11/Studenten/sirorose/hilbert|Hier gehts zum Hilberthotel]]

= Übung 4, Aufgabe 4 (Teilaufgabe 3) =

Illustrieren Sie den Beweis (Aufgabe 4.2) durch ein Scheme-Programm. 

<code id="4f8da37d4debf" hidden>
(define stream-car car)

(define stream-cdr
  (lambda (stm)
    (force (cdr stm))))

(define-syntax stream-cons
  (syntax-rules ()
    ((_ head tail) (cons head (delay tail)))))


  
(define stream-item
  (lambda (str k)
    (if (= k 0)
      (stream-car str)
      (stream-item (stream-cdr str) (- k 1)))))

(define stream->list
  (lambda (str n)
    (if (<= n 0)
      '()
      (cons 
        (stream-car str) 
        (stream->list (stream-cdr str) (- n 1))))))


(define print-stream
  (lambda (stm n)
    (cond
      ((<= n 0) (display "...\n"))
      (else
       (display (stream-car stm))
       (display ", ")
       (print-stream (stream-cdr stm) (- n 1))))))

(define stream-map
  (lambda (stm proc)
    (stream-cons
     (proc (string->number (stream-car stm)))
     (stream-map (stream-cdr stm) proc))))

(define natstream
  (lambda (start)
    (stream-cons (number->string start) (natstream (+ 1 start)))))

(define natzahlstream (stream-cons (number->string 0) (natstream 1)))
</code>



<code id="4f8da37d4df0b">
; Aufzählfunktion f für alle ungerade Zahlen (hier für M)
(define f
  (lambda (n)
    (number->string (+ 1 (* n 2)))))

; Aufzählfunktion g für alle gerade Zahle (hier für A*/M)
(define g
  (lambda (n)
    (number->string (* 2 n))))

(define generiere_aufzaehlbare_menge 
  (lambda (f)
    (stream-map natzahlstream f)))

(define menge-bis print-stream)

(define M (generiere_aufzaehlbare_menge f))
(define A*-M (generiere_aufzaehlbare_menge g))

(define chi_M
  (lambda (w)
    (letrec
        ((chihelper
          (lambda (i)
            (cond
              ((string=? (f i) w) #t)
              ((string=? (g i) w) #f)
              (else
               (chihelper (+ i 1)))))))
         (chihelper 0))))

</code>
<run id="4f8da37d4dfa8">
(menge-bis M 10) 
</run>
<run id="4f8da37d4e023">
(menge-bis A*-M 10) 
</run>
<run id="4f8da37d4e0a4">
(chi_M "9199")
</run>