Verzweigung oder bedingte Anweisung Aufgabe Benzinverbrauchrechner Autofahrer tankt

Verzweigung oder bedingte Anweisung

Aufgabe (Benzinverbrauchrechner): Autofahrer tankt sein Auto voll und schreibt den Kilometerstand auf (dreistelliger Tageszähler). Wenn er das nächste Mal tankt, macht er das gleiche und notiert sich zusätzlich noch die getankten Liter. Wie groß ist der Benzinverbrauch pro 100 km ? Flussdiagramm + C-Programm !

Anfang Eingabe(zalt) Eingabe(zneu) Eingabe(bv) d = zneu – zalt bv 100 = bv / d * 100 Ausgabe (bv 100) Ende Schlechte Namensgebung. Selbstsprechendere Namen sind z. B: zählerstand. Alt zählerstand. Neu differenz benzinverbrauch. Pro 100 Km

int main(){ double zalt, zneu, d, bv 100; printf("n. Kilometerstand "); scanf("%lf", &zalt); fflush(stdin); printf("n. Kilometerstand "); scanf("%lf", &zneu); fflush(stdin); printf("n. Benzinverbrauch n"); scanf("%lf", &bv); fflush(stdin); // gleich geht es weiter

d = zneu - zalt; bv 100 = bv/d * 100; printf("L/100 km %f", bv 100); return 0; } Differenz kann negativ werden Wann berechnet das C-Programm ein falsches Ergebnis ?

Beispiel für negative Differenz Zählerstand beim 1. Tankvorgang: 900 km Es werden nun 200 km bis zum nächsten Tankvorgang gefahren. Welcher Kilometerstand steht dann auf dem Tacho? Zählerstand beim 2. Tankvorgang: 100 km Welche Differenz berechnet das Programm? Differenz = 100 – 900 = - 800 km Welcher neue Kilometerstand müsste in Wirklichkeit aber auf dem Tacho stehen? 1000 km + 100 km

Aufgabe: Verändern Sie das Flussdiagramm so, dass dieser Fall (Zählerüberlauf) berücksichtigt wird.

Eingabe(zalt) Eingabe(zneu) Eingabe(bv) d = zneu – zalt bv 100 = bv / d * 100 Ausgabe (bv 100)

Eingabe(zalt) Eingabe(zneu) Eingabe(bv) zneu zalt f w zneu = zneu + 1000 d = zneu – zalt bv 100 = bv / d * 100 Ausgabe(bv 100)

C-Syntax für die Einseitige Verzweigung

Bedingung Nächste auszuführende Anweisung, wenn Bedingung wahr. Wahr bedeutet: Wert des Ausdrucks: !=0 if (Ausdruck) Anweisung; Nächste auszuführende (d. h. diesem roten Rahmen folgende) Anweisung, wenn Bedingung falsch. Falsch bedeutet: Wert des Ausdrucks: 0

Aufgabe: Verändern Sie das C-Programm so, dass dieser Fall (Tachoüberlauf) berücksichtigt wird.

// Eingabe siehe früher. . . if(zneu <= zalt){ zneu = zneu + 1000; } d = zneu - zalt; bv 100 = bv/d * 100; printf("L/100 km %f", bv 100); return 0; bei einer Anweisung sind } Klammern nicht nötig. Trotzdem: Immer Klammern machen.

Struktogramme als Alternative zu Flussdiagrammen

Eingaben, Ausgaben, einfache Anweisungen werden durch Rechtecke dargestellt. Im Kopf des Struktogramms wird der Name des Algorithmus und die Variablen angegeben.

Beispiel

Eingaben, Ausgaben und einfache Anweisungen werden durch Rechtecke dargestellt. Name des Algorithmus (Programmms) Name: Schreinerei fläche: int länge: int breite: int umfang: int eingabe(länge, breite) fläche = länge * breite umfang = 2*(länge + breite) ausgabe(umfang, fläche)

ACHTUNG: Aus Gründen der Platzersparnis wird der Programmkopf ( Namen des Algorithmus + Variablen) oft weggelassen.

Flussdiagramm für eine Einseitige Verzweigung

f zneu <= zalt w zneu = zneu + 1000

Struktogramm für eine Einseitige Verzweigung

Bei einer zweiseitigen Verzweigung würde hier mindestens eine Anweisung stehen! zneu <= zalt w zneu = zneu + 1000 f

