VU Software Paradigmen / SS 2015

Größe: px
Ab Seite anzeigen:

Download "VU Software Paradigmen / SS 2015"

Transkript

1 VU Software Paradigmen / SS 2015 Stephan Frühwirt Institute for Software Technology i S T Institute for Software Technology Stephan Frühwirt 1

2 Inhalt Beweise in EXP 1. Beweise in EXP Abgabe Institute for Software Technology Stephan Frühwirt 2

3 Beweise in EXP Sprache A - einfache arithmetische Ausdrücke ((10) + (9)) + (3)) Institute for Software Technology Stephan Frühwirt 3

4 Sprache A - einfache arithmetische Ausdrücke ((10) + (9)) + (3)) Sprache V - arithmetische Ausdrücke mit Variablen (((x) + (2)) + (y)) + (z) Environment ω(x) Institute for Software Technology Stephan Frühwirt 4

5 Sprache A - einfache arithmetische Ausdrücke ((10) + (9)) + (3)) Sprache V - arithmetische Ausdrücke mit Variablen (((x) + (2)) + (y)) + (z) Environment ω(x) Sprache T - Sprache der Therme plus(plus(x,y),plus(eins,z)) Institute for Software Technology Stephan Frühwirt 5

6 Sprache A - einfache arithmetische Ausdrücke ((10) + (9)) + (3)) Sprache V - arithmetische Ausdrücke mit Variablen (((x) + (2)) + (y)) + (z) Environment ω(x) Sprache T - Sprache der Therme plus(plus(x,y),plus(eins,z)) Sprache COND C - Sprache der Konditionale if is0?(sub(x)) then add0(x) else sub(x) Institute for Software Technology Stephan Frühwirt 6

7 Sprache A - einfache arithmetische Ausdrücke ((10) + (9)) + (3)) Sprache V - arithmetische Ausdrücke mit Variablen (((x) + (2)) + (y)) + (z) Environment ω(x) Sprache T - Sprache der Therme plus(plus(x,y),plus(eins,z)) Sprache COND C - Sprache der Konditionale if is0?(sub(x)) then add0(x) else sub(x) Sprache E - Sprache der Ausdrücke Rekursive Funktionen Institute for Software Technology Stephan Frühwirt 7

8 Beweise von EXP-Programmen Idee Beweis durch Induktion Institute for Software Technology Stephan Frühwirt 8

9 Beweise von EXP-Programmen Idee Beweis durch Induktion Hypothese Basis Schritt Institute for Software Technology Stephan Frühwirt 9

10 Beweise von EXP-Programmen Idee Beweis durch Induktion Funktion schreiben Hypothese Basis Schritt Institute for Software Technology Stephan Frühwirt 10

11 1. Beweise in EXP Abgabe Institute for Software Technology Stephan Frühwirt 11

12 Angabe Beweise in EXP Schreiben Sie eine Funktion in EXP über den Datentyp der natürlichen Zahlen inkl. Null (N 0 : plus, minus, div, mult, lt?, eq?), die einen Parameter x entgegen nimmt und als Ergebnis berechnet: ω(x)! Zeigen Sie die Korrektheit Ihrer Implementierung. Institute for Software Technology Stephan Frühwirt 12

13 Lösung - Funktion Pseudocode: EXP-Programm: Institute for Software Technology Stephan Frühwirt 13

14 Lösung - Funktion Pseudocode: f u n c t i o n f a c ( x ) i f x = 0 then f a c := 1 e l s e f a c := x f a c ( x 1 ) ; EXP-Programm: Institute for Software Technology Stephan Frühwirt 14

15 Lösung - Funktion Pseudocode: f u n c t i o n f a c ( x ) i f x = 0 then f a c := 1 e l s e f a c := x f a c ( x 1 ) ; EXP-Programm: δ fac = if eq?(x, 0) then 1 else mult(x, fac(minus(x, 1))) Institute for Software Technology Stephan Frühwirt 15

16 Lösung - Hypothese ( ) ω ENV : I δ, ω, fac(x) = ω(x)! Institute for Software Technology Stephan Frühwirt 16

17 Lösung - Basis Beweise in EXP ω(x) ( = 0 ) I δ, ω, fac(x) ( ) = I δ, ω, if eq?(x,0) then 1 else mult(x, fac(minus(x, 1))) ( ) NR: I δ, ω, eq?(x, 0) = eq?(i (δ, ω, x), I (δ, ω, 0)) = eq?(ω(x), 0) = eq?(0, 0) = 0 == 0 = T = I (δ, ω, 1) = 1 = 0! Institute for Software Technology Stephan Frühwirt 17

18 Lösung - Schritt Beweise in EXP Schritt: ( ω(x) = ) n + 1 I δ, ω, fac(x) ( ) = I δ, ω, if eq?(x,0) then 1 else mult(x, fac(minus(x, 1))) ( = I ( ) NR: I δ, ω, eq?(x, 0) = eq?(i (δ, ω, x)), I (δ, ω, 0)) = eq?(ω(x), 0) = eq?(n + 1, 0) = n + 1 == 0 = F da n > 0 ) δ, ω, mult(x, fac(minus(x, 1))) = mult(i (δ, ω, x), I ( δ, ω, fac(minus(x, 1)) ) ) Institute for Software Technology Stephan Frühwirt 18

19 Lösung - Schritt ( ) Neues Environment : ω (x) = I δ, ω, minus(x, 1) = minus(i (δ, ω, x), I (δ, ω, 1)) = minus(ω(x), 1) = minus(n + 1, 1) = n ( ) = mult(ω(x), I δ, ω, fac(x) ) i.h. = mult(ω(x), ω (x)!) = mult(n + 1, n!) = (n + 1) n! = (n + 1!) Institute for Software Technology Stephan Frühwirt 19

20 1. Beweise in EXP Abgabe Institute for Software Technology Stephan Frühwirt 20

21 Angabe Beweise in EXP Schreiben sie eine Funktion in EXP über Listen und natürliche Zahlen inkl. Null L + N 0 (L: first, rest, build, atom?, eq?, N 0 : plus, minus, div, mult, lt?, eq?), welches die Anzahl der enthaltenen Listen in einer beliebig verschachtelten Liste berechnet. Bsp.: [ [1 2] [ [1] [1] ] ] Institute for Software Technology Stephan Frühwirt 21

22 Lösung - Funktion Bsp.: [ [1, 2] [ [1] [1] ] ] Institute for Software Technology Stephan Frühwirt 22

23 Lösung - Funktion Bsp.: [ [1, 2] [ [1] [1] ] ] δcountlists = minus(countlists2(x), 1) Institute for Software Technology Stephan Frühwirt 23

