LISTEN. Programmierkurs Prolog p.1

Ähnliche Dokumente
Rekursion. rekursive Prädikate. deklarative vs. prozedurale Bedeutung von Prädikaten. Programmierkurs Prolog p.1

Terme. Heute: Terme vergleichen. Struktur von Termen. Operatoren. Logik in der Praxis Logikprogrammierung (Prolog) p.1

Prolog 4. Kapitel: Listen

Einführung in PROLOG IV Listen

Rekursive Listenverarbeitung

Teil 4: Rekursion und Listen

Künstliche Intelligenz Einführung in Prolog

Listen. bersicht. Zweck. Listen allgemein Listen in Prolog. Programmiertechniken mit Listen. Erstellen von Prolog-Programmen mit Listen

Prolog: Listen und Cut. Mark Ugarov

Fragen zum Nachdenken: Wie könnte man das Fehlen eines Attribut-Wertes interpretieren?

Expertensysteme Sprachverarbeitung Symbolische Informationsverarbeitung Graphentheoretische Probleme Planungsprobleme Rapid Prototyping...

Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 15 (Linearer Speicher, Listen, Bäume)

Übung 4: Aufgaben in Prolog: Aufgaben trenne(+eingabeliste, -ZahlenListe, -NichtzahlenListe)

Abstrakte Syntax von Prolog (1)

Logisches und funktionales Programmieren

Cut und Negation. Heute: if-then-else. Negation. Programmierkurs Prolog p.1

Prolog 3. Kapitel: Rekursion

Prolog 3. Kapitel: Rekursion

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

Beispiele: Funktionsabstraktion (3) Funktionsdeklaration. Funktionsdeklaration (2) Funktionsdeklaration (3) 3. Abstraktion über Funktionsbezeichner:

Binäre Suchbäume (binary search trees, kurz: bst)

Übungen zu Kognitive Systeme I

4.1 Bäume, Datenstrukturen und Algorithmen. Zunächst führen wir Graphen ein. Die einfachste Vorstellung ist, dass ein Graph gegeben ist als

Logische und funktionale Programmierung

Gliederung. Funktionale Programmierung. Pattern matching in Haskell. Pattern matching in ERLANG. Materialien zur Vorlesung

5 Logische Programmierung

1 Klassen und Objekte

Rekursive Programmiertechniken. Einfachste Rekursion mit Babuschka. Hyponymie: Unterbegriffshierarchie. Linksrekursion mit Babuschka

Theoretische Informatik II

Objektorientierte Programmierung II

Dateien und Module. Heute: Ein- und Ausgabe. Module. Programmierkurs Prolog p.1

ADT: Verkettete Listen

2 Logikprogrammierung am Beispiel Prolog

Die Definition eines Typen kann rekursiv sein, d.h. Typ-Konstruktoren dürfen Elemente des zu definierenden Typ erhalten.

Einführung in das Programmieren Prolog Sommersemester Teil 2: Arithmetik. Version 1.0

Haskell, Typen, und Typberechnung. Grundlagen der Programmierung 3 A. Einige andere Programmiersprachen. Typisierung in Haskell

Prolog Tutorial Norbert E. Fuchs Institut für Informatik Universität Zürich

Tutoraufgabe 1 (Programmieren in Prolog):

DCG II. Heute: DCGs mit extra Argumenten. DCGs mit Agreementmerkmalen. Parsebäume. Extra Tests. Programmierkurs Prolog p.1

Algorithmen und Datenstrukturen

Definition 4 (Operationen auf Sprachen) Beispiel 5. Seien A, B Σ zwei (formale) Sprachen. Konkatenation: AB = {uv ; u A, v B} A + = n 1 An

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

Tutorium Prolog für Linguisten 8

Funktionale Programmierung. ALP I Lambda-Kalkül. Teil III SS Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda

12 Abstrakte Klassen, finale Klassen und Interfaces

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

PROLOG. Lernende Systeme WS 10/11 Crashkurs. Martin Sticht Stephan Weller

26 Hierarchisch strukturierte Daten

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

Algorithmen und Datenstrukturen. Algorithmen und Datenstrukturen. B3.1 Einführung. B3.2 Verkettete Liste. B3.3 Bäume

(Logik und) Logikprogrammierung

Universität Koblenz-Landau Fachbereich Informatik Klausur KI-Programmierung WS 2007/2008. Jun.-Prof. Dr. B. Beckert. 21.

ADT: Verkettete Listen

PROLOG Syntax. Einführung in PROLOG II. Atome. Variablen. Es gibt vier Arten von Termen: Atome. Zahlen. Variablen. Komplexe Terme

Algorithmen und Datenstrukturen

Gliederung. Algorithmen und Datenstrukturen I. Listen in Haskell: Listen in Haskell: Listen in Haskell. Datentyp Liste Strings Listenkomprehension