Beispiel:

// Eingabeteil siehe früher. . . Block (Verbundanweisung): fasst mehrere Anweisungen zusammen Dem EVA-Prinzip: Ausgabe und Verarbeitung nicht gemeinsam in einer Anweisung! if (zneu <= zalt){ zneu = zneu+1000; printf("Zählerüberlauf"); } d = zneu–zalt; bv 100 = b/d*100; printf("n L/100 km %f", erg); Übrigens: Welchem Prinzip widerspricht dieses Programm ?

Bitte Struktogramm zum vorigen C-Programm machen (einschließlich Kopf des Struktogramms und Eingaben)

Name: Benzinverbrauch zalt: double zneu: double bv 100: double d: double Eingabe(zalt) Eingabe(zneu) Eingabe(bv)

Eingabe(zalt) Eingabe(zneu) Eingabe(bv) w zneu = zneu+1000 zneu <= zalt Ausgabe("Zählerüberlauf") d = zneu–zalt bv 100 = bv/d*100 Ausgabe(bv 100) f

Aufgabe: Erstellen Sie das Struktogramm zum früheren Flussdiagramm des Benzinverbrauchrechners mit Überlauf (mit korrekter EVA). (siehe Anfang der Datei)

Eingabe(zalt) Eingabe(zneu) Eingabe(bv) w zneu = zneu+1000 d = zneu–zalt bv 100 = bv/d*100 Ausgabe(bv 100) zneu <= zalt f

Aufgabe: Bestimmung des Maximums zweier ganzer Zahlen, also: Struktogramm + Flussdiagramm + C-Programm ! Achtung: Bis jetzt können wir nur die einseitige Verzweigung in C umsetzen !!!

Name: Maximum bestimmen a: int b: int max: int Rest kommt auf der nächsten Folie

Eingabe(a) Eingabe(b) w max = b a<b f w max = a a >= b f Ausgabe(max) Ist es möglich, dass das Programm alle zwei false-Teile durchläuft?

Eingabe(a) Eingabe(b) w max = b a<b f w max = a a >= b f Ausgabe(max) Nein, denn wenn eine Bedingung false ist, muss die andere Bedingung true sein!

Eingabe(a) Eingabe(b) a<b f w max = b a >= b w max = a Ausgabe(max) f

#include "stdafx. h" #include <stdio. h> int main(){ int a, b, max; Möglich: Trennen von Variablennamen mit Komma printf("n. Eingabe der ersten Zahl: "); scanf("%d", &a); fflush(stdin); printf("n. Eingabe der zweiten Zahl: "); scanf("%d", &b); Kommentar fflush(stdin); // Wie geht es weiter ?

if (a<b){ max = b; } Logisch gleichwertig: !(a<b) if (a>=b){ max = a; } printf("Max=%d", max);

return 0; }

Wir machen ein paar Tests, denn die Wahrheit ist konkret !

2 1 Für a werde 2 eingegeben if (a<b){ max = b; } 2 Für b werde 1 eingegeben 1 if (a>=b){ max = a; } 2 printf("Max=%d", max); 2

3 5 Für a werde 3 eingegeben if (a<b){ max = b; } 5 3 Für b werde 5 eingegeben 5 if (a>=b){ max = a; } printf("Max=%d", max); 5

7 7 Für a werde 7 eingegeben if (a<b){ max = b; } 7 Für b werde 7 eingegeben 7 if (a>=b){ max = a; } 7 printf("Max=%d", max); 7

Andere Lösung mit einseitiger Verzweigung:

Name: Maximum zweier Zahlen bestimmen a: int b: int max: int Rest kommt auf der nächsten Folie

Eingabe(a) Eingabe(b) w max = b a<b f w max = a a == b f w max = a a>b f Ausgabe(max)

Andere Lösung mit einseitiger Verzweigung:

Das vorläufige Maximum wird auf den Wert der Variablen a gesetzt. Ist das vorläufige Maximum kleiner als die 2. Zahl, dann ist das endgültige Maximum gleich der 2. Zahl Eingabe(a) Eingabe(b) max = a; w max = b Ausgabe(max) a<b f

oder als eine elegantere Alternative:

Aufgabe: Bestimmen des Maximums zweier ganzer Zahlen. Flussdiagramm mit zweiseitiger Verzweigung !

Anfang Eingabe(a) Eingabe(b) a<b f w max = b Ausgabe(max) Ende max = a