24 Lösung - Funktion Bsp.: [ [1, 2] [ [1] [1] ] ] δcountlists = minus(countlists2(x), 1) δcountlists2 = if equal?(x, []) then 1 else if atom?(first(x)) then countlists2(rest(x)) else plus(countlists2(first(x)), countlists2(rest(x))) Institute for Software Technology Stephan Frühwirt 24

25 1. Beweise in EXP Abgabe Institute for Software Technology Stephan Frühwirt 25

26 Angabe Beweise in EXP Schreiben Sie eine Scalafunktion append die zwei Listen zusammenhängt. Beweisen Sie, dass gilt: append(as, append(bs, cs)) = append(append(as, bs), cs) Institute for Software Technology Stephan Frühwirt 26

27 Lösung - Funktion d e f append [T ] ( as : L i s t [T], bs : L i s t [T ] ) : L i s t [T] = as match{ case N i l => bs case x : : xs => x : : append ( xs, bs ) } Institute for Software Technology Stephan Frühwirt 27

28 Lösung - Hypothese append(as, append(bs, cs)) = append(append(as, bs), cs)) Idee Induktiver Beweis über as! Institute for Software Technology Stephan Frühwirt 28

29 Lösung - Basis append(as, append(bs, cs)) = append(append(as, bs), cs)) Basis Wir ersetzen as durch Nil append(nil, append(bs, cs)) Institute for Software Technology Stephan Frühwirt 29

30 Lösung - Basis append(as, append(bs, cs)) = append(append(as, bs), cs)) Basis Wir ersetzen as durch Nil append(nil, append(bs, cs)) = append(bs, cs) [def. append l.r.] Institute for Software Technology Stephan Frühwirt 30

31 Lösung - Basis append(as, append(bs, cs)) = append(append(as, bs), cs)) Basis Wir ersetzen as durch Nil append(nil, append(bs, cs)) = append(bs, cs) [def. append l.r.] = append(append(nil, bs), cs) [def. append r.l] Institute for Software Technology Stephan Frühwirt 31

32 Lösung - Schritt append(as, append(bs, cs)) = append(append(as, bs), cs)) Schritt as wird um a erweitert append(a::as, append(bs, cs)) Institute for Software Technology Stephan Frühwirt 32

33 Lösung - Schritt append(as, append(bs, cs)) = append(append(as, bs), cs)) Schritt as wird um a erweitert append(a::as, append(bs, cs)) = a::append(as, append(bs, cs)) [def. append l.r] Institute for Software Technology Stephan Frühwirt 33

34 Lösung - Schritt append(as, append(bs, cs)) = append(append(as, bs), cs)) Schritt as wird um a erweitert append(a::as, append(bs, cs)) = a::append(as, append(bs, cs)) [def. append l.r] = a::append(append(as, bs), cs) [i.h. l.r.] Institute for Software Technology Stephan Frühwirt 34

35 Lösung - Schritt append(as, append(bs, cs)) = append(append(as, bs), cs)) Schritt as wird um a erweitert append(a::as, append(bs, cs)) = a::append(as, append(bs, cs)) [def. append l.r] = a::append(append(as, bs), cs) [i.h. l.r.] = append(a::append(as, bs), cs) [def. append r.l] Institute for Software Technology Stephan Frühwirt 35

36 Lösung - Schritt append(as, append(bs, cs)) = append(append(as, bs), cs)) Schritt as wird um a erweitert append(a::as, append(bs, cs)) = a::append(as, append(bs, cs)) [def. append l.r] = a::append(append(as, bs), cs) [i.h. l.r.] = append(a::append(as, bs), cs) [def. append r.l] = append(append(a::as, bs), cs) [def. append r.l.] Institute for Software Technology Stephan Frühwirt 36

37 Lösung - Schritt append(as, append(bs, cs)) = append(append(as, bs), cs)) Schritt as wird um a erweitert append(a::as, append(bs, cs)) = a::append(as, append(bs, cs)) [def. append l.r] = a::append(append(as, bs), cs) [i.h. l.r.] = append(a::append(as, bs), cs) [def. append r.l] = append(append(a::as, bs), cs) [def. append r.l.] q.e.d Institute for Software Technology Stephan Frühwirt 37

38 Abgabe EXP Beweise über ganze Zahlen Beweise über Listen Institute for Software Technology Stephan Frühwirt 38

39 Abgabe Beweise in EXP Abgabe 20. Mai, 16:00 Uhr vor dem IST Sekretariat Textverarbeitungsprogramm L A TEX Word... Handschriftliche Abgaben werden nicht bewertet! Institute for Software Technology Stephan Frühwirt 39

40 Abgabe Fragen? Institute for Software Technology Stephan Frühwirt 40

SWP Funktionale Programme

SWP Funktionale Programme SWP Funktionale Programme Berhard Aichernig und Alexander Felfernig Institut für Softwaretechnologie {bernhard.aichernig,alexander.felfernig}@ist.tugraz.at Institute for Software Technology Inhalt Einfache

Mehr

Einfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie wotawa@ist.tugraz.at

Einfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie wotawa@ist.tugraz.at Inhalt SWP Funktionale Programme (2. Teil) Einfache Ausdrücke Datentypen Rekursive funktionale Sprache Franz Wotawa Institut für Softwaretechnologie wotawa@ist.tugraz.at Interpreter für funktionale Sprache

Mehr

SWP Prüfungsvorbereitung

SWP Prüfungsvorbereitung 20. Juni 2011 1 Grammatiken 2 LL(1) 3 EXP 4 Datentypen 5 LP Grammatiken Angabe Erstellen Sie First- und Follow-Mengen aller Non-Terminale der folgenden Grammatik. S a S S B y B A C A A b b A x A ɛ C c

Mehr

Informatik I. 9. Nachweis von Programmeigenschaften. Jan-Georg Smaus. Albert-Ludwigs-Universität Freiburg. 2. Dezember 2010

Informatik I. 9. Nachweis von Programmeigenschaften. Jan-Georg Smaus. Albert-Ludwigs-Universität Freiburg. 2. Dezember 2010 Informatik I 9. Nachweis von Programmeigenschaften Jan-Georg Smaus Albert-Ludwigs-Universität Freiburg 2. Dezember 2010 Jan-Georg Smaus (Universität Freiburg) Informatik I 2. Dezember 2010 1 / 30 Informatik

Mehr

Softwareparadigmen EXP-Compiler Dokumentation v1.1 ( )

Softwareparadigmen EXP-Compiler Dokumentation v1.1 ( ) Softwareparadigmen EXP-Compiler Dokumentation v1.1 (8.5.2016) Stephan Frühwirt Inhaltsverzeichnis 1 Aufbau, Tools und Ausführung 2 1.1 Ausführung....................................... 2 2 Sprachdefinition

