≪ View Page

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
programmierung:pseudocode [2024/07/08 19:34] – sweprogrammierung:pseudocode [2025/12/20 14:53] (current) – external edit 127.0.0.1
Line 1: Line 1:
-~~REVEAL~~ +# Pseudocode
-====== Pseudocode ====== +
  
 Programmcode, der nicht zur maschinellen Interpretation dient. Programmcode, der nicht zur maschinellen Interpretation dient.
  
-Dieser Code dient vielmehr der **Veranschaulichung** eines Algoritmus. Er hilft, einen Algorithmus zu verstehen.+Dieser Code dient vielmehr der **Veranschaulichung** eines Algoritmus.
  
-===== Problem ===== +Er hilft, einen Algorithmus zu verstehen, ohne die Zielgruppe auf eine spezielle Programmiersprache festzulegen.
-  * Interpretation von Programmcode wird erschwert durch +
-    * Eigenheiten der unterschiedlichen Programmiersprachen +
-    * Unterschiedliche Syntax +
-===== Pseudocode Eigenschaften ===== +
-  * Eliminiert diese Eigenheiten +
-  * Formulierung ist **ähnlich** einem Programm +
-  * Aber **ohne konkrete Syntax** einer bestimmten Programmiersprache+
  
-===== Wichtig bei der Erstellung von Pseudocode ist: =====+Es gibt, neben anderen, vor allem folgende 3 Notationen:
  
 +|Notation |Beschreibung |
 +|----------|--------------|
 +|JANA - Java based abstract notation for algorithms |An Java angelehnt |
 +|Pseudo-Pascal |An Pascal angeleht. Sehr "sprechend" |
 +|Deutsches Pseudo-Pascal |wie Pseudo-Pascal, nur mit deutschen Worten |
  
-**Verständlichkeit** des Pseudocodes ist wichtiger als starre Konventionen! 
  
-**Unnötige Details vermeiden**: das Offensichtliche kann als bekannt vorausgesetzt werden!+--- 
 +### Pseudocode Eigenschaften
  
-**Im Kontext bleiben**: Wer ist Adressat und in welcher Problemdomäne befinde ich mich? Wem beantworte ich mit dem Pseudocode welche Frage?+- Eliminiert diese Eigenheiten 
 +- Formulierung ist **ähnlich** einem Programm 
 +- Aber **ohne konkrete Syntax** einer bestimmten Programmiersprache
  
  
-===== Aussehen ===== 
-Pseudocode kann... 
  