Und hier das zugehörige Struktogramm für diese zweiseitige Verzweigung

a<b w max = b f max = a

Und hier das gesamte Struktogram dazu:

Name: Maximum bestimmen a: int b: int max: int Rest kommt auf der nächsten Folie

Eingabe(a) Eingabe(b ) a<b w max = b Ausgabe(max) f max = a

C - Syntax für die zweiseitige Verzweigung

Bedingung Nächste Anweisung, wenn Bedingung wahr if (Ausdruck) Anweisung 1; else Anweisung 2; wahr bedeutet: Wert des Ausdrucks != 0 falsch bedeutet: Wert des Ausdrucks = 0 Nächste Anweisung, wenn Bedingung falsch

Wie kann man also ganz allgemein die folgende zweiseitige Verzweigung durch zwei einseitige Verzweigungen darstellen ?

A 1, A 2 und B sind alles Ausdrücke if (B){ A 1; } else{ A 2; } if(B){ A 1; } if(!B){ A 2; }

Aufgabe: Bestimmung des Maximums zweier ganzer Zahlen. C-Programm

Bedingung if (a<b){ max = b; } else{ max = a; } Nächste Anweisung, wenn Bedingung wahr bei einer Anweisung sind Klammern nicht nötig. Trotzdem: Immer Klammern machen. Nächste Anweisung, wenn Bedingung falsch printf("Maximum =%d", max);

return 0; }

Programmverlauf: Durchführung von ein paar Tests. . .

1 2 Zum Beispiel. . . 2 if (a<b){ max = b; } else{ max = a; } 2 printf("Maximum =%d", max);

Weiterer Test. . .

2 Zum Beispiel. . . 1 if (a<b){ max = b; } else{ max = a; } 2 2 printf("Maximum =%d", max);

Frage: Warum ist folgende Lösung falsch ?

if (a<b){ max = b; } printf("Maximum =%d", max); }

Programmverlauf: Durchführung von ein paar Tests. . .

Zum Beispiel. . . 2 1 2 if (a<b){ max = b; } 2 printf("Maximum = %d ", max); Damit noch nicht nachgewiesen, daß Algorithmus inkorrekt.

Weiterer Test. . .

2 Zum Beispiel. . . 1 if (a<b){ max = b; } ? printf("Maximum = %d ", max); Wert von max ist unbekannt und deshalb mit hoher Wahrscheinlichkeit nicht gleich dem Wert von a Damit ist nachgewiesen, daß der Algorithmus inkorrekt ist.

Aufgabe: Bestimmen des Maximums und Minimums zweier ganzer Zahlen. Struktogramm + C-Programm

Name: Maximum und Minimum von 2 Zahlen bestimmen a: int b: int max: int min: int Rest kommt auf der nächsten Folie

Eingabe(a, b) a<b w f max = b max = a min = b Ausgabe (max, min)

#include "stdafx. h" #include <stdio. h> int main(){ int a; int b; int min; int max; // Eingabeteil wie immer // Dann weiter mit. . .

if (a<b){ max = b; min = a; } else{ max = a; min = b; } Blockbeginn Anweisungen in einem Block zusammenfassen Blockende kein Semikolon

printf("Max=%d, Min=%d", max, min); return 0; }

Block: Fasst mehrere Anweisungen zusammen.

Vorschlag: In "nicht einfachen" Anweisungen (wie z. B. if. . . else, bzw. if) immer Block benutzen.

WICHTIG: Nach einem Block kommt kein Semikolon.

Aufgabe: Stellen Sie den Algorithmus durch ein Struktogramm dar, der das Maximum dreier in beliebiger Reihenfolge eingegebener Zahlen berechnet.

Name: Maximum von 3 Zahlen bestimmen z 1: int z 2: int z 3: int max: int Rest kommt auf der nächsten Folie

Eingabe(z 1, z 2, z 3) z 1<z 2 W max = z 2 max = z 1 max<z 3 W F max = z 3 Ausgabe(max) F

Erstellen Sie das zu diesem Struktogramm zugehörige C-Programm

#include "stdafx. h" #include <stdio. h> int main(){ int z 1; int z 2; int z 3; int max; // Eingabeteil wie immer // Dann weiter mit. . .

if(z 1<z 2){ max=z 2; } else{ max=z 1; } if(max<z 3){ max=z 3; } printf("Max=%dn", max); return 0; }