Mehr

Theorembeweiserpraktikum SS 2016

Theorembeweiserpraktikum SS 2016 Institut für Programmstrukturen und Datenorganisation Lehrstuhl Programmierparadigmen Am Fasanengarten 5 76131 Karlsruhe http://pp.ipd.kit.edu/ Theorembeweiserpraktikum SS 2016 http://pp.ipd.kit.edu/lehre/ss2016/tba

Mehr

Softwareparadigmen SS 2015 Equational Reasoning in Scala

Softwareparadigmen SS 2015 Equational Reasoning in Scala Softwareparadigmen SS 2015 Equational Reasoning in Scala Benedikt Maderbacher, Stephan Frühwirt Inhaltsverzeichnis 1 Referential Transparency 1 2 Equational Reasoning 2 2.1 Patternmatching...........................

Mehr

LOOP-Programme 1. Def (Meyer/Ritchie). LOOP-Programme werden induktiv aufgebaut aus den (Basis-) Anweisungen. Führe P X-mal aus ) LOOP-Programme 2

LOOP-Programme 1. Def (Meyer/Ritchie). LOOP-Programme werden induktiv aufgebaut aus den (Basis-) Anweisungen. Führe P X-mal aus ) LOOP-Programme 2 LOOP-Programme 1 LOOP-Programme verwenden (jeweils) endlich viele Variablen aus VAR := {X 0,X 1,X 2,...}, oft nur mit X,Y,Z,U,V,W bezeichnet, die als Register fungieren. Slide 1 Def (Meyer/Ritchie). LOOP-Programme

Mehr

Die Korrektheit von Mergesort

Die Korrektheit von Mergesort Die Korrektheit von Mergesort Christoph Lüth 11. November 2002 Definition von Mergesort Die Funktion Mergesort ist wie folgt definiert: msort :: [Int]-> [Int] msort xs length xs

Mehr

Workshop Einführung in die Sprache Haskell

Workshop Einführung in die Sprache Haskell Workshop Einführung in die Sprache Haskell Nils Rexin, Marcellus Siegburg und Alexander Bau Fakultät für Informatik, Mathematik und Naturwissenschaften Hochschule für Technik, Wirtschaft und Kultur Leipzig

Mehr

Einführung in die funktionale Programmierung

Einführung in die funktionale Programmierung Einführung in die funktionale Programmierung Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 26. Oktober 2006 Haskell - Einführung Syntax Typen Auswertung Programmierung

Mehr

Mächtigkeit von WHILE-Programmen

Mächtigkeit von WHILE-Programmen Mächtigkeit von WHILE-Programmen Prof. Dr. Berthold Vöcking Lehrstuhl Informatik 1 Algorithmen und Komplexität RWTH Aachen 1 / 23 Turingmaschine (TM) M = (Q, Σ, Γ, B, q 0, q, δ) Unendliches Band... 0 c

Mehr

Formale Methoden in der Informatik Wiederholung klassische Logik Konkrete Datentypen (algebraische Strukturen) Abstrakte Datentypen

Formale Methoden in der Informatik Wiederholung klassische Logik Konkrete Datentypen (algebraische Strukturen) Abstrakte Datentypen Was bisher geschah Formale Methoden in der Informatik Wiederholung klassische Logik Konkrete Datentypen (algebraische Strukturen) Abstrakte Datentypen Syntax: Signatur Semantik: Axiome (FOL-Formeln, meist

Mehr

Konzepte von Programmiersprachen

Konzepte von Programmiersprachen Konzepte von Programmiersprachen Kapitel 3: Ausdrücke Phillip Heidegger Universität Freiburg, Deutschland SS 2009 Phillip Heidegger (Univ. Freiburg) Konzepte von Programmiersprachen KvP 1 / 17 Inhalt Let

Mehr

Theoretische Informatik SS 03 Übung 3

Theoretische Informatik SS 03 Übung 3 Theoretische Informatik SS 03 Übung 3 Aufgabe 1 a) Sind die folgenden Funktionen f : partiell oder total: f(x, y) = x + y f(x, y) = x y f(x, y) = x y f(x, y) = x DIV y? Hierbei ist x DIV y = x y der ganzzahlige

Mehr

Lösung Probeklausur Informatik I

Lösung Probeklausur Informatik I Lösung Probeklausur Informatik I 1 Lösung Aufgabe 1 (5 Punkte) Algorithmen und Programme Was ist der Unterschied zwischen einem Algorithmus und einem Programm? Ein Algorithmus ist eine Vorschrift zur Durchführung

Mehr

Was bisher geschah. deklarative Programmierung. funktionale Programmierung (Haskell):

Was bisher geschah. deklarative Programmierung. funktionale Programmierung (Haskell): Was bisher geschah deklarative Programmierung funktional: Programm: Menge von Termgleichungen, Term Auswertung: Pattern matsching, Termumformungen logisch: Programm: Menge von Regeln (Horn-Formeln), Formel

Mehr

Klausur Programmierung WS 2002/03

Klausur Programmierung WS 2002/03 Klausur Programmierung WS 2002/03 Prof. Dr. Gert Smolka, Dipl. Inf. Thorsten Brunklaus 14. Dezember 2002 Leo Schlau 45 Vor- und Nachname Sitz-Nr. 4711 007 Matrikelnummer Code Bitte öffnen Sie das Klausurheft

Mehr

Programmierung und Modellierung

Programmierung und Modellierung Programmierung und Modellierung Benutzerdefinierte Datentypen Martin Wirsing in Zusammenarbeit mit Moritz Hammer SS 2009 2 Inhalt Kap. 7 Benutzerdefinierte Datentypen 1. Aufzählungstypen 2. Typen mit zusammengesetzten

Mehr

Kapitel 3: Eine einfache Programmiersprache. Programmieren in Haskell 1

Kapitel 3: Eine einfache Programmiersprache. Programmieren in Haskell 1 Kapitel 3: Eine einfache Programmiersprache Programmieren in Haskell 1 Datentypen, Datentypdefinitionen data Instrument = Oboe HonkyTonkPiano Cello VoiceAahs data Musik = Note Ton Dauer Pause Dauer Musik

Mehr

Rekursive Funktionen Basisfunktionen

Rekursive Funktionen Basisfunktionen Rekursive Funktionen Basisfunktionen die nullstellige Funktion Z, die den konstanten Wert 0 liefert, die Funktion S : N N, bei der jeder natürlichen Zahl ihr Nachfolger zugeordnet wird, die Funktion P

Mehr

Breitensuche BFS (Breadth First Search)