Grundlagen der Programmierung 3 A

Einführung in die funktionale Programmierung

Algorithmik und Programmieren

Haskell, Typen, und Typberechnung. Grundlagen der Programmierung 3 A. Überladung und Konversion in Haskell. Typisierung in Haskell

Gliederung. Programmierparadigmen. Einführung in Prolog: Einführung in Prolog: Programmieren in Prolog. Einführung Syntax Regeln Listen Relationen

Übungsblatt Programmierung und Software-Entwicklung Generizität, Interfaces, Listen, Sortieralgorithmen & JUnit

Bäume. Martin Wirsing. Ziele. Implementierung von Knoten. Bäume (abstrakt) Standardimplementierungen für Bäume kennen lernen

Programmiersprache Prolog

Kapitel 12: Induktive

Einführung in die Programmierung für NF MI. Übung 04

Aufgabe 1 Basiswissen zur Vorlesung (8 Punkte)

Lemma Für jede monotone Grammatik G gibt es eine kontextsensitive

Abstrakter Datentyp (ADT): Besteht aus einer Menge von Objekten, sowie Operationen, die auf diesen Objekten wirken.

Übergang von funktionaler zu OOP. Algorithmen und Datenstrukturen II 1

Kapitel 9. Programmierkurs. Attribute von Klassen, Methoden und Variablen. 9.1 Attribute von Klassen, Methoden und Variablen

Transkript:

LISTEN Programmierkurs Prolog p.1

Liste Listen sind rekursive Datenstrukturen, die dazu dienen geordnete Mengen von Elementen zu beschreiben. Man kann sich Listen in Prolog als Behälter vorstellen, die Elementen verschiedener Typen behalten können. Die Reihenfolge, in der Behälter gefüllt werden, ist wichtig Programmierkurs Prolog p.2

c i g(a) a b c b ca a b c Programmierkurs Prolog p.3 Beispiele

Numeral Die folgende rekursive Definition definiert eine natürliche Zahl: 1. 0 ist eine natürliche Zahl 2. succ(x) ist eine natürliche Zahl wenn X eine natürliche Zahl ist Programmierkurs Prolog p.4

Definition von Liste Die folgende rekursive Definition definiert eine Liste in Prolog: 1. [] ist eine Liste 2..(T,L) ist eine liste wenn L eine Liste ist und T ein belibiger Term T heisst head der Liste, L heisst tail. Programmierkurs Prolog p.5

Listen in Prolog / Das Predikat liste implementiert die folgende rekursive Definition von Liste: 1. ist eine Liste 2..(T,L) iste eine Liste wenn L eine Liste ist / % Basisklausel liste([]). % Recursive Klausel liste(.(t,l)) :- liste(l). Programmierkurs Prolog p.6

Beispiele a,b,c.(a,.(b,.(c, []))) a b,c.(a,.(.(b,.(c,[])),[])) [].([],[]) c, i,g(a).(c,.(.(i,[]),.(g(a),[]))) Programmierkurs Prolog p.7

Listen als Bäume a a b c b c [] Programmierkurs Prolog p.8

Länge einer Liste / Das Predikat count length implementiert die folgende rekursive Definition von Länge ( ) einer Liste: 1. = 0 2..(T,L) = 1 + L / % Basisklausel count length([],0). % Recursive Klausel count length(.(t,l), succ(x)) :- count length(l,x). Programmierkurs Prolog p.9

Studenten = martin, anna, hans Programmierkurs Prolog p.10

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). Programmierkurs Prolog p.11