Aufgabe: Stellen Sie den Algorithmus durch ein Struktogramm dar, der das Maximum und Minimum dreier in beliebiger Reihenfolge eingegebener Zahlen berechnet.

Name: Maximum und Minimum von 3 Zahlen bestimmen z 1: int z 2: int z 3: int max: int min: int Rest kommt auf der nächsten Folie

Eingabe(z 1, z 2, z 3) z 1<z 2 W max = z 2 min = z 1 W F max = z 1 min = z 2 max<z 3 F min>z 3 F max = z 3 W min= z 3 Ausgabe(max, min)

Erstellen Sie das zu diesem Struktogramm zugehörige C-Programm

#include "stdafx. h" #include <stdio. h> int main(){ int z 1; int z 2; int z 3; int max; int min; // Eingabeteil wie immer // Dann weiter mit. . .

} if(z 1<z 2){ max=z 2; min=z 1; } else{ max=z 1; min=z 2; } if(max<z 3){ max=z 3; } if(min>z 3){ min=z 3; } printf("Max=%d Min=%dn", max, min); return 0;

Aufgabe: Erzeugen Sie einen Algorithmus (und stellen Sie diesen durch ein Struktogramm dar), der drei in beliebiger Reihenfolge eingegebene Zahlen ihrer Größe nach sortiert und ausgibt (kleinste, mittlere, grösste).

TESTEN Sie Ihre Lösung (Struktogramm). Machen Sie dazu folgende Überlegungen:

Die 3 Zahlen werden mit a, b und c bezeichnet.

Annahme: Unter diesen 3 Zahlen a, b, c, sind alle verschieden voneinander. Wie viele verschiedene Möglichkeiten (bzgl. der Reihenfolge der Eingabe) gibt es diese 3 Zahlen einzugeben? Bitte notieren Sie diese Möglichkeiten.

3 verschiedene Zahlen: a b c a c b b a c b c a b c b a

Annahme: Unter 3 Zahlen gibt es genau 2 verschiedene, genannt a und b. Wie viele verschiedene Möglichkeiten (bzgl. der Reihenfolge der Eingabe) gibt es diese 3 Zahlen einzugeben? Bitte notieren Sie diese Möglichkeiten.

Genau 2 gleiche Zahlen: a a b b a a b b b a b

Annahme: Unter 3 Zahlen gibt es genau 3 gleiche, genannt a, a, und a. Wie viele verschiedene Möglichkeiten (bzgl. der Reihenfolge der Eingabe) gibt es diese 3 Zahlen einzugeben? Bitte notieren Sie diese Möglichkeiten.

Genau 3 gleiche Zahlen: a a a

Zusammengefasst: a a b b c c b c a b a b a a b b b a a a

Eine mögliche Lösung der vorigen Aufgabe:

Bemerkung: Die Lösung wird in der folgenden Folie durch ein Flußdiagramm dargestellt. Wandeln Sie dieses Flussdiagramm in ein Struktogramm um. Weitere Info siehe nächste Folie.

Anfang Eingabe(z 1, z 2, z 3) weiter nächste Folie 1. über Tastatur eingegebene Zahl wird in z 1 gespeichert. 2. über Tastatur eingegebene Zahl wird in z 2 gespeichert. 3. über Tastatur eingegebene Zahl wird in z 3 gespeichert.

k: kleinste Zahl m: mittlere Zahl g: größte Zahl f z 1 < z 2 w z 3 < z 1 w k: =z 3 m: =z 1 g: =z 2 z 3 < z 2 f w z 3 < z 2 k: =z 3 m: =z 2 g: =z 1 f w k: =z 1 m: =z 3 g: =z 2 Ausgabe(k, m, g) k: =z 1 m: =z 2 g: =z 3 f z 3 < z 1 w k: =z 2 m: =z 3 g: =z 1 f k: =z 2 m: =z 1 g: =z 3

Name: aufsteigende Sortierung dreier Zahlen z 1: int z 2: int z 3: int k: int m: int g: int Rest kommt auf der nächsten Folie

Eingabe(z 1, z 2, z 3) z 1<z 2 W W z 3<z 1 z 3<z 2 F W W F k=z 3 k=z 1 m=z 3 m=z 2 g=z 3 Ausgabe(k, m, g) F z 3<z 2 F z 3<z 1 W k=z 3 k=z 2 m=z 3 g=z 1 F k=z 2 m=z 1 g=z 3

