3.2.6 Sprünge. Hier: Beschränkung auf gute Sprünge wie return break continue. Beachte: Ein Sprung hat keinen Effekt auf die Programmvariablen.
|
|
- Gretel Vogt
- vor 6 Jahren
- Abrufe
Transkript
1 3.2.6 Sprünge (1.3.5 ) Hier: Beschränkung auf gute Sprünge wie return break continue Beachte: Ein Sprung hat keinen Effekt auf die Programmvariablen. { P }... { Q } break L;... { Q } { P } L : {... { Q } break L;... } { Q } { Q } break L; muss für alle break L; im Block gelten 3.2 1
2 { I C }... { I } continue L;... { I } { I } while( C ){... { I } continue L;... } { I C } { I } continue L; muss für alle continue L; im Schleifenrumpf gelten. Ähnliche Regeln gelten für break und continue in anderen Kontexten
3 3.2.7 Prozeduren Eigentliche Prozeduren void m(t x){...} : { P(v,x) }... { Q( v,v,x) } return;... { Q('v,v,x) } { P(v,x) } {... return;... } { Q(v,v,x) } { Q } muss vor jedem return im Block gelten Beachte: x bedeutet stets das alte x! (weil x Wertparameter ist, ) 3.2 3
4 Beispiel ohne return : int value; /** * pre: value>d && d>0 * post: value'==value-d && value'>0 */ void decr(int d) { {value>d && d>0 } value -= d; {value=='value-d && value>0 } } 3.2 4
5 Funktionsprozeduren T m(...){...} : { P }... { Q result E } return E ;... { True } { P } {... return E ;... } { Q } Q bezieht sich auch auf die Pseudovariable result (3.1.3, S. 19). {Q result E } muss vor jedem return E; im Block gelten. Die E müssen erfolgreich und effektfrei ausgewertet werden können
6 3.2.8 Prozeduraufrufe Eigentliche Prozeduren ohne Parameter mit Parametern Funktionsprozeduren Rekursive Prozeduren 3.2 6
7 Eigentliche Prozeduren ohne Parameter /** * pre: P(v) * post: Q(v,v ) **/ void m() {...} { P } m { Q } { P } m(); { Q } P, Q machen Aussagen über alle in der direkten Umgebung von m sichtbaren Variablen v (3.1.3 ). Praktische Konvention: in P, Q nicht erwähnte Variablen bleiben unverändert (das erspart Aussagen der Art a=a ). P, Q enthalten keine lokalen Variablen von m
8 Beispiel: float x,y; final float eps =...; /** * pre: x>=0 * post: abs(x'*x'-x)<eps && x'>=0 **/ void sqrt() {...} Die Regel erlaubt beispielsweise den Schluss {x>=0 } sqrt(); {abs(x*x-'x)<eps && y='y } aber beispielsweise nicht {x=y*y && y>=1 } sqrt(); {abs(x-y)<eps } Ursachen: - explizite Bezugnahme auf alte Werte, - kein Einbeziehen weiterer, im Kontext benötigter Zusicherungen
9 Daher: { P(v) } m { Q(v,v ) } { P(v) v Q(v,v ) R(v ) } m(); { R(v) } Beh.: {x=y*y && y>=1 } sqrt(); {abs(x-y)<eps } Bew.: {x=y*y && y>=1 } {x>=0 && any(\x' y' -> gilt mit x'==y und y'==y abs(x'*x'-y*y)<eps && x'>=0 && y'==y && abs(x'*x'-y'*y')<eps && x'>=0 && y'>=1 )float } sqrt(); {abs(x*x-y*y)<eps && x>=0 && y>=1 } {abs(x+y)*abs(x-y)<eps && x>=0 && y>=1 } {abs(x-y)<eps } QED
10 Eigentliche Prozeduren mit Parametern /** * pre: P(v,x) * post: Q(v,v,x) **/ void m(t x) {...} { P } m { Q } { P x E } m(e); { Q x 'E } bzw. { P(v,x) } m { Q(v,v,x) } { P(v,E) v Q(v,v,E) R(v ) } m(e); { R(v) } sofern die Auswertung von E erfolgreich und ohne Effekte ist
11 Beispiel: float r,y; final float eps =...; /** * pre: x>=0 * post: abs(r'*r'-x)<eps && r'>=0 **/ void sqrt(float x) {... } Die erste Regel erlaubt lediglich Schlüsse wie {True } {y*y>=0 } sqrt(y*y); {abs(r*r-'y*'y)<eps && y=='y } {abs(r*r-y*y)<eps }
12 Beh.: {y>=1 } sqrt(y*y); {abs(r-y)<eps } Bew. nicht korrektes Haskell! mit zweiter Regel: {y>=1 } {y*y>=0 && any(\(r',y') -> gilt mit r'==y und y'==y abs(r'*r'-y*y)<eps && r'>=0 && y'==y && abs(r'*r'-y'*y')<eps && r'>=0 && y'>=1 ) (float,float) } sqrt(y*y); {abs(r*r-y*y)<eps && r>=0 && y>=1 } {abs(r+y)*abs(r-y)<eps && r>=0 && y>=1 } {abs(r-y)<eps } (wie auf s. 8) QED
13 Variablenparameter statt Wertparameter: /** * pre: P(v,x) * post: Q(v,v,x,x ) **/ void m(var T x) {...} { P(v,x) } m { Q(v,v,x,x ) } { P(v,A) v,a Q(v,v,A,A ) R(v,A ) } m(a); { R(v,A) } unter der Bedingung der Alias-Freiheit (vgl !): wenn m auf eine Variable unter verschiedenen Namen zugreifen kann, dann darf es dabei keine Schreibzugriffe geben!
14 Warum Alias-Freiheit? int a, b; /** * pre: -- * post: a'==1 && b'==2 && x'==3 && y'==4 */ void m(var int x, VAR int y) { a = 1; b = 2; x = 3; y = 4; } Man beweist leicht {True } m(a,a); {a==1 && b==2 && a==3 && a==4 }... und was sich wirklich ergibt ist implementierungsabhängig!
15 Ergebnisparameter : /** * pre: P(v) * post: Q(v,v,x ) **/ void m(out T x) {...} { P(v) } m { Q(v,v,x ) } { P(v) (Q(v,v,A ) R(v,A )) } m(a); { R(v,A) } ebenfalls unter der Bedingung der Alias-Freiheit!
16 Folgerung: Spezifikation muss Angabe enthalten, auf welche nichtlokalen Variablen und welche Parameter schreibend zugegriffen wird! Aufruf muss aliasfrei sein. Achtung z.b. bei m(a[i],a[k])! Fazit: Variablen- und Ergebnisparameter sind mit Vorsicht zu genießen
17 Funktionsprozeduren ohne Nebenwirkungen /** * pre: P(v,x) * post: Q(result,v,x) (Keine Nebenwirkungen: v = v) */ (Konvention: result ohne ) Res m(arg x) {...} { P(v,x) } m { Q(result,v,x } P(v,E) Q(m(E), v, E) sofern die Auswertung von E erfolgreich und ohne Effekte ist
18 Beispiel: final float eps =...; /** * pre: x >= 0 * post: abs(result*result - x) < eps */ float sqrt(float x) {...}... sqrt(a*a)... Dafür gilt P(v,E) tatsächlich: a*a >= 0 Somit liefert die Regel abs(sqrt(a*a)*sqrt(a*a) - a*a) < eps
19 3.2.9 Rekursive Prozeduren Korrektheit der Prozedur setzt Korrektheit der Prozedur voraus?? Genauer:... setzt Korrektheit der Prozedur für andere Eingabe voraus. Verifikation durch vollständige Induktion über die linear geordneten Eingabedaten e 0, e 1, e 2,
20 Explizite Induktion: beweisen, dass die Prozedur mit korrektem Ergebnis terminiert, I. falls sie - für e 0,e 1,...,e k - keinen rekursiven Aufruf ausführt, II. falls - für e n mit n>k - alle rekursiven Aufrufe sich auf Eingabedaten e i mit i<n beziehen und diese Aufrufe mit korrekten Ergebnissen terminieren. Implizite Induktion: beweisen, dass die Prozedur partiell korrekt ist, falls sie partiell korrekt ist (!); beweisen, dass die Rekursion terminiert. (Vgl. Schleifen)
21 int f; /** * pre: n >= 0 * post: f' == fact n */ void fakultaet(int n) { {n>=0 } {n>=0 && n=='n } if(n==0) {n==0 && n=='n } {1==fact 'n } f = 1; {f==fact 'n } else { {n>0 && n=='n } Beispiel 1 - Fakultät: Partielle Korrektheit
22 else { {n>0 && n=='n } {n-1>=0 && any(\(f',n') -> Regel aus (S. 11) f'==fact(n-1) && n'==n && f'==fact(n-1) && n'=='n )(int,int) } fakultaet(n-1); {f==fact(n-1) && n=='n } {f*n==fact n && n=='n } f *= n; {f==fact n && n=='n } {f==fact 'n } } // end if {f==fact 'n } (Beachte Regel aus 3.2.7) } // end fakultaet n'==n gehört zu Q(v,v,E), weil das n in der Umgebung des rekursiven Aufrufs für diesen Aufruf nicht das n der Spezifikation ist
23 Termination: (vollständige Induktion:) I. Die Methode terminiert für n=0. II. Für ein bestimmtes n>0 führt die Methode einen rekursiven Aufruf mit Argument n-1 durch, terminiert also genau dann, wenn sie für n-1 terminiert. III. Somit terminiert sie für alle n
24 Beispiel 2: Türme von Hanoi (1.4.3 ) /** Stack-Parameter werden wie Variablen-Parameter behandelt! * pre: n >= 0 * post: src' == drop n src && * dst' == take n src ++ dst && * aux' == aux */ void hanoi(int n, Stack src, Stack dst, Stack aux) { } if(n>0) { hanoi(n-1, src, aux, dst); move(src,dst); // hanoi(n-1, aux, dst, src); } Termination ist gesichert (wie oben bei Fakultät). Partielle Korrektheit - Beweisskizze:
25 {src == 'src && dst == 'dst && aux == 'aux } { s a d..... } hanoi(n-1, src, aux, dst); {src == drop(n-1)'src && aux == take(n-1)'src ++ 'aux && dst == 'dst } { s d a..... } move(src,dst); {src == drop n 'src && dst == head(drop(n-1)'src) ++ 'dst && aux == take(n-1)'src ++ 'aux... } { a d s Q(aux,a,dst,d,src,s ) R(s,d,a ) } hanoi(size-1, aux, dst, src); {src == drop n 'src && dst == take n 'src ++ 'dst && aux == 'aux R(src,dst,aux) }
26 Nachweis der Korrektheit des letzten Aufrufs: {src == drop n 'src && dst == head(drop(n-1)'src) ++ 'dst && aux == take(n-1)'src ++ 'aux } { a d s Q(aux,a,dst,d,src,s ) R(s,d,a ) } a'==drop(n-1)aux && d'==take(n-1)aux ++ dst && s'==src s'==drop n 'src && d'==take n 'src ++ 'dst && a'=='aux wird erfüllt durch s'==src wegen a'=='aux wegen d'==take n 'src ++ 'dst wegen und (für die anderen Aufrufe entsprechend)
Kapitel 5: Abstrakte Algorithmen und Sprachkonzepte. Elementare Schritte
Elementare Schritte Ein elementarer Berechnungsschritt eines Algorithmus ändert im Allgemeinen den Wert von Variablen Zuweisungsoperation von fundamentaler Bedeutung Zuweisungsoperator In Pascal := In
MehrC.3 Funktionen und Prozeduren
C3 - Funktionen und Prozeduren Funktionsdeklarationen in Pascal auch in Pascal kann man selbstdefinierte Funktionen einführen: Funktionen und Prozeduren THEN sign:= 0 Funktion zur Bestimmung des Vorzeichens
MehrTechnische Informatik 1 Übung 2 Assembler (Rechenübung) Georgia Giannopoulou (ggeorgia@tik.ee.ethz.ch) 22./23. Oktober 2015
Technische Informatik 1 Übung 2 Assembler (Rechenübung) Georgia Giannopoulou (ggeorgia@tik.ee.ethz.ch) 22./23. Oktober 2015 Ziele der Übung Aufgabe 1 Aufbau und Aufruf von Funktionen in Assembler Codeanalyse
Mehrzu große Programme (Bildschirmseite!) zerlegen in (weitgehend) unabhängige Einheiten: Unterprogramme
Bisher Datentypen: einfach Zahlen, Wahrheitswerte, Zeichenketten zusammengesetzt Arrays (Felder) zur Verwaltung mehrerer zusammengehörender Daten desselben Datentypes eindimensional, mehrdimensional, Array-Grenzen
Mehr1. Erste Schritte 2. Einfache Datentypen 3. Anweisungen und Kontrollstrukturen 4. Verifikation 5. Reihungen (Arrays)
1. Erste Schritte 2. Einfache Datentypen 3. Anweisungen und Kontrollstrukturen 4. Verifikation 5. Reihungen (Arrays) II.1.3. Anweisungen und Kontrollsttukturen - 1 - 3. Anweisungen und Kontrollstrukturen
MehrFunktionale Programmierung. Funktionale Programmierung: Vorlesungsüberblick. Eigenschaften rein funktionaler Programmierung
Funktionale Programmierung 1 Funktionale Programmierung: Vorlesungsüberblick 1. Funktionale Programmierung Prinzipien funktionaler Programmierung Funktionale Programmierung in prozeduralen Sprachen Rekursive
MehrSpezifikation der zulässigen Parameter. Bemerkungen: Bemerkungen: (2) Design by Contract:
Spezifikation der zulässigen Parameter Bemerkungen: Bei jeder (partiellen) Funktion muss man sich überlegen und dokumentieren, welche aktuellen Parameter bei einer Anwendung zulässig sein sollen. Der Anwender
MehrÜbersicht Programmablaufsteuerung
Übersicht Programmablaufsteuerung Konditionale Verzweigung: if - else switch-anweisung Schleifenkonstrukte: while, do - while for Schleife Sprung-Anweisungen: break, continue, goto, return Anweisungen
MehrEinführung in die Informatik 1
Einführung in die Informatik 1 Algorithmen und algorithmische Sprachkonzepte Sven Kosub AG Algorithmik/Theorie komplexer Systeme Universität Konstanz E 202 Sven.Kosub@uni-konstanz.de Sprechstunde: Freitag,
MehrKontrollstrukturen und Funktionen in C
Kontrollstrukturen und Funktionen in C Lernziele: Vertiefen der Kenntnisse über Operatoren, Kontrollstrukturen und die Verwendung von Funktionen. Aufgabe 1: Quickies: Datentypen in C a) Was sind die elementaren
MehrProgrammierung in Python
Programmierung in Python imperativ, objekt-orientiert dynamische Typisierung rapid prototyping Script-Sprache Funktionales und rekursives Programmieren P raktische Informatik 1, W S 2004/05, F olien P
MehrGrundlagen der Programmierung (Vorlesung 15)
Grundlagen der Programmierung (Vorlesung 15) Ralf Möller, FH-Wedel Vorige Vorlesung Blöcke, Funktionen Auswertestrategien Inhalt dieser Vorlesung Prozeduren Rekursion Lernziele Grundlagen der systematischen
MehrGrundlagen der Programmierung in C Funktionen
Der erste Mechanismus für Code-Reuse! Grundlagen der Programmierung in C Funktionen Wintersemester 2005/2006 G. Zachmann Clausthal University, Germany zach@in.tu-clausthal.de Ältester Mechanismus für Code-Reuse:
MehrRekursion. Selbstbezug, rekursive Funktionen, rekursive Prozeduren, Terminierung, Effizienz, Korrektheit, Rekursion und Induktion
Rekursion Selbstbezug, rekursive Funktionen, rekursive Prozeduren, Terminierung, Effizienz, Korrektheit, Rekursion und Induktion Ein kleines Problem Schreiben Sie eine Methode writebin, die eine Dezimalzahl
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
MehrTechnische Universität Braunschweig Institut für Programmierung und Reaktive Systeme
Technische Universität Braunschweig Institut für Programmierung und Reaktive Systeme Programmieren I Dr. Werner Struckmann 7. September 2015 Name: Vorname: Matrikelnummer: Kennnummer: Anrede: Frau Herr
MehrGrundlagen der Programmierung Prof. H. Mössenböck. 6. Methoden
Grundlagen der Programmierung Prof. H. Mössenböck 6. Methoden Parameterlose Methoden Beispiel: Ausgabe einer Überschrift class Sample { static void printheader() { // Methodenkopf Out.println("Artikelliste");
MehrAlgorithmische Kernsprache. Zuweisung, einfache und bedingte Anweisung, Blöcke, Schleifen, return, debugging.
Algorithmische Kernsprache Zuweisung, einfache und bedingte Anweisung, Blöcke, Schleifen, return, debugging. Ausdrücke Anweisungen Ausdrücke bezeichnen einen Wert Kontext stellt Werte von Variablen Werte
MehrGrundlagen der Programmierung in C++ Kontrollstrukturen
Grundlagen der Programmierung in C++ Kontrollstrukturen Wintersemester 2005/2006 G. Zachmann Clausthal University, Germany zach@in.tu-clausthal.de Block Keine Kontrollstruktur im eigentlichen Sinn Dient
MehrGrundlagen der Programmierung (Vorlesung 14)
Grundlagen der Programmierung (Vorlesung 14) Ralf Möller, FH-Wedel Vorige Vorlesung Verifikation von Anweisungen und Anweisungsfolgen Schleifen Inhalt dieser Vorlesung Funktionen und Prozeduren Lernziele
MehrProgrammierkurs Java
Programmierkurs Java Dr. Dietrich Boles Aufgaben zu UE16-Rekursion (Stand 09.12.2011) Aufgabe 1: Implementieren Sie in Java ein Programm, das solange einzelne Zeichen vom Terminal einliest, bis ein #-Zeichen
MehrJava Kurs für Anfänger Einheit 5 Methoden
Java Kurs für Anfänger Einheit 5 Methoden Ludwig-Maximilians-Universität München (Institut für Informatik: Programmierung und Softwaretechnik von Prof.Wirsing) 22. Juni 2009 Inhaltsverzeichnis Methoden
MehrC-Probeklausur (Informatik 1; Umfang: C, Teil 1; SS07)
C-Probeklausur (Informatik 1; Umfang: C, Teil 1; SS07) 1. Aufgabe 6 Punkte Geben Sie Definitionen an für: float var; 1 a) eine float-variable var: b) einen Zeiger pvar, der float *pvar = &var; 1 auf die
MehrRekursion. Beispiel Fakultät (iterativ) Rekursive Java-Implementierung. Beispiel Fakultät (rekursiv) n! = n
Rekursion Beispiel Fakultät (iterativ) Methoden können Methoden aufrufen Methoden können nicht nur andere Methoden aufrufen, sondern auch sich selbst Eine Methode, die sich selbst (direkt oder indirekt)
MehrProgrammiersprache 1 (C++) Prof. Dr. Stefan Enderle NTA Isny
Programmiersprache 1 (C++) Prof. Dr. Stefan Enderle NTA Isny 7. Funktionen Einleitung Nach dem Prinzip Divide and Conquer bietet es sich an, größere Aufgaben in kleinere Teile zu unterteilen. Anweisungsblöcke,
MehrGrundlagen der Programmierung Prof. H. Mössenböck. 4. Schleifen
Grundlagen der Programmierung Prof. H. Mössenböck 4. Schleifen While-Schleife Führt eine Anweisungsfolge aus, solange eine bestimmte Bedingung gilt i 1 sum 0 i n sum sum + i i i + 1 i = 1; sum = 0; while
MehrAbstrakte Algorithmen und Sprachkonzepte
Abstrakte Algorithmen und Sprachkonzepte Thomas Röfer Begriff des Algorithmus Algorithmenaufbau Programmiersprachliche Grundkonzepte Interative und rekursive Algorithmen Rückblick Aufbau und Funktionsweise
MehrJava 8. Elmar Fuchs Grundlagen Programmierung. 1. Ausgabe, Oktober 2014 JAV8
Java 8 Elmar Fuchs Grundlagen Programmierung 1. Ausgabe, Oktober 2014 JAV8 5 Java 8 - Grundlagen Programmierung 5 Kontrollstrukturen In diesem Kapitel erfahren Sie wie Sie die Ausführung von von Bedingungen
MehrObjektorientierte Programmierung
Objektorientierte Programmierung Eine Einführung mit anschaulichen Beispielen aus der Java-Welt apl. Prof. Dr. Achim Ebert Inhalt Kapitel 3: Kontrollstrukturen Einfache Anweisungen Anweisungsblöcke Steuerung
MehrKlausur C-Programmierung / 15.02.2014 / Klingebiel / 60 Minuten / 60 Punkte
Klausur C-Programmierung / 15.02.2014 / Klingebiel / 60 Minuten / 60 Punkte Musterlösung 1. Aufgabe (5 Punkte) Im folgenden Programmcode sind einige Fehler enthalten. Finden und markieren Sie mindestens
Mehrzu große Programme (Bildschirmseite!) zerlegen in (weitgehend) unabhängige Einheiten: Unterprogramme
Bisher Datentypen: einfach Zahlen, Wahrheitswerte, Zeichenketten zusammengesetzt Arrays (Felder) zur Verwaltung mehrerer zusammengehörender Daten desselben Datentypes eindimensional, mehrdimensional, Array-Grenzen
MehrJava Einführung ABLAUFSTEUERUNG Kapitel 3 und 4
Java Einführung ABLAUFSTEUERUNG Kapitel 3 und 4 Inhalt dieser Einheit Merkmale und Syntax der verschiedenen Kontrollstrukturen: if else switch while do while for break, continue EXKURS: Rekursion 2 Kontrollstrukturen
MehrGliederung. Tutorium zur Vorlesung. Gliederung. Gliederung. 1. Gliederung der Informatik. 1. Gliederung der Informatik. 1. Gliederung der Informatik
Informatik I WS 2012/13 Tutorium zur Vorlesung 1. Alexander Zietlow zietlow@informatik.uni-tuebingen.de Wilhelm-Schickard-Institut für Informatik Eberhard Karls Universität Tübingen 11.02.2013 1. 2. 1.
MehrEinstieg in die Informatik mit Java
Vorlesung vom 18.4.07, Grundlagen Übersicht 1 Kommentare 2 Bezeichner für Klassen, Methoden, Variablen 3 White Space Zeichen 4 Wortsymbole 5 Interpunktionszeichen 6 Operatoren 7 import Anweisungen 8 Form
MehrKapitel 5: Applikative Programmierung
Kapitel 5: Applikative Programmierung In der applikativen Programmierung wird ein Programm als eine mathematische Funktion von Eingabe-in Ausgabewerte betrachtet. Das Ausführen eines Programms besteht
MehrErwin Grüner 09.02.2006
FB Psychologie Uni Marburg 09.02.2006 Themenübersicht Folgende Befehle stehen in R zur Verfügung: {}: Anweisungsblock if: Bedingte Anweisung switch: Fallunterscheidung repeat-schleife while-schleife for-schleife
Mehr12. Rekursion Grundlagen der Programmierung 1 (Java)
12. Rekursion Grundlagen der Programmierung 1 (Java) Fachhochschule Darmstadt Haardtring 100 D-64295 Darmstadt Prof. Dr. Bernhard Humm FH Darmstadt, 24. Januar 2006 Einordnung im Kontext der Vorlesung
MehrOperatoren für elementare Datentypen Bedingte Anweisungen Schleifen. Programmieren I. Martin Schultheiß. Hochschule Darmstadt Wintersemester 2010/2011
Programmieren I Martin Schultheiß Hochschule Darmstadt Wintersemester 2010/2011 1 Operatoren für elementare Datentypen 2 Bedingte Anweisungen 3 Schleifen Zuweisungsoperator Die Zuweisung von Werten an
MehrC allgemein. C wurde unter und für Unix entwickelt. Vorläufer sind BCPL und B.
C-Crash-Kurs Eine kurze, keinesfalls erschöpfende Einführung in die Sprache C für Studierende, die eine strukturierte imperative Programmiersprache beherrschen. Die Vorstellung erfolgt am Beispiel von
MehrRekursion. Annabelle Klarl. Einführung in die Informatik Programmierung und Softwareentwicklung
Rekursion Annabelle Klarl Zentralübung zur Vorlesung Einführung in die Informatik: http://www.pst.ifi.lmu.de/lehre/wise-12-13/infoeinf WS12/13 Aufgabe 1: Potenzfunktion Schreiben Sie eine Methode, die
MehrWiederholung Wozu Methoden? Methoden Schreiben Methoden Benutzen Rekursion?! Methoden. Javakurs 2012, 3. Vorlesung
Wiederholung Wozu? Schreiben Benutzen Rekursion?! Javakurs 2012, 3. Vorlesung maggyrz@freitagsrunde.org 5. März 2013 Wiederholung Wozu? Schreiben Benutzen Rekursion?! 1 Wiederholung 2 Wozu? 3 Schreiben
MehrModellierung und Programmierung 1
Modellierung und Programmierung 1 Prof. Dr. Sonja Prohaska Computational EvoDevo Group Institut für Informatik Universität Leipzig 19. November 2015 Gültigkeitsbereich (Scope) von Variablen { int m; {
MehrProseminar Funktionales Programmieren. Stephan Kreutzer
Proseminar Funktionales Programmieren Die Programmiersprache LISP Stephan Kreutzer Teil I: Funktionales Programmieren Imperative Sprachen Imperative Sprachen: Befehlsorientiert Imperative Sprachen orientieren
MehrGroßübung zu Einführung in die Programmierung
Großübung zu Einführung in die Programmierung Daniel Bimschas, M.Sc. Institut für Telematik, Universität zu Lübeck https://www.itm.uni-luebeck.de/people/bimschas Inhalt 1. Besprechung Übung 4 Iteration
MehrEinführung in die Java- Programmierung
Einführung in die Java- Programmierung Dr. Volker Riediger Tassilo Horn riediger horn@uni-koblenz.de WiSe 2012/13 1 Rückblick Datentypen (int, long, double, boolean, String) Variablen und Variablendeklarationen
MehrÜbersicht. Einführung in die Programmierung. main. main. main. main. Speicherverwaltung. Definition nach ANSI C:
Übersicht Einführung in die Programmierung Bachelor of Science die -Funktion Prof. Dr. Rethmann Fachbereich Elektrotechnik und Informatik Hochschule Niederrhein WS 009/0 Einführung in die Programmierung
MehrEinführung Datentypen Verzweigung Schleifen. Java Crashkurs. Kim-Manuel Klein May 4, 2015
Java Crashkurs Kim-Manuel Klein (kmk@informatik.uni-kiel.de) May 4, 2015 Quellen und Editoren Internet Tutorial: z.b. http://www.java-tutorial.org Editoren Normaler Texteditor (Gedit, Scite oder ähnliche)
MehrC++ - Funktionen und mehr. Kerstin Gößner und Ralf Wondratschek
C++ - Funktionen und mehr Kerstin Gößner und Ralf Wondratschek Übersicht Deklaration, Definition und Initialisierung Variablen- und Konstantendeklaration Funktionsaufrufe und rückgabewerte Technische Grundlage
MehrInhalt. 4.7 Funktionen
Inhalt Inhalt: 4. Programmiersprache C 4.1 Programmaufbau in C 4.2 Basisdatentypen und einfache Anweisungen 4.3 Steuerfluss-Konstrukte 4.4 Arbeit mit indizierten Größen (Felder) 4.5 Arbeit mit Pointern
MehrInformatik II Musterlösung
Ludwig-Maximilians-Universität München SS 2006 Institut für Informatik Übungsblatt 4 Prof. Dr. M. Wirsing, M. Hammer, A. Rauschmayer Informatik II Musterlösung Zu jeder Aufgabe ist eine Datei abzugeben,
Mehr! Sprachkonstrukte für den funktionalen Programmierstil in Java. ! Programmiertechniken:
Überblick über dieses Kapitel Grundlagen der Programmierung Dr. Christian Herzog Technische Universität München Wintersemester 2011/2012 Kapitel 5: Funktionaler Programmierstil und Rekursion! Sprachkonstrukte
MehrProgrammieren in C. Rekursive Funktionen. Prof. Dr. Nikolaus Wulff
Programmieren in C Rekursive Funktionen Prof. Dr. Nikolaus Wulff Rekursive Funktionen Jede C Funktion besitzt ihren eigenen lokalen Satz an Variablen. Dies bietet ganze neue Möglichkeiten Funktionen zu
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
Mehr5. Spezifikation und Verifikation von Programmen. Hier: Spezifikation einfacher Programme
5. Spezifikation und Verifikation von Programmen Programmentwicklung: genaue Kenntnis der gewünschten Leistungen offensichtlich unabdingbar In größeren Systemen: Anforderungsdefinition legt fest: - Funktionalität
MehrKlausurteilnehmer. Wichtige Hinweise. Note: Klausur Informatik Programmierung, 17.09.2012 Seite 1 von 8 HS OWL, FB 7, Malte Wattenberg.
Klausur Informatik Programmierung, 17.09.2012 Seite 1 von 8 Klausurteilnehmer Name: Matrikelnummer: Wichtige Hinweise Es sind keinerlei Hilfsmittel zugelassen auch keine Taschenrechner! Die Klausur dauert
MehrObjektorientierte Programmierung OOP Programmieren mit Java
Übungen: 6 Schleifen Objektorientierte Programmierung OOP Programmieren mit Java 1. do-schleife 2. while-schleife 3. a) c) Verschiedene for-schleifen 6 Schleifen Übungen 4. for-schleife: halber Tannenbaum
MehrÜbungen zu C++ Kapitel 3
Übungen zu C++ Kapitel 3 Aufgabe 1 Gib jeweils den Funktionskopf für die folgenden Funktionen an! a) Die Funktion Hypotenuse übernimmt zwei double-variable Seite1 und Seite2 und liefert ein double-ergebnis
MehrProgrammiertechnik II
Analyse von Algorithmen Algorithmenentwurf Algorithmen sind oft Teil einer größeren Anwendung operieren auf Daten der Anwendung, sollen aber unabhängig von konkreten Typen sein Darstellung der Algorithmen
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))
MehrProgrammiersprache 1 (C++) Prof. Dr. Stefan Enderle NTA Isny
Programmiersprache 1 (C++) Prof. Dr. Stefan Enderle NTA Isny 5. Kontrollstrukturen Allgemein Kontrollstrukturen dienen zur Steuerung des Programmablaufs. (Bemerkung: C und C++ besitzen die selben Kontrollstrukturen.)
MehrGebundene Typparameter
Gebundene Typparameter interface StringHashable { String hashcode(); class StringHashMap { public void put (Key k, Value v) { String hash = k.hashcode();...... Objektorientierte
MehrProgrammierung in C++
Skript zur Vorlesung Programmierung in C++ IT Kompaktkurs Teil 14: Rekursive Programmierung Wintersemester 2000/2001 Prof. Dr. Manfred Beham Fachhochschule Amberg-Weiden Empfohlene Literatur: Die C++ Bibel:
MehrProgrammieren in C. Operatoren, Variablen und deren Sichtbarkeit. Prof. Dr. Nikolaus Wulff
Programmieren in C Operatoren, Variablen und deren Sichtbarkeit Prof. Dr. Nikolaus Wulff Auswertung von Ausdrücken Was passiert wenn ein Ausdruck wie z. B. int y,x=2; y = ++x * x++; im Computer abgearbeitet
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
MehrJava Einführung Methoden. Kapitel 6
Java Einführung Methoden Kapitel 6 Inhalt Deklaration und Aufruf von Methoden Lokale und globale Namen (Bezeichner) Sichtbarkeit und Lebensdauer von Variablen in Methoden Überladen von Methoden 2 Methoden
MehrEinführung in die Programmierung mehr Ein- und Ausgabe, Programmfluss, Funktionen. Arvid Terzibaschian
Einführung in die Programmierung Arvid Terzibaschian 1 Klausurtermine Abstimmung beendet: Einführung in die Programmierung Freitag, 28.2.2014, wahrscheinlich 11:00 Basiskonzepte des Rechnerbetriebs Freitag,
MehrÜbersicht. Datenstrukturen und Algorithmen Vorlesung 5: Rekursionsgleichungen (K4) Übersicht. Binäre Suche. Joost-Pieter Katoen. 20.
Übersicht Datenstrukturen und Algorithmen Vorlesung 5: (K4) Joost-Pieter Katoen Lehrstuhl für Informatik 2 Software Modeling and Verification Group http://www-i2.informatik.rwth-aachen.de/i2/dsal12/ 20.
MehrModProg 15-16, Vorl. 5
ModProg 15-16, Vorl. 5 Richard Grzibovski Nov. 18, 2015 1 / 29 Übersicht Übersicht 1 Logische Operationen 2 Priorität 3 Verzweigungen 4 Schleifen 2 / 29 Logische Werte Hauptkonzept: Besitzt ein C-Ausdruck
MehrKurze Einführung in die Programmiersprache C++ und in Root
Kurze Einführung in die Programmiersprache C++ und in Root Statistik, Datenanalyse und Simulation; 31.10.2006 Inhalt 1 Einführung in die Programmiersprache C++ Allgemeines Variablen Funktionen 2 1 Einführung
MehrEinfache Rechenstrukturen und Kontrollfluss II
Einfache Rechenstrukturen und Kontrollfluss II Martin Wirsing in Zusammenarbeit mit Moritz Hammer und Axel Rauschmayer http://www.pst.informatik.uni-muenchen.de/lehre/ss06/infoii/ SS 06 Ziele Lernen imperative
MehrUnterprogramme, Pointer und die Übergabe von Arrays
Unterprogramme, Pointer und die Übergabe von Arrays Unterprogramme Wie schon im Abschnitt über Funktionen erwähnt, versteht man unter einem Unterprogramm im engeren Sinn eine Prozedur, welche die Werte
MehrProgrammiersprache C. Grundlegende Konstrukte 5/1
Programmiersprache C Grundlegende Konstrukte 5/1 Variablen Haskell Benannter Ausdruck eines Zwischenergebnisses Unveränderbar nach Vollzug der Bindung C Benannter Speicherplatz für Zwischenergebnisse Allokation
MehrEinführung in die Programmierung
: Inhalt Einführung in die Programmierung Wintersemester 2010/11 Prof. Dr. Günter Rudolph Lehrstuhl für Algorithm Engineering Fakultät für Informatik TU Dortmund Wiederholungen - while - do-while - for
MehrII. Grundlagen der Programmierung. 9. Datenstrukturen. Daten zusammenfassen. In Java (Forts.): In Java:
Technische Informatik für Ingenieure (TIfI) WS 2005/2006, Vorlesung 9 II. Grundlagen der Programmierung Ekkart Kindler Funktionen und Prozeduren Datenstrukturen 9. Datenstrukturen Daten zusammenfassen
MehrProgrammierung in C. Grundlagen. Stefan Kallerhoff
Programmierung in C Grundlagen Stefan Kallerhoff Vorstellungsrunde Name Hobby/Beruf Schon mal was programmiert? Erwartungen an den Kurs Lieblingstier Für zu Hause C-Buch online: http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/
Mehr2.5 Programmstrukturen Entscheidung / Alternative
Entscheidung, ob der folgende Anweisungsblock ausgeführt wird oder ein alternativer Block Entscheidung ob die Bedingung wahr oder falsch (True / False) ist Syntax: 2.5 Programmstrukturen 2.5.1 Entscheidung
MehrProgrammieren I. Strategie zum Entwurf von Klassen. Beispiele. Design von Klassen. Dr. Klaus Höppner. Beispiel: Bibliothek
Programmieren I Dr. Klaus Höppner Hochschule Darmstadt Wintersemester 2008/2009 1 / 22 2 / 22 Strategie zum Entwurf von Klassen Beispiele Objektorientierte Sichtweise: Mit welchen Objekten habe ich es
MehrDie Programmiersprache C99: Zusammenfassung
Die Programmiersprache C99: Zusammenfassung Jörn Loviscach Versionsstand: 7. Dezember 2010, 19:30 Die nummerierten Felder sind absichtlich leer, zum Ausfüllen in der Vorlesung. Videos dazu: http://www.youtube.com/joernloviscach
MehrProgrammentwicklung I für Hörer anderer Fachrichtungen -Wintersemester 2003/04- Abschlussklausur 20.02.2004
Programmentwicklung I für Hörer anderer Fachrichtungen -Wintersemester 2003/04- Abschlussklausur 20.02.2004 Name : Vorname : Matrikelnummer : Hauptfach : Nebenfach/Fachrichtung Hinweise : 1. Überprüfen
MehrAlgorithmen und Datenstrukturen Wintersemester 2004/ November T(n) = T(n a) + T(a) + n
Lehrstuhl für Praktische Informatik III Norman May B6, 29, Raum C0.05 68131 Mannheim Telefon: (0621) 181 2517 Email: norman@pi3.informatik.uni-mannheim.de Matthias Brantner B6, 29, Raum C0.05 68131 Mannheim
MehrAbschnitt: Algorithmendesign und Laufzeitanalyse
Abschnitt: Algorithmendesign und Laufzeitanalyse Definition Divide-and-Conquer Paradigma Divide-and-Conquer Algorithmen verwenden die Strategien 1 Divide: Teile das Problem rekursiv in Subproblem gleicher
MehrTheorie zu Übung 8 Implementierung in Java
Universität Stuttgart Institut für Automatisierungstechnik und Softwaresysteme Prof. Dr.-Ing. M. Weyrich Theorie zu Übung 8 Implementierung in Java Klasse in Java Die Klasse wird durch das class-konzept
MehrKomplexität von Algorithmen
Komplexität von Algorithmen Prof. Dr. Christian Böhm WS 07/08 in Zusammenarbeit mit Gefei Zhang http://www.dbs.informatik.uni-muenchen.de/lehre/nfinfosw Ressourcenbedarf - Größenordnungen Prozesse verbrauchen
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
MehrTeil X. Programmverifikation. Spezifikation eines Algorithmus einer Funktion einer Prozedur. Vorbedingungen Parameter Wertebereiche
Teil X Programmverifikation STRUKTURIERTES PROGRAMMIEREN Vorlesung im Wintersemester 2015 Prof. E.G. Schukat-Talamazzini Stand: 24. Juli 2015 Robert W Floyd 1936 2001 Sir Charles Antony Richard Hoare *1934
MehrC/C++ Programmierung
1 C/C++ Programmierung Grundlagen: Anweisungen Sebastian Hack Christoph Mallon (hack mallon)@cs.uni-sb.de Fachbereich Informatik Universität des Saarlandes Wintersemester 2009/2010 2 Anweisungen (Statements)
MehrFunktionen Häufig müssen bestimmte Operationen in einem Programm mehrmals ausgeführt werden. Schlechte Lösung: Gute Lösung:
Funktionen Häufig müssen bestimmte Operationen in einem Programm mehrmals ausgeführt werden. Schlechte Lösung: Der Sourcecode wird an den entsprechenden Stellen im Programm wiederholt Programm wird lang
MehrAssertions (Zusicherungen)
April 10, 2005 Oberseminar Software-Entwicklung Inhalt 1. Einführung (Motivation, Tony Hoare, Programmverifikation) 2. Design by Contract (Idee, Eiffel) 3. Praxis: Programming by Contract for Python 4.
MehrWiederholung und Vertiefung. Programmieren in C. Pointer und so... thoto. /dev/tal e.v. 6. April 2013 (Version vom 11. April 2013) Programmieren in C
Pointer und so... 6. April 2013 (Version vom 11. April 2013) Agenda für Heute 1 Wiederholung und Vertiefung Wiederholung 2 Was sind? Felder und Vektoren? Zeichenketten Wiederholung Wiederholung Funktion
MehrFlussdiagramm / Programmablaufplan (PAP)
Flussdiagramm / Programmablaufplan (PAP) Basissysmbole Grenzstelle (Anfang, Zwischenhalt oder Ende des Programms/Algorithmus) Verbindung Zur Verdeutlichung der Ablaufrichtung werden Linien mit einer Pfeilspitze
MehrInf 12 Aufgaben 14.02.2008
Inf 12 Aufgaben 14.02.2008 Übung 1 (6 Punkte) Ermitteln Sie eine mathematische Formel, die die Abhängigkeit der Suchzeit von der Anzahl der Zahlen N angibt und berechnen Sie mit Ihrer Formel die durchschnittliche
MehrBeispiel 19. December 4, 2009
Beispiel 9 December 4, 2009 Computermathematik (für Informatik) 4. Übungsblatt (Musterlösung) 2. 2. 2009 Die heutigen Übungen sollen mit dem Computeralgebrasystem Sage gelöst werden. Die Lösung der Beispiele
MehrInhaltsverzeichnis. Grundbegriffe der C-Programmierung Für den HI-TECH C-Compiler
Inhaltsverzeichnis Grundbegriffe der C-Programmierung 1. Grundsätzliches... 2 1.1 Darstellung von Werten... 2 1.1.1 Dezimale Zahlendarstellung... 2 1.1.2 Binäre Zahlendarstellung... 3 1.1.3 Hexadezimale
MehrPass by Value Pass by Reference Defaults, Overloading, variable Parameteranzahl
Funktionen Zusammenfassung von Befehlssequenzen als aufrufbare/wiederverwendbare Funktionen in einem Programmblock mit festgelegter Schnittstelle (Signatur) Derartige prozedurale Programmierung erlaubt
MehrPraktikum zu Einführung in die Informatik für LogWiIngs und WiMas Wintersemester 2015/16. Vorbereitende Aufgaben
Praktikum zu Einführung in die Informatik für LogWiIngs und WiMas Wintersemester 2015/16 Fakultät für Informatik Lehrstuhl 14 Lars Hildebrand, Marcel Preuß, Iman Kamehkhosh, Marc Bury, Diana Howey Übungsblatt
MehrHochschule Ravensburg-Weingarten Schriftliche Prüfung Programmieren Prof. Dr. M. Zeller
Hochschule Ravensburg-Weingarten Schriftliche Prüfung Programmieren Prof. Dr. M. Zeller Datum, Zeit, 08:00 09:30 Uhr (90 min) Aufgabenblätter 14 Seiten (einschl. Deckblatt) erreichbare Punktzahl 54 zugelassene
MehrEinführung in die Informatik für Naturwissenschaftler und Ingenieure (alias Einführung in die Programmierung)
Wintersemester 2007/08 Einführung in die Informatik für Naturwissenschaftler und Ingenieure (alias Einführung in die Programmierung) (Vorlesung) Prof. Dr. Günter Rudolph Fakultät für Informatik Lehrstuhl
MehrFunktionale Programmierung
Funktionale Programmierung Jörg Kreiker Uni Kassel und SMA Solar Technology AG Wintersemester 2011/2012 2 Teil II Typen mit Werten und Ausdruck, sogar listenweise 3 Haskell Programme Programm Module ein
MehrEinführung in die C-Programmierung
Einführung in die C-Programmierung Warum C? Sehr stark verbreitet (Praxisnähe) Höhere Programmiersprache Objektorientierte Erweiterung: C++ Aber auch hardwarenahe Programmierung möglich (z.b. Mikrokontroller).
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 &
Mehr