VU Software Paradigmen / SS 2015
|
|
- Stephanie Krüger
- vor 7 Jahren
- Abrufe
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 Berhard Aichernig und Alexander Felfernig Institut für Softwaretechnologie {bernhard.aichernig,alexander.felfernig}@ist.tugraz.at Institute for Software Technology Inhalt Einfache
MehrEinfache 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
MehrSWP 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
MehrInformatik 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
MehrSoftwareparadigmen 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
MehrTheorembeweiserpraktikum 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
MehrSoftwareparadigmen 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...........................
MehrLOOP-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
MehrDie 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
MehrWorkshop 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
MehrEinfü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
MehrMä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
MehrFormale 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
MehrKonzepte 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
MehrTheoretische 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
MehrLö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
MehrWas 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
MehrKlausur 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
MehrProgrammierung 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
MehrKapitel 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
MehrRekursive 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
MehrBreitensuche 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;
MehrWiederholung. 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
MehrBash-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
MehrVL-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,
MehrZahlen 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
MehrAlgorithmen 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
MehrProgrammieren 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
Mehr2.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
MehrVorsicht 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 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
MehrBash-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
MehrZweite 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
MehrBash-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
MehrGrundlagen 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
MehrProgrammierung 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
MehrINFORMATIK 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
MehrWS 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
MehrTheoretische 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
Mehr26 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
MehrBeispiele: (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))
MehrMitschrift 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
MehrFunktionale 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
Mehr2. 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
MehrProf. 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.
MehrVerarbeitung 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 =
MehrAufgabe 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
MehrLISP. 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
MehrSemantik 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
MehrProgrammierung 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)
MehrGrundlagen 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
MehrHausaufgaben. 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
MehrR 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
MehrF 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
MehrL 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 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 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
MehrPraktische 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?
MehrFunktionale 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........................................
Mehrliefern 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
MehrVisualisierung 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
MehrProgrammierung 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
MehrEidP. 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
MehrLOOP-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: ; :=
MehrShell-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
MehrProgrammierung 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
MehrProgrammierung 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:
Mehr4. 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
MehrSei Σ 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
MehrDank. 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
Mehrexpr :: 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,
MehrShell-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
MehrVU 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
MehrShell-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
MehrShell-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
MehrEinfü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
MehrProgrammieren 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
Mehr1.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
MehrProgrammierung 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
MehrPraktische 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
Mehr2. 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
MehrProbeklausur 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 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
MehrKOP / FBS - Programmierung
KOP / FBS - Programmierung Programmieren in Anweisungsliste Programmieren in strukturierten Text Programmieren in Kontaktplan Programmieren in Funktionsbausteinsprache KOP Programmierung (1) 2 1 Neues
MehrSoftwareparadigmen 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
MehrInformatik 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:
MehrProgrammieren 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
MehrZusammenfassung. 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,Φ)
MehrLR: 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
MehrKorrekte 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
MehrSemantik 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 +& $
MehrEinfü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
MehrFunktionale 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 &
MehrEffiziente 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)
Mehr11.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:
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?
MehrEinfü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
MehrInformatik 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
Mehr1. 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