Breitensuche BFS (Breadth First Search) Breitensuche BFS (Breadth First Search) Algorithmus BREITENSUCHE EINGABE: G = (V, E) als Adjazenzliste, Startknoten s V 1 Für alle v V 1 If (v = s) then d[v] 0 else d[v] ; 2 pred[v] nil; 2 Q new Queue;

Mehr

Wiederholung. Organisatorisches. VL-11: LOOP und WHILE Programme I. (Berechenbarkeit und Komplexität, WS 2017) Gerhard Woeginger

Wiederholung. Organisatorisches. VL-11: LOOP und WHILE Programme I. (Berechenbarkeit und Komplexität, WS 2017) Gerhard Woeginger Organisatorisches VL-11: LOOP und WHILE Programme I (Berechenbarkeit und Komplexität, WS 2017) Gerhard Woeginger Nächste Vorlesung: Mittwoch, November 29, 14:15 15:45 Uhr, Roter Hörsaal Webseite: http://algo.rwth-aachen.de/lehre/ws1718/buk.php

Mehr

Bash-Skripting Linux-Kurs der Unix-AG

Bash-Skripting Linux-Kurs der Unix-AG Bash-Skripting Linux-Kurs der Unix-AG Sebastian Weber 13.06.2012 Was ist ein Bash-Skript? Skript muss mit chmod +x ausführbar gemacht sein Aneinanderreihung von Befehlen normale Befehle nutzbar Sebastian

Mehr

VL-11: LOOP und WHILE Programme I. (Berechenbarkeit und Komplexität, WS 2017) Gerhard Woeginger

VL-11: LOOP und WHILE Programme I. (Berechenbarkeit und Komplexität, WS 2017) Gerhard Woeginger VL-11: LOOP und WHILE Programme I (Berechenbarkeit und Komplexität, WS 2017) Gerhard Woeginger WS 2017, RWTH BuK/WS 2017 VL-11: LOOP und WHILE Programme I 1/46 Organisatorisches Nächste Vorlesung: Mittwoch,

Mehr

Zahlen in Haskell Kapitel 3

Zahlen in Haskell Kapitel 3 Einführung in die Funktionale Programmiersprache Haskell Zahlen in Haskell Kapitel 3 FH Wedel IT-Seminar: WS 2003/04 Dozent: Prof. Dr. Schmidt Autor: Timo Wlecke (wi3309) Vortrag am: 04.11.2003 - Kapitel

Mehr

Algorithmen und Datenstrukturen

Algorithmen und Datenstrukturen 1 Algorithmen und Datenstrukturen Wintersemester 2016/17 13. Vorlesung Binäre Suchbäume Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I 2 Dynamische Menge verwaltet Elemente einer sich ändernden Menge

Mehr

Programmieren in Haskell

Programmieren in Haskell beschreibungen Universität Bielefeld AG Praktische Informatik October 21, 2014 der funktionalen Programmierung gibt es allen Programmiersprachen, aber der funktionalen Programmierung werden sie besonders

Mehr

2.5 Listen. Kurzschreibweise: [42; 0; 16] Listen werden mithilfe von [] und :: konstruiert.

2.5 Listen. Kurzschreibweise: [42; 0; 16] Listen werden mithilfe von [] und :: konstruiert. 2.5 Listen Listen werden mithilfe von [] und :: konstruiert. Kurzschreibweise: [42; 0; 16] # let mt = [];; val mt : a list = [] # let l1 = 1::mt;; val l1 : int list = [1] # let l = [1;2;3];; val l : int

Mehr

Vorsicht bei redundanten und unvollständigen Matches!

Vorsicht bei redundanten und unvollständigen Matches! Vorsicht bei redundanten und unvollständigen Matches! # let n = 7;; val n : int = 7 # match n with 0 -> "null";; Warning: this pattern-matching is not exhaustive. Here is an example of a value that is

Mehr

Übung KogInf Problemlösen, Suche, Lisp

Übung KogInf Problemlösen, Suche, Lisp Übung KogInf Problemlösen, Suche, Lisp Michael Siebers 5. und 12. November 2012 Zu Meiner Person Michael Siebers, Dipl. Psych., B.Sc. AI Raum: W05/05.045 Tel.: +49-951-863 2863 E-mail: michael.siebers@uni-bamberg.de

Mehr

Bash-Scripting Linux-Kurs der Unix-AG

Bash-Scripting Linux-Kurs der Unix-AG Bash-Scripting Linux-Kurs der Unix-AG Zinching Dang 02. Juli 2013 Was ist ein Bash-Script? Aneinanderreihung von Befehlen, die ausgeführt werden Bedingte und wiederholende Ausführung möglich Nützlich bei

Mehr

Zweite Möglichkeit: Ausgabe direkt auf dem Bildschirm durchführen:

Zweite Möglichkeit: Ausgabe direkt auf dem Bildschirm durchführen: Ein- und Ausgabe Zweite Möglichkeit: Ausgabe direkt auf dem Bildschirm durchführen: fun p r i n t T r e e printa t = c a s e t o f Leaf a => ( p r i n t Leaf ; printa a ) Node ( l, a, r ) => ( p r i n

Mehr

Bash-Skripting Linux-Kurs der Unix-AG

Bash-Skripting Linux-Kurs der Unix-AG Bash-Skripting Linux-Kurs der Unix-AG Sebastian Weber 07.01.2013 Was ist ein Bash-Skript? Skript muss mit chmod +x ausführbar gemacht sein Aneinanderreihung von Befehlen normale Befehle nutzbar Sebastian

Mehr

Grundlagen der Programmierung 2. Operationale Semantik

Grundlagen der Programmierung 2. Operationale Semantik Grundlagen der Programmierung 2 Operationale Semantik Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 29. April 2009 Semantik von Programmiersprachen Semantik = Bedeutung

Mehr

Programmierung 1 (Wintersemester 2015/16) Lösungsblatt: Aufgaben für die Übungsgruppen: 8 (Kapitel 9)

Programmierung 1 (Wintersemester 2015/16) Lösungsblatt: Aufgaben für die Übungsgruppen: 8 (Kapitel 9) Fachrichtung 6. Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung Programmierung (Wintersemester 5/6) Lösungsblatt: Aufgaben für die Übungsgruppen: 8 (Kapitel 9) Hinweis: Dieses

Mehr

INFORMATIK FÜR BIOLOGEN

INFORMATIK FÜR BIOLOGEN Technische Universität Dresden 15012015 Institut für Theoretische Informatik Professur für Automatentheorie INFORMATIK FÜR BIOLOGEN Musterklausur WS 2014/15 Studiengang Biologie und Molekulare Biotechnologie

Mehr

WS 2011/2012. Robert Giegerich Dezember 2013

WS 2011/2012. Robert Giegerich Dezember 2013 WS 2011/2012 Robert 1 AG Praktische Informatik 11. Dezember 2013 1 robert@techfak.uni-bielefeld.de Vorschau Themen heute: Funktionen höherer Ordnung (Fortsetzung) künstliche Striktheit mehr zu fold für

Mehr

Theoretische Grundlagen des Software Engineering

Theoretische Grundlagen des Software Engineering Theoretische Grundlagen des Software Engineering 12: Termersetzungssysteme schulz@eprover.org Reduktionssysteme Definition: Reduktionssystem Ein Reduktionssystem ist ein Tupel (A, ) Dabei gilt: A ist eine

Mehr

26 Hierarchisch strukturierte Daten

26 Hierarchisch strukturierte Daten Algorithmik II Peter Wilke Sommersemester 2005 Teil III Funktionale Programmierung 26 Hierarchisch strukturierte Daten Peter Wilke Algorithmik II Sommersemester 2005 1 Peter Wilke Algorithmik II Sommersemester

Mehr

Beispiele: (Funktionen auf Listen) (3) Bemerkungen: Die Datenstrukturen der Paare (2) Die Datenstrukturen der Paare

Beispiele: (Funktionen auf Listen) (3) Bemerkungen: Die Datenstrukturen der Paare (2) Die Datenstrukturen der Paare Beispiele: (Funktionen auf Listen) (3) Bemerkungen: 5. Zusammenhängen der Elemente einer Liste von Listen: concat :: [[a]] -> [a] concat xl = if null xl then [] else append (head xl) ( concat (tail xl))

Mehr

Mitschrift BFS WS 13/14

Mitschrift BFS WS 13/14 Mitschrift BFS WS 13/14 Stand: 4. Juni 2014 Dieses Skript zum Teil Primitive und µ-rekursion der Vorlesung Berechenbarkeit und Formale Sprachen im Wintersemester 2013/14 bei Prof. Wanka wurde von untenstehenden

Mehr

Funktionale Programmierung

Funktionale Programmierung FP-1.0 Funktionale Programmierung Prof. Dr. Uwe Kastens SS 2013 Vorlesung Funktionale Programmierung SS 2013 / Folie 100 Begrüßung Functional Programming is Fun FP-1.1 Fun ctional Programming is Fun ctional

Mehr

2. Grundlagen. Beschreibung von Algorithmen durch Pseudocode. Korrektheit von Algorithmen durch Invarianten.

2. Grundlagen. Beschreibung von Algorithmen durch Pseudocode. Korrektheit von Algorithmen durch Invarianten. 2. Grundlagen Beschreibung von Algorithmen durch Pseudocode. Korrektheit von Algorithmen durch Invarianten. Laufzeitverhalten beschreiben durch O-Notation. 1 Beispiel Minimum-Suche Eingabe bei Minimum

Mehr

Prof. Dr. Margarita Esponda

Prof. Dr. Margarita Esponda Analyse von Algorithmen Die O-Notation WS 2012/2013 Prof. Dr. Margarita Esponda Freie Universität Berlin 1 Korrekte und effiziente Lösung von Problemen Problem Wesentlicher Teil der Lösung eines Problems.

Mehr

Verarbeitung unendlicher Datenstrukturen Jetzt können wir z.b. die unendliche Liste aller geraden Zahlen oder aller Quadratzahlen berechnen:

Verarbeitung unendlicher Datenstrukturen Jetzt können wir z.b. die unendliche Liste aller geraden Zahlen oder aller Quadratzahlen berechnen: Verarbeitung unendlicher Datenstrukturen Jetzt können wir z.b. die unendliche Liste aller geraden Zahlen oder aller Quadratzahlen berechnen: take 1 0 ( f i l t e r ( fn x => x mod 2=0) nat ) ; val it =

Mehr

Aufgabe 8. 1 Arbeitsweise illustrieren. 2 Korrektheitsbeweis führen. 3 Laufzeitanalyse durchführen.

Aufgabe 8. 1 Arbeitsweise illustrieren. 2 Korrektheitsbeweis führen. 3 Laufzeitanalyse durchführen. Aufgabe 8 Betrachten Sie den folgenden Algorithmus namens Bubble-Sort. Bubble-Sort(A[1..n]): 1 for i 1 to length(a) 1 2 do for j length(a) downto i + 1 3 do if A[j 1] > A[j] 4 then A[j 1] A[j] 1 Arbeitsweise

Mehr

LISP. Viele eklige Klammern. Entropia e.v. - CCC Karlsruhe

LISP. Viele eklige Klammern. Entropia e.v. - CCC Karlsruhe LISP Viele eklige Klammern LISP: Übersicht Was ist LISP? Programmiersprache mit vielen Klammern Listen orientierte Sprache (LISt Processor) Nicht rein funktional Viele Funktionen mit Nebeneffekten Später

Mehr

Semantik von Programmiersprachen SS 2017

Semantik von Programmiersprachen SS 2017 Lehrstuhl für Programmierparadigmen Denis Lohner Sebastian Ullrich denis.lohner@kit.edu sebastian.ullrich@kit.edu Semantik von Programmiersprachen SS 2017 http://pp.ipd.kit.edu/lehre/ss2017/semantik Lösungen

Mehr

Programmierung 1 (Wintersemester 2015/16) Lösungsblatt: Aufgaben für die Übungsgruppen: 12 (Kapitel 13)

Programmierung 1 (Wintersemester 2015/16) Lösungsblatt: Aufgaben für die Übungsgruppen: 12 (Kapitel 13) Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2015/16) Lösungsblatt: Aufgaben für die Übungsgruppen: 12 (Kapitel 13)

Mehr

Grundlagen der Programmierung

Grundlagen der Programmierung Grundlagen der Programmierung SS 05 Prof. Dr. K. Madlener Lösungshinweise zu Übungsblatt 6 Aufgabe 6.1. Sei f(x, b) = µy b.(y y x (y + 1) (y + 1) > x) f.a. x, b N. Sei weiter f(x) = f(x, x) f.a. x N. Aufgabe

Mehr