Studenten = martin, anna, hans In Prolog: Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). Programmierkurs Prolog p.12

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). Programmierkurs Prolog p.13

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) Programmierkurs Prolog p.14

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) 3. count length(.(anna,.(hans, [])), I1). Programmierkurs Prolog p.15

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) 3. count length(.(anna,.(hans, [])), I1). 4. I1 = 1 + I2 = succ(i2) Programmierkurs Prolog p.16

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) 3. count length(.(anna,.(hans, [])), I1). 4. I1 = 1 + I2 = succ(i2) 5. count length(.(hans, []), I2). Programmierkurs Prolog p.17

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) 3. count length(.(anna,.(hans, [])), I1). 4. I1 = 1 + I2 = succ(i2) 5. count length(.(hans, []), I2). 6. I2 = 1 + I3 = succ(i3) Programmierkurs Prolog p.18

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) 3. count length(.(anna,.(hans, [])), I1). 4. I1 = 1 + I2 = succ(i2) 5. count length(.(hans, []), I2). 6. I2 = 1 + I3 = succ(i3) 7. count length([], I3) Programmierkurs Prolog p.19

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) 3. count length(.(anna,.(hans, [])), I1). 4. I1 = 1 + I2 = succ(i2) 5. count length(.(hans, []), I2). 6. I2 = 1 + I3 = succ(i3) 7. count length([], I3) 8. count length([], 0). Programmierkurs Prolog p.20

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) 3. count length(.(anna,.(hans, [])), I1). 4. I1 = 1 + I2 = succ(i2) 5. count length(.(hans, []), I2). 6. I2 = 1 + I3 = succ(i3) 7. count length([], I3) 8. count length([], 0). 9. I3 = 0 Programmierkurs Prolog p.21

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) 3. count length(.(anna,.(hans, [])), I1). 4. I1 = 1 + I2 = succ(i2) 5. count length(.(hans, []), I2). 6. I2 = 1 + I3 = succ(i3) 7. count length([], I3) 8. count length([], 0). 9. I3 = 0 10. I2 = 1 Programmierkurs Prolog p.22

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) 3. count length(.(anna,.(hans, [])), I1). 4. I1 = 1 + I2 = succ(i2) 5. count length(.(hans, []), I2). 6. I2 = 1 + I3 = succ(i3) 7. count length([], I3) 8. count length([], 0). 9. I3 = 0 10. I2 = 1 11. I1 = 2 Programmierkurs Prolog p.23

Studenten = In Prolog: martin, anna, hans Studenten =.(martin,.(anna,.(hans, [])))). 0. count length(studenten,n). 1. count length(.(martin,.(anna,.(hans, []))), N). 2. N = 1 + I1 =succ(i1) 3. count length(.(anna,.(hans, [])), I1). 4. I1 = 1 + I2 = succ(i2) 5. count length(.(hans, []), I2). 6. I2 = 1 + I3 = succ(i3) 7. count length([], I3) 8. count length([], 0). 9. I3 = 0 10. I2 = 1 11. I1 = 2 12. N = 3 Programmierkurs Prolog p.24

Aufgaben 1. Definiere ein Predikat länger then/2, das als Argumente zwei Listen nimmt und entscheidet ob die erste länger als die zweite ist. (Tipp: ähnlich wie greater then) 2. Definiere ein Predikat append/3, das drei Listen als Argumente nimmt und die Konkatenation der ersten zwei Listen in dem dritten Argument speichert. Zum Beispiel bei der Anfrage?- append(.(a,.(b,[])),.(1,.(2,[])),x) soll Prolog soll X =.(a,.(b,.(1,.(2,[])))) antworten. (Tipp: ähnlich wie add) 3. Definiere ein Predikat member/2, das als Argumente ein Term und eine Liste nimmt und testet ob der Term in der Liste enthalten ist. Programmierkurs Prolog p.25

Alternative Darstellung für Listen?-.(a,.(b,[])) = X. X = [a,b] Listen können in Prolog ähnlich wie Mengen geschrieben werden: [a,b,c,[1]] Programmierkurs Prolog p.26

Prolog stellt eine benutzerfreundlichere Darstellung für Listen zur Verfügung, die wie folgt definiert ist: 1. [] ist eine Liste 2. [H T] ist eine Liste wenn T eine Liste ist. Programmierkurs Prolog p.27

Zugriff auf Listen [a,b,c]= [X T] X = a T = [b,c] [g(a)] = [X Y] X = g(a) Y = [] [a,b,c] = [X,Y T] X = a Y = b T = [c] no = [X T] Programmierkurs Prolog p.28

Die anonyme Variable _ Jedes vorkommen dieser Variable ist unhabängig von den anderen Vorkommen, d.h jedes mal das diese Variable vorkommt wird sie neu instanziiert. Die Bindungen dieser Variable sind unsicthbar, d.h. sie werden nicht gespeichert und werden auch nicht von Prolog ausgegeben.?- f(a,b,c)=f(x,b,x) no?- f(a,b,c)=f(,b, ) yes?- [a,b,c,d] = [H T] H = a T = [b,c,d]?- [a,b,c,d] = [H ] H = a Programmierkurs Prolog p.29

Member / Das Predikat member/2 testet ob ein Objekt sich in einer Liste befindet / % Basisklausel member(x,[x ]). % Recursive Klausel member(x, [Y T] :- member(x,t). Programmierkurs Prolog p.30

Append / Das Predikat append/3 konkateniert zwei Listen / % Basisklausel append([],x,x). % Recursive Klausel append([x T],Y,[X C]) :- append(t,y,c). Programmierkurs Prolog p.31

Zusammenfassung Listen sind rekursive Datenstrukturen mit denen geordnete Mengen von Objekten dargestellt werden können Anonyme variable Nächste Woche: Arithmetik und mehr zu Listen. Übungsaufgaben: Das Übungsblatt ist auf der Web-Seite. Programmierkurs Prolog p.32