Wieviel if. . . else Anweisungen Eingabe(z 1, z 2, z 3)kommen in diesem Programm vor? z 1<z 2 W W z 3<z 1 z 3<z 2 F W W F k=z 3 k=z 1 m=z 3 m=z 2 g=z 3 F z 3<z 2 F z 3<z 1 W k=z 3 k=z 2 m=z 3 g=z 1 F k=z 2 m=z 1 g=z 3 Genau eine (die rot umrandete)! Ausgabe(k, m, g) Diese ist allerdings verschachtelt !!!

TESTEN Sie mit den gerade angegebenen Zahlenkombinationen dieses Struktogramm.

Erstellen Sie das zu diesem Struktogramm zugehörige C-Programm

#include "stdafx. h" #include "stdio. h" int main(){ int z 1, z 2, z 3, m, k, g; // Eingabe printf("Eingabe der scanf("%d", &z 1); fflush(stdin); printf("Eingabe der scanf("%d", &z 2); fflush(stdin); printf("Eingabe der scanf("%d", &z 3); fflush(stdin); // gleich kommt die 1. Zahl: n"); 2. Zahl: n"); 3. Zahl: n"); Ausgabe

if (z 1<z 2){ if(z 3<z 1){ k=z 3; m=z 1; g=z 2; } else{ if(z 3<z 2){ k=z 1; m=z 3; g=z 2; } else{ k=z 1; m=z 2; g=z 3; } } } else{ if(z 3<z 2){ k=z 3; m=z 2; g=z 1; } else{ if(z 3<z 1){ k=z 2; m=z 3; g=z 1; } else{ k=z 2; m=z 1; g=z 3; } } } z 1<z 2 F W z 3<z 2 z 3<z 1 F W z 3<z 2 W k=z 3 k=z 1 m=z 3 g=z 2 z 3<z 1 F W k=z 1 k=z 3 k=z 2 m=z 3 g=z 1 F k=z 2 m=z 1 g=z 3

// Ausgabe printf("sortierte Reihenfolge %d %d %d: n", k, m, g); return 0; }

Erstellen Sie dazu ein Testprotokoll mit den Werten: z 1: 1 z 2: 2 z 3: 3

TESTPROTOKOLL Name des Algorithmus: Sortieren von 3 Zahlen Datum: 25. 5. 2014 Name des Entwicklers: Erich Überflieger Name des Testers: Ernst Bockelhart TESTDATEN z 1, z 2, z 3. . . weiter nächste Folie. . .

z 1 z 2 z 3 k m g 1 1 2 2 3 3 1 1 2 2 2 1 1 2 3 1 2 1 2 1 3 2 3 1 2 1 1 1 2 2 1 1 1 1 2 2 2 1 1 1 2 2 2 1 3 3 3 2 2 2 1 Alg. korr. ? ja ja ja ja

Nochmals zum EVA-Prinzip

Das EVA-Prinzip bedeutet: In einer Anweisung dürfen nicht zwei verschiedene Komponenten von EVA stehen (wie z. B. V und A)

Schlechter Programmierstil: 2 Komponenten in 1 Anweisung E Eingabe(zaehler , nenner) nenner != 0 W F erg = zaehler / nenner Ausgabe(erg) Ausgabe("unerlaubte Division durch 0") V + A

Guter Programmierstil:

Name: Division zweier Zahlen zaehler: int nenner: int erlaubt: int erg: int Rest kommt auf der nächsten Folie

E Eingabe(zaehler , nenner) nenner != 0 W F erg = zaehler / nenner V erlaubt = 0 erlaubt = 1 erlaubt == 1 W F A Ausgabe(erg) Ausgabe("Division durch 0") Die Variable "erlaubt" nennt man Steuervariable. Selbstsprechende Namen wären z. B. auch "status", "zustand", "fehler", usw.

E Eingabe(zaehler , nenner) nenner != 0 W F erg = zaehler / nenner V erlaubt = 0 erlaubt = 1 erlaubt == 1 W F Ausgabe(erg) Ausgabe("Division durch 0") Im V-Teil wird sie … A

E Eingabe(zaehler , nenner) nenner != 0 W F erg = zaehler / nenner V erlaubt = 0 erlaubt = 1 erlaubt == 1 W F Ausgabe(erg) Ausgabe("Division durch 0") nur gesetzt und im A-Teil wird sie nur … A