Hausaufgaben. zur Vorlesung. Vollständige Induktion. 1. Beweist folgende Formeln (zu beweisen ist nur die Gleichheit mit dem. i=1 (4 + i)!

Hausaufgaben. zur Vorlesung. Vollständige Induktion. 1. Beweist folgende Formeln (zu beweisen ist nur die Gleichheit mit dem. i=1 (4 + i)! WS 015/1 Hausaufgaben zur Vorlesung Vollständige Induktion 1. Beweist folgende Formeln zu beweisen ist nur die Gleichheit mit dem! -Zeichen : a 5 + + 7 + 8 + + 4 + n n 4 + i! nn+9 b 1 + + 9 + + n 1 n 1

Mehr

R a i n e r N i e u w e n h u i z e n K a p e l l e n s t r G r e v e n T e l / F a x / e

R a i n e r N i e u w e n h u i z e n K a p e l l e n s t r G r e v e n T e l / F a x / e R a i n e r N i e u w e n h u i z e n K a p e l l e n s t r. 5 4 8 6 2 8 G r e v e n T e l. 0 2 5 7 1 / 9 5 2 6 1 0 F a x. 0 2 5 7 1 / 9 5 2 6 1 2 e - m a i l r a i n e r. n i e u w e n h u i z e n @ c

Mehr

F r e i t a g, 3. J u n i

F r e i t a g, 3. J u n i F r e i t a g, 3. J u n i 2 0 1 1 L i n u x w i r d 2 0 J a h r e a l t H o l l a, i c h d a c h t e d i e L i n u x - L e u t e s i n d e i n w e n i g v e r n ü n f t i g, a b e r j e t z t g i b t e

Mehr

L 3. L a 3. P a. L a m 3. P a l. L a m a 3. P a l m. P a l m e. P o 4. P o p 4. L a. P o p o 4. L a m. Agnes Klawatsch

L 3. L a 3. P a. L a m 3. P a l. L a m a 3. P a l m. P a l m e. P o 4. P o p 4. L a. P o p o 4. L a m. Agnes Klawatsch 1 L 3 P 1 L a 3 P a 1 L a m 3 P a l 1 L a m a 3 P a l m 2 P 3 P a l m e 2 P o 4 L 2 P o p 4 L a 2 P o p o 4 L a m 4 L a m p 6 N a 4 L a m p e 6 N a m 5 5 A A m 6 6 N a m e N a m e n 5 A m p 7 M 5 A m p

Mehr

Übersetzung von Datenstrukturen

Übersetzung von Datenstrukturen Übersetzung von Datenstrukturen bisher: Übersetzung von Mini-Java-Exp: Datenkeller zur Auswertung arithm. Ausdrücke Mini-Java: Sprünge zur Simulation von Kontrollstrukturen Mini-Java-FunProc: rekursive

Mehr

Übung Algorithmen und Datenstrukturen

Übung Algorithmen und Datenstrukturen Übung Algorithmen und Datenstrukturen Sommersemester 2016 Marc Bux, Humboldt-Universität zu Berlin Organisation Vorlesung: Montag 11 13 Uhr Marius Kloft RUD 26, 0 115 Mittwoch 11 13 Uhr Marius Kloft RUD

Mehr

Praktische Informatik 3

Praktische Informatik 3 Praktische Informatik 3 Christian Maeder WS 03/04 Vorlesung vom 12.1.2004: Ein/Ausgabe in funktionalen Sprachen Vorlesung vom 12.1.2004: Ein/Ausgabe in funktionalen Sprachen 3 Inhalt Wo ist das Problem?

Mehr

Funktionale Programmierung Grundlegende Datentypen

Funktionale Programmierung Grundlegende Datentypen Grundlegende Datentypen Prof. Dr. Oliver Braun Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 06.11.2017 16:45 Inhaltsverzeichnis Typen........................................

Mehr

liefern eine nicht maschinenbasierte Charakterisierung der regulären

liefern eine nicht maschinenbasierte Charakterisierung der regulären Reguläre Ausdrücke 1 Ziel: L=L M für NFA M L=L(r) für einen regulären Ausdruck r Reguläre Ausdrücke über einem Alphabet Σ Slide 1 liefern eine nicht maschinenbasierte Charakterisierung der regulären Sprachen

Mehr

Visualisierung von Graphen

Visualisierung von Graphen 1 Visualisierung von Graphen Teile-und-Herrsche-Algorithmen: Bäume und serienparallele Graphen 3. Vorlesung Sommersemester 2013 (basierend auf Folien von Martin Nöllenburg und Robert Görke, KIT) 2 Ankündigung

Mehr

Programmierung 1 - Repetitorium

Programmierung 1 - Repetitorium WS 2002/2003 Programmierung 1 - Repetitorium Andreas Augustin und Marc Wagner Homepage: http://info1.marcwagner.info Donnerstag, den 10.04.03 Kapitel 7 Korrektheit 7.1 Abstrakte Prozeduren Abstrakte Prozedur

Mehr

EidP. Blocktutorium SS 2014

EidP. Blocktutorium SS 2014 EidP. Blocktutorium SS 2014 Praktischer Teil //Programmieren = Theoriewissen + Handwerk; Bücher, Folien, Videos, Vorträge,... Können Theorie vermitteln. Der Rest ist ÜBUNG! Beste Vorbereitung: Programmieren

Mehr

LOOP-Programme: Syntaktische Komponenten

LOOP-Programme: Syntaktische Komponenten LOOP-Programme: Syntaktische Komponenten LOOP-Programme bestehen aus folgenden Zeichen (syntaktischen Komponenten): Variablen: x 0 x 1 x 2... Konstanten: 0 1 2... Operationssymbole: + Trennsymbole: ; :=

Mehr

Shell-Scripting Linux-Kurs der Unix-AG

Shell-Scripting Linux-Kurs der Unix-AG Shell-Scripting Linux-Kurs der Unix-AG Andreas Teuchert 31. Januar 2014 Was ist ein Shell-Script? Aneinanderreihung von Befehlen, die ausgeführt werden Bedingte und wiederholende Ausführung möglich Nützlich

Mehr

Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 11 (Parser II)

Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 11 (Parser II) Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 11 (Parser II) Hinweis: Dieses

Mehr

Programmierung und Modellierung

Programmierung und Modellierung Programmierung und Modellierung Terme, Suchbäume und Pattern Matching Martin Wirsing in Zusammenarbeit mit Moritz Hammer SS 2009 2 Inhalt Kap. 7 Benutzerdefinierte Datentypen 7. Binärer Suchbaum 8. Anwendung:

Mehr

4. Anhang 4.1 Wertetabellen zum 2. Algorithmus //Suche alle k, welche quadratische Reste mod 64 sind print "Quadratische Reste mod 64:"; for k:=0 to 31 do print (k^2 mod 64); end for; k 0 1 2 3 4 5 6 7

Mehr

Sei Σ ein endliches Alphabet. Eine Sprache L Σ ist genau dann regulär, wenn sie von einem regulären Ausdruck beschrieben werden kann.

Sei Σ ein endliches Alphabet. Eine Sprache L Σ ist genau dann regulär, wenn sie von einem regulären Ausdruck beschrieben werden kann. Der Satz von Kleene Wir haben somit Folgendes bewiesen: Der Satz von Kleene Sei Σ ein endliches Alphabet. Eine Sprache L Σ ist genau dann regulär, wenn sie von einem regulären Ausdruck beschrieben werden

Mehr

Dank. Theoretische Informatik II. Teil II. Registermaschinen. Vorlesung

Dank. Theoretische Informatik II. Teil II. Registermaschinen. Vorlesung Dank Vorlesung Theoretische Informatik II Bernhard Beckert Institut für Informatik Diese Vorlesungsmaterialien basieren zum Teil auf den Folien zu den Vorlesungen von Katrin Erk (gehalten an der Universität

Mehr

expr :: Expr expr = Mul (Add (Const 3) (Const 4)) (Div (Sub (Const 73) (Const 37)) (Const 6))

expr :: Expr expr = Mul (Add (Const 3) (Const 4)) (Div (Sub (Const 73) (Const 37)) (Const 6)) 1 - Korrektur 2 - Abstrakte Datentypen für arithmetische Ausdrücke Der Datentyp Wir beginnen zunächst mit dem algebraischen Datentyp für Ausdrücke. Hierfür definieren wir einen Konstruktor Number für Zahlen,

Mehr

Shell-Scripting Linux-Kurs der Unix-AG

Shell-Scripting Linux-Kurs der Unix-AG Shell-Scripting Linux-Kurs der Unix-AG Benjamin Eberle 1. Februar 2016 Was ist ein Shell-Script? Aneinanderreihung von Befehlen, die ausgeführt werden Bedingte und wiederholende Ausführung möglich Nützlich

Mehr

VU Software Paradigmen / SS 2008

VU Software Paradigmen / SS 2008 VU Software Paradigmen 716.060 / SS 2008 Stephan Gspandl Institut für Softwaretechnologie sgspandl@ist.tugraz.at Institute for Software Technology Lehrziele Vermittlung von einführenden Kenntnissen des

Mehr

Shell-Scripting Linux-Kurs der Unix-AG

Shell-Scripting Linux-Kurs der Unix-AG Shell-Scripting Linux-Kurs der Unix-AG Benjamin Eberle 6. Juli 2016 Was ist ein Shell-Script? Aneinanderreihung von Befehlen, die ausgeführt werden Bedingte und wiederholende Ausführung möglich Nützlich

Mehr

Shell-Scripting Linux-Kurs der Unix-AG

Shell-Scripting Linux-Kurs der Unix-AG Shell-Scripting Linux-Kurs der Unix-AG Andreas Teuchert 8. Juli 2014 Was ist ein Shell-Script? Aneinanderreihung von Befehlen, die ausgeführt werden Bedingte und wiederholende Ausführung möglich Nützlich

Mehr

Einführung in Haskell

Einführung in Haskell Einführung in Haskell Axel Stronzik 21. April 2008 1 / 43 Inhaltsverzeichnis 1 Allgemeines 2 / 43 Inhaltsverzeichnis 1 Allgemeines 2 Funktions- und Typdefinitionen 2 / 43 Inhaltsverzeichnis 1 Allgemeines

Mehr

Programmieren in Haskell. Stefan Janssen. Strukturelle Rekursion. Universität Bielefeld AG Praktische Informatik. 10.

Programmieren in Haskell. Stefan Janssen. Strukturelle Rekursion. Universität Bielefeld AG Praktische Informatik. 10. Universität Bielefeld AG Praktische Informatik 10. Dezember 2014 Wiederholung: Schema: f :: [σ] -> τ f [] = e 1 f (a : as) = e 2 where s = f as wobei e 1 und e 2 Ausdrücke vom Typ τ sind und e 2 die Variablen

Mehr

1.3 Primitiv rekursive und µ-rekursive Funktionen

1.3 Primitiv rekursive und µ-rekursive Funktionen Definition 1.11 Die Klasse der primitiv rekursiven Funktionen (a) Basisfunktionen: (1.) die konstanten Funktionen c (c N) (2.) die Projektionen Π m i (x 1,...,x m ) = x i (1 i m) (3.) die Nachfolgerfunktion

Mehr

Programmierung 1 (Wintersemester 2012/13) Lösungsblatt 10 (Kapitel 11)

Programmierung 1 (Wintersemester 2012/13) Lösungsblatt 10 (Kapitel 11) Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2012/13) Lösungsblatt 10 (Kapitel 11) Hinweis: Dieses Übungsblatt enthält

Mehr

Praktische Informatik 3: Einführung in die Funktionale Programmierung Vorlesung vom 10.11.2010: Rekursive Datentypen

Praktische Informatik 3: Einführung in die Funktionale Programmierung Vorlesung vom 10.11.2010: Rekursive Datentypen Rev. 1152 1 [23] Praktische Informatik 3: Einführung in die Funktionale Programmierung Vorlesung vom 10.11.2010: Rekursive Datentypen Christoph Lüth & Dennis Walter Universität Bremen Wintersemester 2010/11

Mehr

2. Algorithmische Methoden 2.1 Rekursion. 18. April 2017

2. Algorithmische Methoden 2.1 Rekursion. 18. April 2017 2. Algorithmische Methoden 2.1 Rekursion 18. April 2017 Rekursiver Algorithmus Ein rekursiver Algorithmus löst ein Problem, indem er eine oder mehrere kleinere Instanzen des gleichen Problems löst. Beispiel

Mehr

Probeklausur Director s Cut

Probeklausur Director s Cut Probeklausur Director s Cut Lösungsvorschlag Informatik II SS2005 Aufgabe 1: Graphentheorie (2 + 1 + 2 Punkte) Gegeben ist der folgende ungerichtete Graph G n = (V, E) mit V = n 1 i=0 V i wobei V i = {v

Mehr

Übung Algorithmen und Datenstrukturen

Übung Algorithmen und Datenstrukturen Übung Algorithmen und Datenstrukturen Sommersemester 2016 Patrick Schäfer, Humboldt-Universität zu Berlin Organisation Vorlesung: Montag 11 13 Uhr Marius Kloft RUD 26, 0 115 Mittwoch 11 13 Uhr Marius Kloft

Mehr

KOP / FBS - Programmierung

KOP / FBS - Programmierung KOP / FBS - Programmierung Programmieren in Anweisungsliste Programmieren in strukturierten Text Programmieren in Kontaktplan Programmieren in Funktionsbausteinsprache KOP Programmierung (1) 2 1 Neues

Mehr

Softwareparadigmen SS 2015, Übungsblatt P

Softwareparadigmen SS 2015, Übungsblatt P Blatt P Seite 1 Softwareparadigmen SS 2015, Übungsblatt P Abgabe: 27. Mai 2015, bis 16:00 Uhr 1. Bilden Sie eine Zweiergruppe mit einem/einer weiteren LV-TeilnehmerIn 2. Erstellen Sie mittels TUGrazOnline

Mehr

Informatik II, SS 2018

Informatik II, SS 2018 Informatik II - SS 2018 (Algorithmen & Datenstrukturen) Vorlesung 6 (7.5.2018) Dictionaries, Binäre Suche, Hashtabellen I / Yannic Maus Algorithmen und Komplexität Abstrakte Datentypen : Dictionary Dictionary:

Mehr

Programmieren in Haskell

Programmieren in Haskell Programmieren in Haskell Syntax und Semantik von Haskell Programmieren in Haskell 1 Was wir heute (und nächstes mal) machen Datentypdefinitionen Wertdefinitionen, Variablenbindungen Musterbindungen Funktionsbindungen

Mehr

Zusammenfassung. Stephan Gspandl Institut für Softwaretechnologie Institute for Software Technology

Zusammenfassung. Stephan Gspandl Institut für Softwaretechnologie Institute for Software Technology Zusammenfassung Stephan Gspandl Institut für Softwaretechnologie sgspandl@ist.tugraz.at SYNTAX 2 Syntax Struktur einer Sprache Werkzeug zur Beschreibung aller möglichen Sätze: Grammatik Tupel (V N,V T,S,Φ)

Mehr

LR: Syntax. Semantik und Analyse von Funktionalen Programmen (SAFP): LR: Reduktions-Regeln. LR: Reduktions-Regeln

LR: Syntax. Semantik und Analyse von Funktionalen Programmen (SAFP): LR: Reduktions-Regeln. LR: Reduktions-Regeln LR: Syntax Semantik und Analyse von Funktionalen Programmen (SAFP): KFPT mit Sharing und Striktheisanalyse: LR Prof. Dr. Manfred Schmidt-Schauß SAFP; WS 2014/15 E ::= V (c E 1... E ar(c) ) (seq E 1 E 2

Mehr

Korrekte Software: Grundlagen und Methoden Vorlesung 11 vom : Funktionen und Prozeduren

Korrekte Software: Grundlagen und Methoden Vorlesung 11 vom : Funktionen und Prozeduren 18:10:49 2016-07-07 1 [14] Korrekte Software: Grundlagen und Methoden Vorlesung 11 vom 06.06.16: Funktionen und Prozeduren Serge Autexier, Christoph Lüth Universität Bremen Sommersemester 2016 Korrekte

Mehr

Semantik und Analyse von Funktionalen Programmen (SAFP):

Semantik und Analyse von Funktionalen Programmen (SAFP): Semantik und Analyse von Funktionalen Programmen (SAFP): KFPT mit Sharing und Striktheisanalyse: LR Prof. Dr. Manfred Schmidt-Schauß SAFP; WS 2014/15 Stand der Folien: 5. Februar 2015 LR: Syntax E ::=

Mehr

=!'04 #>4 )-:!- / )) $!# & $ % # %)6 ) + # 6 0 %% )90 % 1% $ 9116 69)" %" :"6. 1-0 &6 -% ' 0' )%1 0(,"'% #6 0 )90 1-11 ) 9 #,0. 1 #% 0 9 & %) ) '' #' ) 0 # %6 ;+'' 0 6%((&0 6?9 ;+'' 0 9)&6? #' 1 0 +& $

Mehr

Einführung in die Theoretische Informatik

Einführung in die Theoretische Informatik Technische Universität München Fakultät für Informatik Prof. Tobias Nipkow, Ph.D. Sascha Böhme, Lars Noschinski Sommersemester 2011 Lösungsblatt 8 18. Juli 2011 Einführung in die Theoretische Informatik

Mehr

Funktionale Programmierung Teil 2 Methodik: Spezifikation, Implementierung, Verifikation

Funktionale Programmierung Teil 2 Methodik: Spezifikation, Implementierung, Verifikation Grundlagen der Programm- und Systementwicklung Funktionale Programmierung Teil 2 Methodik: Spezifikation, Implementierung, Verifikation Technische Universität München Institut für Informatik Software &

Mehr

Effiziente Algorithmen und Datenstrukturen I. Kapitel 10: Lineare Algebra

Effiziente Algorithmen und Datenstrukturen I. Kapitel 10: Lineare Algebra Effiziente Algorithmen und Datenstrukturen I Kapitel 10: Lineare Algebra Christian Scheideler WS 2008 19.02.2009 Kapitel 10 1 Überblick Notation Arithmetik auf großen Zahlen (Addition und Multiplikation)

Mehr

11.1 Grundlagen - Denitionen

11.1 Grundlagen - Denitionen 11 Binärbäume 11.1 Grundlagen - Denitionen Denition: Ein Baum ist eine Menge, die durch eine sog. Nachfolgerrelation strukturiert ist. In einem Baum gilt: (I) (II) 1 Knoten w ohne VATER(w), das ist die

Mehr

äußere Klammern können entfallen, ebenso solche, die wegen Assoziativität von + und Konkatenation nicht notwendig sind:

äußere Klammern können entfallen, ebenso solche, die wegen Assoziativität von + und Konkatenation nicht notwendig sind: 3. Reguläre Sprachen Bisher wurden Automaten behandelt und Äquivalenzen zwischen den verschiedenen Automaten gezeigt. DEAs erkennen formale Sprachen. Gibt es formale Sprachen, die nicht erkannt werden?

Mehr

Einführung in die Informatik 2 4. Übung

Einführung in die Informatik 2 4. Übung Technische Universität München WS 2013/14 Institut für Informatik 05.11.2013 Prof. Tobias Nipkow, Ph.D. Abgabe: 12.11.2013 Lars Noschinski, Lars Hupel, Dr. Jasmin Blanchette Einführung in die Informatik

Mehr

Informatik I. Informatik I Iteration vs. Rekursion. Iteration vs. Rekursion Iteration vs. Rekursion. 20. Iteration vs.

Informatik I. Informatik I Iteration vs. Rekursion. Iteration vs. Rekursion Iteration vs. Rekursion. 20. Iteration vs. Informatik I 1. Februar 2011 20. Informatik I 20. Jan-Georg Smaus 20.1 Albert-Ludwigs-Universität Freiburg 1. Februar 2011 Jan-Georg Smaus (Universität Freiburg) Informatik I 1. Februar 2011 1 / 31 Jan-Georg

Mehr

1. Typen 1.1 Typsicherheit 1.2 Typprüfung

1. Typen 1.1 Typsicherheit 1.2 Typprüfung 1. Typen 1.1 Typsicherheit 1.2 Typprüfung Ein Typsystem ist ein praktikables, syntaktisches Verfahren, mit dem man die Abwesenheit gewisser Laufzeit-Eigenschaften eines Programms beweisen kann, indem man

Mehr