-* Der **Syntax höherer Programmiersprachen** ähneln +Laut [](https://oer-informatik.de/pseudocode) ist wichtig bei der 
-<code > +Erstellung von Pseudocode:
-if, then, else, for, in,  +
-</code> +
-* Gemixt werden mit natürlicher Sprache +
-<code > +
-wenn, dann, sonst, ist, größer, kleiner, wahr ... +
-</code> +
-* Gemixt werden mit mathematischer Notation +
-<code > +
-<, !=, > +
-</code>+
  
-===== Variablen ===== +**Verständlichkeit** des Pseudocodes ist wichtiger als starre 
-Wie im echten Programm, müssen auch im Pseudocode alle Variablen, die später verwendet werden, vorher **deklariert** und **initialisiert** werden.+Konventionen!
  
-Der Unterschied zum echten Code ist, dass dies im Pseudocode **sehr viel freier** geschehen kann. Bsp. kann auf eine **Typisierung der Variablen** verzichtet werden.+**Unnötige Details vermeiden**: das Offensichtliche kann als bekannt 
 +vorausgesetzt werden!
  
-==== Deklaration ==== +**Im Kontext bleiben**: Wer ist Adressat und in welcher Problemdomäne 
-<code > +befinde ich mich? Wem beantworte ich mit dem Pseudocode welche Frage?
-name;  +
-a; +
-isBoolean; +
-</code>+
  
  
-==== Initialisierung bzw. Deklaration + Initialisierung ==== +--- 
-<code > +### Blockdefinition
-name = "Bugs Bunny";  +
-a = 2024; +
-isBoolean = true; +
-Eingabe a; +
-</code>+
  
  
-===== Kontrollstrukturen ===== +**JANA**: geschweifte Klammern
-Kontrollstrukturen können ebenfalls wunderbar in Pseudocode beschrieben werden. Dabei geht es ausschließlich darum, zu sehen, **welche** Kontrollstruktur verwendet wurde und wo sich **Anfang und Ende** der jeweiligen Struktur befindet.+
  
-==== Bedingungen ==== +``` 
- +{ 
-Denkbar sind stark an eine höhere Programmiersprache angelegte Konstrukte wie +  Anweisung
-<code > +
-Eingabe a +
-if (a > 45) { +
-   Ausgabe: a+
 } }
-else { +``` 
-   Ausgabe: Kein Treffer+ 
 +**Pseudo-Pascal**: Schlüsselwort `end` 
 + 
 +``` 
 +for (...)  
 +  Anweisung 
 +end for 
 +``` 
 + 
 +**Deutsches Pseudo-Pascal** 
 + 
 +``` 
 +WENN (...)  
 +  Anweisung 
 +ENDE WENN 
 +``` 
 + 
 +--- 
 +### Standard-Datentypen (mit Beispielen) 
 + 
 + 
 +| **JANA**  | **Pseudo-Pascal** | **deutsches Pseudo-Pascal** | 
 +| --------- | ----------------- | --------------------------- | 
 +| int     | integer         | GANZZAHL                  | 
 +| float   | real            | GLEITKOMMAZAHL            | 
 +| char    | char            | ZEICHEN                   | 
 +| boolean | boolean         | WAHRHEITSWERT             | 
 +| String  | String          | ZEICHENKETTE              | 
 +| Object  | Object          | OBJEKT                    | 
 + 
 +--- 
 + 
 +### Beispielhafte Deklarationen 
 + 
 +**JANA** 
 + 
 +``` 
 +int i 
 +int i := 0 
 +Object o 
 +``` 
 + 
 +**Pseudo-Pascal** 
 + 
 +``` 
 +i: int 
 +i: int := 0 
 +o: Object 
 +``` 
 + 
 +**Deutsches Pseudo-Pascal** 
 + 
 +``` 
 +i: GANZZAHL 
 +i: GANZZAHL := 0 
 +o: OBJEKT 
 +``` 
 + 
 +--- 
 + 
 +### Operatoren 
 + 
 +Wichtig: Zuweisungsoperator 
 +``` 
 +:=              // Zuweisung (besser als = im Pseudocode) 
 +``` 
 +``` 
 ++,-,/,*         // Mathematische Operatoren 
 +&               // Sollte kommentiert werden (Bit- oder Textoperation) 
 +<, >, ==, !=    // Vergleichsoperatoren 
 +:               // Typdeklaration (nicht Division!) 
 +AND, OR, NOT    // Logische Operatoren (ggf. deutsch verwenden) 
 +``` 
 + 
 +--- 
 + 
 +### Selektion / bedingte Anweisung (if / else if / else) 
 + 
 +**JANA** 
 + 
 +``` 
 +if (...) { 
 +  Anweisung 
 +} else if (...) { 
 +  Anweisung 
 +} else { 
 +  Anweisung
 } }
-</code>+```
  
-Konstrukte, die natürliche Sprache verwenden +**Pseudo-Pascal** 
-<code > + 
-EINGABE a +``` 
-WENN a kleiner 45 DANN +if (...) then 
-  Ausgabe a+  Anweisung 
 +else if (...) 
 +  Anweisung 
 +else 
 +  Anweisung 
 +end if 
 +``` 
 + 
 +**Deutsches Pseudo-Pascal** 
 + 
 +``` 
 +WENN (...) DANN 
 +  Anweisung 
 +SONST WENN (...) DANN 
 +  Anweisung
 SONST SONST
-  Ausgabe: Kein Treffer   +  Anweisung 
-</code>+ENDE WENN 
 +```
  
-Wichtig: Da es bei diesem Format keine öffnende und schließende geschweifte Klammern gibt, muss durch korrekte **Einrückung** dafür gesorgt werden, dass Anfang und Ende des Blocks klar werden! 
  
 +---
  
-==== Loops ====+### Mehrfachauswahl (switch / case)
  
-''for ... to ... step'' \\ ''wiederhole ... solange/bis ... wiederhole_ende'' \\ ''repeat ... until'' +**JANA** 
-<code > + 
-for(i=5, i< 10, i++){ +``` 
-  Ausgabe: i+switch (variable) { 
 +  case 1: { 
 +    Anweisung 
 +  } 
 +  case >=2: { 
 +    Anweisung 
 +  } 
 +  default: { 
 +    Anweisung 
 +  }
 } }
-</code>+```
  
-<code > +**Pseudo-Pascal** 
-for (startwert i= 5, endwert i=10, schrittweite 1){ + 
-  Ausgabe i+``` 
 +case variable of 
 +  1: Anweisung 
 +  >=2: Anweisung 
 +  else Anweisung 
 +end case 
 +``` 
 + 
 +**Deutsches Pseudo-Pascal** 
 + 
 +``` 
 +WERT VON variable ENTSPRICHT 
 +  1: Anweisung 
 +  >=2: Anweisung 
 +  SONST Anweisung 
 +ENDE WERT VON 
 +``` 
 + 
 +--- 
 + 
 +### Kopfgesteuerte Schleife (while) 
 + 
 +**JANA** 
 + 
 +``` 
 +while (...) { 
 +  Anweisung
 } }
-</code> +``` 
-<code > + 
-INPUT listOfNumbers  +**Pseudo-Pascal** 
-FOR each number in listOfNumbers + 
-PRINT number +``` 
-END FOR +while (...) do 
-</code>+  Anweisung 
 +end while 
 +``` 
 + 
 +**Deutsches Pseudo-Pascal** 
 + 
 +``` 
 +SOLANGE (...) 
 +  Anweisung 
 +ENDE SOLANGE 
 +``` 
 + 
 +--- 
 + 
 +### Fußgesteuerte Schleife (do-while / repeat-until) 
 + 
 +**JANA** 
 + 
 +``` 
 +do { 
 +  Anweisung 
 +} while (...) 
 +``` 
 + 
 +**Pseudo-Pascal** 
 + 
 +``` 
 +repeat 
 +  Anweisung 
 +until (...) 
 +``` 
 + 
 +**Deutsches Pseudo-Pascal** 
 + 
 +``` 
 +WIEDERHOLE 
 +  Anweisung 
 +SOLANGE (...) 
 +``` 
 + 
 +--- 
 + 
 +### Zählergesteuerte Schleife (for) 
 + 
 +**JANA** 
 + 
 +``` 
 +for (...) { 
 +  Anweisung 
 +} 
 +``` 
 + 
 +**Pseudo-Pascal** 
 + 
 +``` 
 +for (...)  
 +  Anweisung 
 +end for 
 +``` 
 + 
 +**Deutsches Pseudo-Pascal** 
 + 
 +``` 
 +ZÄHLE i VON 0 BIS 7 mit Schrittweite 2 
 +  Anweisung 
 +ENDE ZÄHLE 
 +``` 
 +Die zur iterierende Menge kann relativ frei eingegeben werden, solange sie eindeutig definiert wird. Denkbar ist z.B.: 
 +``` 
 +for (int i = 1..10) 
 + 
 +for (int i; i<=10; i++) 
 + 
 +for (int i = 1, 2, 3, .., 10) 
 +``` 
 +--- 
 + 
 +### Iteration über Listen (foreach) 
 + 
 +**JANA** 
 + 
 +``` 
 +foreach (String txt in txtList) { 
 +  Anweisung 
 +} 
 +``` 
 + 
 +**Pseudo-Pascal** 
 + 
 +``` 
 +foreach element in list 
 +  Anweisung 
 +next element 
 +``` 
 + 
 +**Deutsches Pseudo-Pascal** 
 + 
 +``` 
 +FÜR JEDES element VON liste 
 +  Anweisung 
 +NÄCHSTES element 
 +``` 
 + 
 +--- 
 + 
 +### Methodendeklaration (Funktion / Methode) 
 + 
 +**JANA** 
 + 
 +``` 
 +String halloWelt(String text) { 
 +  return "Hallo " & text 
 +} 
 +``` 
 + 
 +**Pseudo-Pascal** 
 + 
 +``` 
 +FUNCTION halloWelt(text: String) : String 
 +  Anweisung 
 +END halloWelt() 
 +``` 
 + 
 +**Deutsches Pseudo-Pascal** 
 + 
 +``` 
 +FUNKTION halloWelt(text: String) : String 
 +  RÜCKGABE "Hallo " & text 
 +ENDE halloWelt() 
 +``` 
 + 
 +--- 
 + 
 +### Arrays und Collections 
 + 
 +**JANA** 
 + 
 +``` 
 +int zahlenfeld[] 
 +int zahlenfeld[1..100] 
 +zahlenfeld[n, m] 
 +zahlen2D[].length 
 +``` 
 + 
 +**Pseudo-Pascal** 
 + 
 +``` 
 +zahlenFeld = array [] of integer 
 +zahlenFeld = array [1..100] of integer 
 +zahlenFeld = array [1..n, 1..m] of integer 
 +zahlen2D[].length 
 +``` 
 + 
 +**Deutsches Pseudo-Pascal** 
 + 
 +``` 
 +zahlenFeld = eindimensionales Ganzzahlen-Array 
 +zahlenFeld = eindimensionales Ganzzahlen-Array mit 100 Elementen 
 +zahlenFeld = zweidimensionales Ganzzahlen-Array 
 +zahlen2D[].LÄNGE 
 +``` 
 +