≪ 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 17:06] – 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 ===== +
-  * Eliminiert diese Eigenheiten +
-  * Formulierung ist **ähnlich** einem Programm +
-  * Aber **ohne konkrete Syntax** einer bestimmten Programmiersprache +
-===== Aussehen ===== +
-Pseudocode kann +
-**Der **Syntax höherer Programmiersprachen** ähneln** +
-<code > +
-if, then, else +
-</code> +
-**Gemixt werden mit natürlicher Sprache** +
-<code > +
-wenn, dann, sonst +
-</code> +
-**Gemixt werden mit mathematischer Notation** +
-<code > +
-<, !=, > +
-</code>+
  
-===== Variablen ===== +Es gibt, neben anderen, vor allem folgende 3 Notationen:
-Wie im echten Programm, müssen auch im Pseudocode alle Variablen, die später verwendet werden, vorher **deklariert** und **initialisiert** werden.+
  
-Der Unterschied zum echten Code ist, dass dies im Pseudocode **sehr viel freier** geschehen kann. Bsp. kann auf eine **Typisierung der Variablen** verzichtet werden.+|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 |
  
-==== Deklaration ==== 
-<code > 
-name;  
-a; 
-isBoolean; 
-</code> 
  
 +---
 +### Pseudocode Eigenschaften
  
-==== Initialisierung ==== +- Eliminiert diese Eigenheiten 
-<code > +- Formulierung ist **ähnlich** einem Programm 
-name = "Bugs Bunny";  +- Aber **ohne konkrete Syntax** einer bestimmten Programmiersprache
-a = 2024; +
-isBoolean = true; +
-Eingabe a; +
-</code>+
  
  
-===== Kontrollstrukturen ===== 
-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. 
  
-==== IF-ELSE ====+Laut [](https://oer-informatik.de/pseudocode) ist wichtig bei der 
 +Erstellung von Pseudocode:
  
-Denkbar sind stark an eine höhere Programmiersprache angelegte Konstrukte wie +**Verständlichkeit** des Pseudocodes ist wichtiger als starre 
-<code > +Konventionen! 
-Eingabe a + 
-if (a > 45) { +**Unnötige Details vermeiden**: das Offensichtliche kann als bekannt 
-  Ausgabe: a+vorausgesetzt werden! 
 + 
 +**Im Kontext bleiben**: Wer ist Adressat und in welcher Problemdomäne 
 +befinde ich mich? Wem beantworte ich mit dem Pseudocode welche Frage? 
 + 
 + 
 +--- 
 +### Blockdefinition 
 + 
 + 
 +**JANA**: geschweifte Klammern 
 + 
 +``` 
 +{ 
 +  Anweisung
 } }
-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 
-==== Loops ==== +``` 
-<code > + 
-for(i=5, i< 10, i++){ + 
-  Ausgabe: i+--- 
 + 
 +### Mehrfachauswahl (switch / case) 
 + 
 +**JANA** 
 + 
 +``` 
 +switch (variable) { 
 +  case 1: { 
 +    Anweisung 
 +  } 
 +  case >=2: { 
 +    Anweisung 
 +  } 
 +  default: { 
 +    Anweisung 
 +  }
 } }
-</code>+```
  
-<code > +**Pseudo-Pascal** 
-for (startwert 5, endwert 10, schrittweite 1){ + 
-  Ausgabe Zählvariable+``` 
 +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 
 +``` 
 +