Aufgaben

Aus ProgrammingWiki

< AuK < Teile und Herrsche 2 SS10

Archivierte Version vom 2010-04-19T12:17:51+00:00. Aktuelle Version

Inhaltsverzeichnis

1 Übungsaufgaben
2 Lösungen

Übungsaufgaben

Binäre Suche

Aufgabe 1 binär-Suche

Nur keine Angst, die Übung sieht schlimer aus als es tatsächlich ist.

Binär Such Maske mit sicherheits abfragen

(define bin-suche

 (lambda (ls wert)
   (bin-such ls wert)))

(define bin-such

 (lambda (ls wert)
   (cond
     [(number? wert)
   (cond
     [(eq? ls '()) "Fehler! Eingegebene Liste ist leer"]
     [(eq? wert '()) "Fehler! Eingegebener Wert ist leer"]
     [(list? wert) "Fehler! Der zusuchende Wert soll eine Liste sein!?!"]
     [(eq? (cdr ls) '()) 
      (cond
       [(eq? (car ls) wert) wert]
       [else "Element Nicht vorhanden + Liste besteht aus max einem Wert."])]
     [else (bint-suc (sort < ls) wert (listen-lang ls))])]
     [Else "Ausschließlich Zahlen sind als Suchabfrage erlaubt."])))

ls = Liste
wert = gesuchter Wert
i = länge der liste
wenn die unterste teilliste eine Linke-Liste ist entsteht ein Fehler!

(define bint-suc

 (lambda (ls wert i)
   (cond
     [(eq? i 2)(isers ls wert)]
     [(< wert (car (liste-r ls))) 
      (bint-suc (liste-l ls) wert (listen-lang (liste-l ls)))
      ]
     [(>= wert (car (liste-r ls))) ;Fehler Lokaliesiert irgend wo hier
      (bint-suc (liste-r ls) wert (listen-lang (liste-r ls))); oder eher hier
      ]
     )))

ermitteln der Länge einer Liste

(define list-lalng1

        (lambda (ls i)
          (cond
            [(not-list? ls)(+ i 1)]
            [else (list-lalng (cdr ls) (+ i 1))])))

(define list-lalng

        (lambda (ls i)
          (cond
            [(eq? ls '()) i]
         ;   [number? ls i]
            [else (list-lalng (cdr ls) (+ i 1))])))

(define listen-lang

 (lambda (ls)
   (list-lalng ls 0)))

Ermitteln der linken 50% Liste LLL

(define liste-l

 (lambda (ls)
   (list-linkses ls (/ (listen-lang ls) 2))))

(define list-linkses

 (lambda (ls laenge)
   (cond
     [(< laenge 1) '() ]
     [else (cons (car ls) (list-linkses (cdr ls) (- laenge 1)))])))

Ermitteln der rechten 50% Liste RRR

(define liste-ra

 (lambda (ls)
   (list-rechtest ls (modulo (listen-lang ls) 2))))

(define liste-r

 (lambda (ls)
   (list-rechtest ls (/ (listen-lang ls) 2))))

(define list-rechtest

 (lambda (ls laenge)
   (cond
     [(< laenge 1) ls]
     [else (list-rechtest (cdr ls) (- laenge 1))])))

BinäreSuche

Konzeptionel

(define ist-er-es

 (lambda (ls wert)
   (cond
     [(eq? ls '()) 'no]
     [(eq? (car ls) wert) (car ls)]
     [else (ist-er-es (cdr ls) wert)]
     )))

paar-durchsuchung
isers1 wird nicht genutzt

(define isers1

 (lambda (ls wert)
   (cond
     [(eq? ls '()) 'no]
     [(eq? (car ls) wert) (car ls)]
     [(eq? (cadr ls) wert) (cadr ls)]
     [else 'no]
     )))

(define isers

 (lambda (ls wert)
   (cond
     [(eq? ls '()) "unter Umständen ist ein Fehler aufgetreten! Die End-Liste ist leer!!!"]
     [(eq? (car ls) wert) "Wert Enthalten"]; für bint-suc i = 2
     [(eq? (cadr ls) wert) "Wert Enthalten"]; für bint-suc i = 2
     [(eq? (cddr ls) wert) "Wert Enthalten"]; für bint-suc i = 3;(!!!! Wichtig ansonsten entsteht eine endlose

sich selbst verarbeitende Schleife in bin-suc im falle das die vorletzte Teil Liste eine 3-er liste ist)

     [else "Wert nicht Enthalten"]
     )))

(define sort

 (lambda (rel ls)
   (cond 
     [(eq? '() ls)'()]
     [(eq? '() (cdr ls)) ls]
     [(Cond
       [(eq? rel <)(einf < (sort rel (cdr ls))(car ls) )]
       [(eq? rel >)(einf > (sort rel (cdr ls))(car ls) )]
       [else "Relation unzulässig!"])])))

(define einf

 (lambda (relatio ls wawert)
   (cond
     [(eq? ls '())(list wawert)]
     ;[(eq? wawert (car ls) ) (cons sortls wawert)]
     [(relatio wawert (car ls))(cons wawert ls)]
     [else (cons (car ls)(einf relatio (cdr ls) wawert))])))

;;;;; TESTLISTEN ;;;;;
;testliste "d" mit länge 18
(define d
  '(93 2 96 4 86 5 6 3 34 7 38 45 3333 44 87 10 23 18))
;testliste "c" mit länge 19
(define c
  '(93 2 96 4 86 5 6 3 34 7 38 45 3333 44 87 10 23 53 19))
;testliste "c" mit länge 19
(define c2
  '(93 2 245 4 86 5 6 3 34 7 38 45 3333 44 87 10 23 53 19))
;testliste "b" mit länge 20
(define b
  '(93 2 96 4 86 5 6 3 34 7 38 45 3333 44 87 10 23 53 233 20))
;testliste "b2" mit länge 20
(define b2
  '(91 2 96 4 86 5 6 3 34 7 38 45 3333 44 87 10 23 53 233 20))
;testliste "a" mit länge 21
(define a
  '(93 2 96 4 86 5 6 3 34 7 38 45 3333 44 87 10 23 53 233 17 21))
;testliste "z" mit länge 23
(define z
  '(93 2 4 86 5 6 3 34 7 38 45 3333 44 87 10 27 53 233 17 25 102 23))
;genervt-von-unlogischen-Fehlern-sei-testliste "t" mit länge 20
(define t
  '(1 1 96 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 233 1))

;;;;;Hilfe anfragen
;;;eingabe hilfe
(define hilfe-bin-suche
  "Eingabe Format: (bin-such <zu-durchsuchende-Liste> <zu-Suchender-Wert>)")
(define bin-such-wie?
  hilfe-bin-suche)
(define bin-suche-wie?
  hilfe-bin-suche)
(define hilfe-bin-such
  hilfe-bin-suche)
(define hilfe-fehler
  "für hilfe: hilfe-bin-suche eingeben / oder: tipp-xy wobei x ein Buchstabe ist und y eine Ziffer / für die 

Buchstaben: a, b, c und l(für lösung) die Tipps mit gleichen Buchstaben gehören zusammen / für Ziffern: 1, 2, 3, 4 

die Zahlen stehen für die Tipp-stufe")

;;;Random
(define hilfe-zufalls-liste
  "Faule Sau! Schreib selber ne' Liste!!!!")
(define hilfe-zufallsliste
  hilfe-zufalls-liste)

;;;Tipps
(define tipp-a1 "für Tippfaule es giebt Testlisten: a ,b , b2, c, c2, d, t, z")
(define tipp-a2 "> (bin-such a 100) = user break || > (bin-such b 100) = user break || > (bin-such c 100) = Wert 

nicht Enthalten || > (bin-such c2 100) = user break || > (bin-such d 100) = Wert nicht Enthalten || > (bin-such z 

100) = Wert nicht Enthalten || > (bin-such t 100) = Wert nicht Enthalten")
(define tipp-a3
"> (bin-such '(1 1 96 1 1 1 3 1 1 1 1 1 1 1 1 1 1 1 233 1) 100) = Wert nicht Enthalten || > (bin-such '(93 2 96 4 

86 5 6 3 34 7 38 45 3333 44 87 10 23 53 233 20) 100) = user break")
(define tipp-a4
  "(eq? i 3)(isers... hups...")

(define tipp-b1 " alle Listen werden automatisch aufsteigend sortiert ")
(define tipp-b2 " Testliste a, Zahlen von (einschließlich) 96 bis 232 hmpf...")
(define tipp-b3 "Die Funktionen mit einer Zahl am ende ihres Namens sind irrelevant, konzentration auf die direkten 

Funktionen der binären Suche")
(define tipp-b4 "der Fehler ist eine Fehlende(!) Zeile")


(define tipp-c1 "gieb ein (bin-suche c2 100)")
(define tipp-c2 "bleib beim wert 100 und versuche die anderen Testlisten und vergleiche die Reaktionen von Dr 

Scheme!")
(define tipp-c3
  "du Willst einen Tip: gieb ein (sort < c2) und untersuche die letzten drei Zahlen")
(define tipp-c4 "ernsthaft... versuch es nochmal, denke darüber nach was mit der 100 in der Testliste c2 passiert, 

wie läuft das ganze ab?! Tipp aus Gnade: 3-er Liste... hmpf...")

(define tipp-l1 "Der Fehler ist eine fehlende Bedingung in einem Cond")
(define tipp-l2 "Wenn eine Liste zerteilt wird und die Suche in eine Dreie-Elemente-Listen mündet kommt dieser 

Quellcode nicht mehr aus der untersuchung dieser Drei Elemente Liste heraus!")
(define tipp-l3 "der Fehler liegt NICHT an den BESTEHENDEN Bedingungen in bint-suc diese sind Richtig aber in 

bint-suc fehlt noch eine Bedingung!")
(define tipp-l4 "Der Fehler liegt in bint-suc dort fehlt im Cond die Bedingung [(eq? i 3)(isers ls wert)] ziemlich 

fiess was... ich habe etwa 1h und 45min gebraucht")

"---------------------------------------------------------------------------" "Für Hilfe: hilfe-bin-suche eingeben " "Für Tipps: tipp-xy wobei x ein Buchstabe ist und y eine Ziffer" "Für die Buchstaben: a, b, c und l(für Lösung)" "Die Tipps mit gleichen Buchstaben gehören zusammen" "Für die Ziffern: 1, 2, 3, 4 die Ziffern stehen für die Tipp-intensitäts-stufe" "(Oder sollten das zumindestens)" "---------------------------------------------------------------------------" "!!!ACHTUNG!!! vorm verändern des Quellcodes, von diesem eine Kopie anlegen!" "---------------------------------------------------------------------------"

Multiplikation großer ganzer Zahlen nach KARATSUBA und OFMAN

Lösen Sie, unter Verwendung der Kenntnisse aus Teile und Herrsche 2: Der Algorithmus von KARATSUBA und OFMAN, folgende Rechenaufgaben:

3812 \cdot 3264
837147 \cdot 479253
34 \cdot 56

Schnelle Matrixmultiplikation nach STRASSEN

Gegeben sind folgende zwei Matrizen A und B

A=\begin{pmatrix} 3 & 4 & 8 & 9\\ 1 & 5 & 9 & 2\\ 5 & 7 & 4 & 3\\ 2 & 3 & 8 & 1 \end{pmatrix} und

B=\begin{pmatrix} 3 & 2 & 8 & 6\\ 1 & 4 & 9 & 5\\ 7 & 6 & 4 & 3\\ 2 & 9 & 2 & 3 \end{pmatrix}

Berechnen Sie das Produkt der gegebenen Matrizen mithilfe des Algorithmus von Strassen.

Lösungen

Die Lösungen zu den Aufgaben findet man hier.