Add exercises 4.

04/asciiTabelle.c

@@ -0,0 +1,30 @@
+/********************************************************************************************
+ * Ascii-Tabelle
+ * 
+ * Schreiben Sie ein Programm, das zwei Zeichen abfragt und dann alle Zeichen der Ascii-
+ * Tabelle ausgibt, die zwischen diesen zwei Zeichen liegen. Falls das Ende der Ascii-Tabelle 
+ * erreicht wird, soll die Ausgabe wieder am Anfang beginnen! Geben Sie nur sichtbare Zeichen
+ * aus, keine Kontrollzeichen (Hinweis: Sie können die Funktion iscntrl() aus ctype.h dafür 
+ * verwenden).
+ * 
+ * 1. Beispiel:
+ * >> Geben Sie ein einzelnes Zeichen ein: C
+ * >> Geben Sie noch ein einzelnes Zeichen ein: c
+ * Die folgenden Zeichen befinden sich in der Ascii-Tabelle zwischen 'c' und 'C':
+ * DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab
+ * 
+ * 2. Beispiel:
+ * >> Geben Sie ein einzelnes Zeichen ein: c
+ * >> Geben Sie noch ein einzelnes Zeichen ein: C
+ * Die folgenden Zeichen befinden sich in der Ascii-Tabelle zwischen 'c' und 'C':
+ * defghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@AB
+ *********************************************************************************************/
+
+#include <stdio.h>
+#include <ctype.h>
+
+int main()
+{
+
+    return 0;
+}

04/binaerUmrechnungSchleife.c

@@ -0,0 +1,36 @@
+/***********************************************************************************
+ * Aufgabe                                                                         *
+ * Schreiben Sie ein Programm, das eine ganze Zahl einliest und die Rechenschritte *
+ * anzeigt, um die Bits der entsprechenden Binaerzahl zu ermitteln. Nutzen Sie     *
+ * eine geeignete Schleife, sodass das Programm alle Stellen der Binärzahl anzeigt.*
+ * Lesen Sie zudem solange ein, bis eine positive Zahl eingegeben wird.            *
+ *                                                                                 *
+ * Beispiel:                                                                       *
+ * >> Geben Sie eine ganze, positive Zahl ein: abc                                 *
+ * >> Geben Sie eine ganze, positive Zahl ein: -5                                  *
+ * >> Geben Sie eine ganze, positive Zahl ein: 21                                  *
+ *  21 / 2 =   10, Rest:    1                                                      *
+ *  10 / 2 =    5, Rest:    0                                                      *
+ *   5 / 2 =    2, Rest:    1                                                      *
+ *   2 / 2 =    1, Rest:    0                                                      *
+ *                                                                                 *
+ * Schreiben Sie danach das Programm so um, dass es Bit- und Shiftoperatoren       *
+ * verwendet sowie negative Zahlen verarbeiten kann. Die Rechenschritte werden     *
+ * nicht mehr anzeigt, sondern nur noch das Bitmuster aller gespeicherten Bits.    *
+ *                                                                                 *
+ * Beispiele:                                                                      *
+ * >> Geben Sie eine ganze Zahl ein: abc                                           *
+ * >> Geben Sie eine ganze Zahl ein: 21                                            *
+ * 00000000000000000000000000010101                                                *
+ *                                                                                 *
+ * >> Geben Sie eine ganze Zahl ein: -9                                            *
+ * 11111111111111111111111111110111                                                *
+ ***********************************************************************************/
+
+#include <stdio.h>
+
+int main()
+{
+
+    return 0;
+}

04/eingabePruefung.c

@@ -0,0 +1,27 @@
+/********************************************************************************************
+ * Eingabeprüfung
+ * 
+ * Schreiben Sie ein Programm, das einen Preis in Euro als Kommazahl vom Benutzer abfragt 
+ * und diesen dann mittels explizitem casting in Euros und Cents zerlegt und ausgibt.
+ * Falls eine ungültige Eingabe gemacht wird (z.B. eine negative Zahl oder Buchstaben), 
+ * geben Sie eine entsprechende Meldung aus und wiederholen sie die Eingabeabfrage solange,
+ * bis eine gültige Eingabe erfolgt ist.
+ * 
+ * 1. Beispiel:
+ * >> Geben Sie einen Preis in Euro ein: 12.53
+ * Der Preis ist 12 Euro und 53 Cents.
+ * 
+ * 2. Beispiel:
+ * >> Geben Sie einen Preis in Euro ein: abc
+ * Eingabe ungueltig. Geben Sie eine positive Zahl ein!
+ * >> Geben Sie einen Preis in Euro ein: 32.12
+ * Der Preis ist 32 Euro und 12 Cents.
+ *********************************************************************************************/
+
+#include <stdio.h>
+
+int main()
+{
+
+    return 0;
+}

04/heron.c

@@ -0,0 +1,29 @@
+/****************************************************************************************************************************************************
+ * Schreiben Sie ein Programm, das eine Gleitkommazahl vom Benutzer einliest und dessen Quadratwurzel approximiert, ohne math.h zu verwenden.       *
+ * Lesen Sie dafür zunächst solange Eingaben ein, bis eine Zahl eingegeben wird, die mindestens 0 ist. Andere Eingaben werden verworfen.            *
+ * Implementieren Sie danach den Algorithmus nach Heron. Dafür gehen wir davon aus, dass die eingegebene Zahl der Flächeninhalt eines Quadrats ist, *
+ * die Seitenlänge aber unbekannt ist. Wir versuchen nun ein Rechteck mit dem angegebenen Flächeninhalt zu konstruieren und stückweise beide        *
+ * Seitenlängen aneinander anzugleichen, bis ein Quadrat mit dem gewünschten Flächeninhalt entsteht.                                                *
+ * Wir initialisieren die beiden unbekannten Seitenlängen mit dem halben Flächeninhalt und dem Flächeninhalt geteilt durch die erste Seitenlänge.   *
+ * Wie erwartet erhalten wir kein Quadrat, sondern ein allgemeines Rechteck. Wir nähern nun die beiden Seitenlängen aneinander an, müssen aber      *
+ * dafür sorgen, dass der Flächeninhalt immer gleich bleibt. Dazu halbieren wir für die erste Seitenlänge die Summe beider Seitenlängen. Für        *
+ * die zweite Seitenlänge teilen wir wieder den Flächeninhalt durch die erste Seitenlänge, um                                                       *
+ * Seitenlänge 1 * Seitenlänge 2 = Flächeninhalt = eingegebener Zahl                                                                                *
+ * zu erhalten. Dies wiederholen wir, bis (Seitenlänge 1 - Seitenlänge 2)² <= 10^-9 ist. So konstruieren wir schrittweise ein Quadrat mit dem       *
+ * eingegebenen Flächeninhalt und approximieren gleichzeitig die Quadratwurzel der eingegebenen Zahl. Am Ende geben wir das Ergebnis aus.           *
+ *                                                                                                                                                  *
+ * Beispiel:                                                                                                                                        *
+ * >> Geben Sie eine Zahl ein: abc                                                                                                                  *
+ * >> Geben Sie eine Zahl ein: -5                                                                                                                   *
+ * >> Geben Sie eine Zahl ein: 5.5                                                                                                                  *
+ * 2.345208 * 2.345208 = 5.500000                                                                                                                   *
+ *                                                                                                                                                  *
+ ****************************************************************************************************************************************************/
+
+#include <stdio.h>
+
+int main()
+{
+
+    return 0;
+}