E Eingabe(zaehler , nenner) nenner != 0 W F erg = zaehler / nenner V erlaubt = 0 erlaubt = 1 erlaubt == 1 W F A Ausgabe(erg) Ausgabe("Division durch 0") abgefragt (ausgelesen), um die entsprechende Ausgabe zu machen.

Wieviel if. . . else Anweisungen kommen in diesem Programm vor? Eingabe(zaehler , nenner) E nenner != 0 W F erg = zaehler / nenner V erlaubt = 0 erlaubt = 1 erlaubt == 1 W F Ausgabe(erg) Ausgabe("Division durch 0") Genau 2! A

Aufgabe: Die Variablen n und t sollen den Datentyp integer haben. Mit welcher Anweisung kann man nachprüfen, ob t ein Teiler von n ist, wie z. B. 3 ein Teiler von 18 ist.

. . . if(n % t == 0){ // t teilt n } else{ // t teilt n nicht } Mit dem Operator % wird der Rest berechnet. Wenn t Teiler von n ist, ist. . . der Rest gleich 0. Gibt es eine andere Lösung, die Operatoren / und * benutzt?

. . . if(n/t * t == n){ // t teilt n } else{ // t teilt n nicht }. . . Wenn n von t nicht geteilt wird, wird der Rest bei der Division abgeschnitten und somit das Produkt n/t * t ungleich n

Geben Sie dazu ein paar Beispiele. . .

. . . 21 7 7 21 if(n/t * t == n){ // t teilt n 3 } * 7 = 21 else{ //. . . }. . . Also ist die nächste Anweisung im if-Teil der if. . . else Anweisung.

. . . 20 7 7 20 if(n/t * t == n){ //. . . } 2 * 7 ≠ 20 else{ // t teilt n nicht }. . . Also ist die nächste Anweisung im else-Teil der if. . . else Anweisung.

Eine weitere Lösung ist:

. . . if((double)n/(double)t == n/t){ // t teilt n } else{ // t teilt n nicht } n und t umwandeln in double. Dann kann es. . . bei Division einen Rest geben!

Aufgabe: Schreiben Sie ein CProgramm, in dem über Tastatur 3 Zeichen eingegeben werden. Das Programm soll berechnen, wie oft das Zeichen x in den 3 Zeichen vorkommt.

#include "stdafx. h" #include "stdio. h" int main(){ char zeichen 1, zeichen 2, zeichen 3; int anzahl; // Eingabe printf("Eingabe des 1. Zeichens: n"); scanf("%c", &zeichen 1); fflush(stdin); printf("Eingabe der 2. Zeichens: n"); scanf("%c", &zeichen 2); fflush(stdin); printf("Eingabe der 3. Zeichens: n"); scanf("%c", &zeichen 3); fflush(stdin); // gleich kommt die Ausgabe

// Verarbeitung anzahl = 0; if(zeichen 1=='x'){ anzahl=anzahl+1; } if(zeichen 2=='x'){ anzahl=anzahl+1; } if(zeichen 3=='x'){ anzahl=anzahl+1; } // Ausgabe printf("Anzahl=%dn", anzahl); return 0; }

Aufgabe: Schreiben Sie ein CProgramm, in dem über Tastatur 3 Zeichen eingegeben werden. Das Programm soll berechnen, ob in dieser Zeichenkette, die Zeichenkette "xy" vorkommt.

#include "stdafx. h" #include <stdio. h> int main(){ char zeichen 1, zeichen 2, zeichen 3; int anzahl. Vorkommen; // Eingabe printf("Eingabe des 1. Zeichens: n"); scanf("%c", &zeichen 1); fflush(stdin); printf("Eingabe der 2. Zeichens: n"); scanf("%c", &zeichen 2); fflush(stdin); printf("Eingabe der 3. Zeichens: n"); scanf("%c", &zeichen 3); fflush(stdin); // gleich kommt die Ausgabe

// Verarbeitung anzahl. Vorkommen = 0; if(zeichen 1=='x' && zeichen 2=='y' || zeichen 2=='x' && zeichen 3=='y'){ anzahl. Vorkommen =1; } // Ausgabe if(anzahl. Vorkommen ==0) printf("xy kommt nicht vor); else printf("xy kommt vor); return 0; }