Übungen

| ### Programmieren in C von Prof. Dr. Rainer Thomas

# Übungen zum Programmieren in C

### 1. Aufgabe
2. Aufgabe
3. Aufgabe
4. Aufgabe
5. Aufgabe
6. Aufgabe
7. Aufgabe
8. Aufgabe
9. Aufgabe
10. Aufgabe

## 1. Aufgabe

Erstellen Sie ein ANSI-C-Programm, daß folgende Ein- und Ausgaben durch- führt (s. untenstehendes Beispiel eines Musterlaufs):

- Einlesen - jeweils nach Ausgabe einer entsprechenden Eingabeaufforderung -
  - eines Buchstabens (mittels `getchar()`)
  - einer Integerzahl
  - einer Gleitpunktzahl doppelter Genauigkeit

- Ausgabe der eingelesenen Werte in folgender Form :
  - Buchstabe : in Hochkommata eingeschlossener Buchstabe, gefolgt von einem Doppelpunkt, danach jeweils getrennt durch 3 Blanks der dezimale, sedezimale und oktale Wert des Zeichencodes.
    Dabei ist dem sedezimalen Wert ein $, dem oktalen ein @ voranzustellen.
  - Integerzahl : zuerst in einem Feld der Breite 10 linksbündig, anschließend nochmals durch einen senkrechten Strich abgetrennt rechtsbündig mit führenden Nullen in einem Feld der Breite 12.
  - Gleitpunktzahl : im Dezimalbruch-Standardformat, anschließend nochmals durch 3 Blanks abgetrennt in Exponentendarstellung mit 8 Nachpunktstellen

- Ausgabe folgender Gleitpunktzahl-Grenzwerte in folgenden Formaten :
  - `FLT_MIN` im Dezimalbruch-Standardformat, anschließend in einer neuen Zeile im Exponentendarstellungs-Standardformat
  - `FLT_MAX` im Dezimalbruch-Standardformat, anschließend in einer neuen Zeile im Exponentendarstellungs-Standardformat
  - `DBL_MAX` in Exponentendarstellung mit (DBL_DIG-1) Nachpunktstellen

Alle Programmausgaben müssen dem nachfolgenden Beispiel entsprechen :

    G:\>e:auf1

    Zeichen      ? f
    Integer-Zahl ? 2468
    Double-Zahl  ? 326.109

    Ausgabe der eingegebenen Werte :

    'f' : 102   $66   @146
    2468      |000000002468
    326.109000  3.26109000e+02

    Ausgabe einiger Gleitpunkt-Grenzwerte :

    FLT_MIN : x...
                  : x...
    FLT_MAX : x...
                  : x...
    DBL_MAX : x...

    G:\>

## 2. Aufgabe

Bei vielen Rechnersystemen/Terminals existieren spezielle Steuersequenzen zur Steuerung der Bildschirmausgabe.
Eine Ausgabe dieser Steuersequenzen führt nicht zur direkten Ausgabe der darin enthaltenen Zeichen sondern bewirkt eine Bildschirmsteuerung.
Diese Steuersequenzen können für unterschiedliche Systeme unterschiedlich sein.
Beispielsweise gelten für den IBM-PC (bei geladenem ANSI-Treiber) die ANSI- Steuersequenzen und für den Atari die VT52-Steuersequenzen :

| ANSI (IBM-PC) | VT52 (ATARI)
--- | --- | ---
Clear Screen (u. Cursor Home) | <ESC> [ 2 J | <ESC> E
absolute Cursor-Positionierung | <ESC> [ Zn;Sn f | <ESC> Y Zx Sx
| Zn Zeilennummer (1..25) | Zx = (char)(Zn + 31)
| Sn Spaltennumm. (1..80) | Sx = (char)(Sn + 31)

<ESC> ist das ASCII-Steuerzeichen mit dem sedizimalen Zeichencode $1B

1. Erstellen Sie ein portables (d.h. ohne Quellcode-Änderung nur durch Neuübersetzung sowohl auf dem IBM-PC als auch auf dem ATARI ablauffähiges) ANSI-C-Programm,daß
   - den Bildschirm löscht
   - die Eingabeaufforderung `Position (Zeile Spalte) ?` in der ersten Zeile ausgibt
   - und an der eingegebenen Position das folgende Alpha-Muster ausgibt (linkes oberes Zeichen in der eingegebenen Position)

         FFFF   H  H
         F      H  H
         FFFF   HHHH
         F      H  H
         F      H  H

         FH MUENCHEN

   Nach Drücken der <RETURN>-Taste soll der Bildschirm wieder gelöscht und das Programm beendet werden.

   Die Portabilität ist durch - mittels geeigneter Preprozessoranweisungen realisierbare - Definition der Makros

   `CLS` | (Löschen des Bildschirms und Cursor Home)
   `POS(x, y)` | (Cursor zu Spalte x und Zeile y)

   und bedingte Compilierung zu erreichen.

   Als Unterscheidungskriterium soll die nur beim ATARI-PURE-C-Compiler definierte Konstante `__PUREC__` (=1) dienen.

2. Modifizieren Sie das Programm aus a) so, daß durch immer erneute Positionsanforderungen und -eingaben eine wiederholte Verschiebung des Alpha-Musters möglich ist. (Verschiebung bedeutet, daß das Musters an der alten Position gelöscht wird)
   Die Eingabeaufforderung soll ständig in der ersten Bildschirmzeile erscheinen.
   Bei Eingabe von CTRL-Z (mit anschließendem <RETURN>) soll - nach Löschen des Bildschirms - das Programm beendet werden.

## 3. Aufgabe

Ein über die Standardeingabe einzugebender Text soll analysiert werden.

Erstellen Sie ein ANSI-C-Programm, mit dem

- die Anzahl der Zeilen,
- die Anzahl der Zeichen der längsten Zeile,
- die Anzahl der Worte,
- die Länge des längsten Wortes des Eingabetextes ermittelt werden kann.

Unter einem Wort sei dabei jede Zeichenfolge, die mit einem Buchstaben oder Underscore ('_') beginnt, nur aus Buchstaben, Ziffern und dem Underscore besteht und von beliebigen Steuer- oder Sonder-Zeichen (nicht aber Ziffern) begrenzt wird, verstanden.
Beachten Sie, daß nach dieser Definition z. B. die Zeichenfolge ;2abc% kein Wort enthält.

- Hinweise zur Lösung :

  - Der Text ist mit der Funktion getchar() einzulesen und darf nicht in Arrays abgelegt werden.

  - Aus Vereinfachungs- (u. Portabilitäts-) Gründen kann angenommen werden, daß die deutschen Umlaute nicht im Text vorkommen.

  - Berücksichtigen Sie, daß die letzte Zeile nicht unbedingt mit einem Zeilenendezeichen abgeschlossen sein muß.
    Andererseits stellt ein Dateiendezeichen (CTRL-Z unter MS-DOS) unmittelbar nach einem Zeilenende keine neue Zeile dar.

  - Zur Vereinfachung der Wortermittlung sind die folgenden symbolischen Konstanten zu definieren und sinnvoll zu verwenden:

    - symbolische Konstante zur Kennzeichnung der jeweiligen Zeichenklasse

      `BU` | (Groß- u. Kleinbuchstaben, Underscore)
      `ZIFF` | (Ziffern)
      `SONST` | (restliche Zeichen, d.h. Steuerzeichen und sonstige Sonderzeichen)

    - symbolische Konstante zur Kennzeichnung des jeweils aktuellen Textzustands

      `PRE_WORT` | (nächstes Zeichen kann Anfang eines Wortes sein)
      `IN_WORT` | (innerhalb eines Wortes)
      `NO_WORT` | (innerhalb einer Zeichenfolge, die kein Wort ist, nächstes Zeichen kann nicht Anfang eines Wortes sein)

  - Überlegen Sie sich den durch ein Zeichen in Abhängigkeit von seiner Klasse und dem alten Textzustand jeweils ausgelösten Zustandsübergang.
    Zeichnen Sie ein Zustandsübergangsdiagramm.
    Das Diagramm ist bei der Programm-Abgabe vorzulegen.

  - Beschreiben Sie den durch das Programm zu realisierenden Algorithmus vor der Formulierung in C durch ein Struktogramm.
    Das Struktogramm ist bei der Programm-Abgabe vorzulegen.

## 4. Aufgabe

Erstellen Sie ein ANSI-C-Programm, mit dem ein Histogramm der Wortlänge eines über die Standardeingabe eingegebenen Textes ermittelt und in folgender Form auf dem Bildschirm ausgegeben werden kann:

                  H i s t o g r a m m  der Wortlänge eines Textes
                  -----------------------------------------------
                     *
            *        *
      *     *        *
      *     *        *
      *     *        *
      *     *        *
      *     *        *
      *     *        *
      *  *  *        *           *
      *  *  *        *        *  *
      *  *  *     *  *        *  *                                            *
      *  *  *  *  *  *  *  *  *  *     *     *                                *
      *  *  *  *  *  *  *  *  *  *  *  *  *  *                                *
    ---------------------------------------------------------------------------
      1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

Unter einem Wort sei hier jede Zeichenfolge, die mit einem Buchstaben oder Underscore ('_') beginnt, nur aus Buchstaben, Ziffern und dem Underscore besteht und von beliebigen Steuer- oder Sonder-Zeichen (nicht aber Ziffern) begrenzt wird, verstanden.
Beachten Sie, daß nach dieser Definition z. B. die Zeichenfolge ;3abc% kein Wort enthält.

Die Anzahl der Sternchen soll gleich der Anzahl der Auftritte eines Worts der entsprechenden Länge sein.
Alle Worte, die größer gleich 25 Zeichen lang sind, sollen dabei zu einer Gruppe zusammengefaßt werden.

Damit die gesamte Bildschirmausgabe sichtbar ist, ist bei Wortlängen, deren Auftritte die Anzahl 20 überschreitet die Ausgabe auf 19 Sternchen zu begrenzen und an der Position des 20. (obersten) Sternchens die tatsächliche Anzahl der Auftritte auszugeben.

- Hinweise zur Lösung :

  - Greifen Sie zur Wortermittlung auf den in der Aufgabe 3 entwickelten Algorithmus zurück

  - Legen Sie zur Aufnahme der Auftritte der einzelnen Wortlängen ein int- Array an, dessen Komponenten zweckmäßigerweise über die Wortlänge indiziert werden.

  - Die Bildschirmausgabe darf nicht über eine absolute Cursor- Positionierung erfolgen.

## 5. Aufgabe

- Formulieren Sie eine ANSI-C-Funktion
  `pos(str1,str2)` ,
  die den String `str2` nach dem ersten Auftreten des Strings `str1` durchsucht und folgenden Funktionswert liefert :

  Funktionswert :

    - Index, | den das erste Zeichen von `str1` in `str2` innehat, wenn `str1` vollständig in `str2` enthalten ist (erster Index : 0)
    - -1, | wenn `str1` nicht "vollständig" (oder garnicht) in `str2` enthalten ist.

- Formulieren Sie eine ANSI-C-Funktion
  `ein_str(str)` ,
  mit der der String "str" von der Standardeingabe eingelesen wird.
  Die Funktion soll - bis auf die Funktionswerterzeugung - wie die ANSI-C-Standardfunktion `gets(str)` arbeiten.

  Funktionswert :

    - Stringlänge, | wenn die Eingabe mit <RET> abgeschlossen wurde
    - EOF, | wenn die Eingabe mit CTRL-Z abgeschlossen wurde

- Testen Sie die obigen Funktionen mit einem kleinen ANSI-C-Programm.
  Eingabeaufforderung - von der Standardeingabe zuerst einen Zielstring und anschließend einen Suchstring einlesen und

  - | bei Enthaltensein den Index des ersten Auftritts des Suchstrings im Zielstring
  - | bzw. bei Nicht-Enthaltensein die Meldung "Nicht enthalten !"

  ausgeben.
  Eine Beendigung der Einleseschleife und damit des Programms soll erfolgen, wenn an beliebiger Stelle CTRL-Z eingegeben wird.

- Hinweise zur Lösung :

  - Such- und Zielstring können eine maximale Länge von 80 Zeichen haben.
    Die Funktion `ein_str` soll nicht auf Überschreitung einer maximal zulässigen Stringlänge überprüfen.

  - Beide Funktionen dürfen keine globalen Variablen verwenden.

  - Bibliotheksfunktionen zur Stringverarbeitung dürfen nicht verwendet werden

  - Groß- und Kleinbuchstaben sind als verschieden zu betrachten

  - Berücksichtigen Sie bei der Funktion `pos`, daß der abschliessende NUL-Character ('\0') nicht zum eigentlichen String gehört und daher in die Suche nicht miteinzubeziehen ist.
    Überlegen Sie sich ein sinnvolles Verhalten von `pos` für die Übergabe von Leerstrings.

  - Verwenden Sie zur Ermittlung des Funktionswertes von `pos` und `ein_str` den bedingten Auswerteoperator

## 6. Aufgabe

Entwickeln Sie ein ANSI-C-Programm, das auf die Eingabe von Abkürzungsbezeichnungen für die - deutschen - Wochentage mit der Ausgabe des vollen - englischen - Namens der Wochentage reagiert.

- Die Abkürzungsbezeichnungen für die Wochentage sollen aus 3 Zeichen bestehen und folgendermaßen lauten : MON, DIE, MIT, DON, FRE, SAM, SON.
  Zwischen Groß- und Kleinbuchstaben soll dabei nicht unterschieden werden, d.h. statt "MON" kann z.B. auch "mon" oder "Mon" oder "moN" usw. verwendet werden.
- Auf die Eingabe einer falschen - auch zu kurzen - Abkürzungsbezeichnung soll das Programm mit der Ausgabe von "No_day" reagieren.
- Das Programm soll in einer Schleife in jeweils einer neuen Zeile die Eingabe einer neuen Abkürzungsbezeichnung anfordern und die entsprechende Ausgabe in der nächsten Zeile erzeugen.
  Abschluß jeder Eingabe mit <RETURN>.
- Werden mehr als drei Zeichen eingegeben, so sind nur die ersten drei Zeichen zu berücksichtigen. Der Rest der Eingabezeile ist zu ignorieren.
- Das Programm soll enden, wenn nach einer Eingabeaufforderung als erstes Zeichen ein Dateiende-Zeichen (unter MS-DOS : <CTRL-Z>) eingegeben wird.

- Beispiel für einen Programmdialog :

      Geben Sie die Abkürzung eines Wochentages ein :

      ? mon
        --> Monday

      ? mo
        --> No_day

      ? Dienstag
        --> Tuesday

      ? ^Z

- Hinweise zur Lösung :

  - Gliedern Sie das Programm möglichst sinnvoll in geeignete Funktionen.
    U.a. sind die folgenden Funktionen zu entwickeln und zu verwenden :

    `int get_mstr(int m, char s[])` | Einlesen eines Strings der maximalen Länge m in die Variable s (von stdin), Überlesen eventueller weiterer Zeichen bis zum Zeilenende. Funktionswert : 1. gelesenes Zeichen bzw. `EOF`
    `void up_str(char s[])` | Umwandlung aller Klein-Buchstaben im String s in Großbuchstaben

    Zur eigentlichen Ermittlung des vollen englischen Namens aus der deutschen Abkürzung sind eine oder zwei weitere geeignete Funktionen zu definieren und einzusetzen.

  - Setzen Sie geeignete 2-dimensionale char-Arrays zur Speicherung der Abkürzungsbezeichnungen und der vollen Wochentags-Namen ein.

## 7. Aufgabe

Erstellen Sie ein ANSI-C-Programm, mit dem über die Tastatur eingegebene arithmetische Ausdrücke ausgewertet werden (Taschenrechner !).

Beispiel:

Eingabe : (4 + 7.5 * 3)*2-5.5*4=
Ausgabe : 31.000000

Das Programm soll in einer Schleife fortwährend die Eingabe eines Ausdrucks anfordern, diesen einlesen, auswerten und das Ergebnis am Bildschirm ausgeben.
Es soll enden, wenn an beliebiger Stelle ein Dateiendezeichen (CTRL_Z) eingegeben wird.

Auf die Eingabe eines fehlerhaften Ausdrucks sowie eines Nenners mit dem Wert "0" soll das Programm mit der Ausgabe einer entsprechenden Fehlermeldung statt eines Ergebnisses reagieren.
Dabei sollen folgende Fehlermeldungen unterschieden werden :

- "Schließende Klammer fehlt"
- "Sonstiger Syntaxfehler"
- "Nenner ist 0"

Hinweise :

- Ein Ausdruck kann mit folgenden syntakt. Regeln beschrieben werden :

      Ausdruck ::== Term { +Term || -Term }
      Term     ::== Faktor { *Faktor || /Faktor }
      Faktor   ::== Zahl || (Ausdruck)
      Zahl     ::== [-] Ziffer{Ziffer}[.{Ziffer}]

- Im Ausdruck dürfen - außer innerhalb einer Zahl - an beliebiger Stelle Whitespace-Character (Blank, Newline, Tab) vorkommen.

- Beachten Sie, daß ein Ausdruck im obigen Sinne aus Gleitpunktzahlen gebildet wird, diese aber nur in der "Komma"-Darstellung, nicht jedoch in der Exponenten-Darstellung eingegeben werden dürfen.

- Die Eingabe eines Ausdrucks soll mit einem "=" nicht jedoch mit einem <RET> abgeschlossen werden, d.h. ein Ausdruck kann sich durchaus über mehrere Zeilen erstrecken.

- Setzen Sie zum Einlesen nur die Funktion `getchar()`, nicht jedoch die Funktionen `scanf()` oder `gets()` ein.

- Verwenden Sie zur Auswertung eines Ausdrucks geeignete Funktionen, die die obigen Regeln nachbilden. (Beachten Sie die enthaltene Rekursion !)
  Diese Funktionen dürfen weder Parameter besitzen noch auf globale Größen zugreifen.
  Jede Funktion muß die von ihr verarbeiteten Zeichen selbst einlesen.
  Stößt sie dabei auf ein Zeichen, das der von ihr verarbeiteten Syntax nicht entspricht, so ist sie nach Rückgabe des Zeichens an die Standard- eingabe (`ungetc()` !) zu beenden.

- Zur Kennzeichnung eines Fehlers läßt sich z.B. die Möglichkeit ausnutzen, mit ungetc() auch ein anderes als das zuletzt gelesene Zeichen zurückzugeben.

## 8. Aufgabe

Erstellen Sie ein Programm mit dem maximal 1000 Strings der maximalen Länge 136 alphabetisch sortiert werden können, wobei große und kleine Buchstaben jeweils als gleich betrachtet werden sollen.
Verwenden Sie zum Sortieren den Quick-Sort-Algorithmus.

Durch Angabe von "auf" bzw. "ab" in der Kommandozeile soll beim Programmaufruf bestimmt werden, ob aufsteigend oder absteigend sortiert wird.
Wird kein oder kein zulässiger Kommandozeilenparameter angegeben, so ist aufsteigend zu sortieren.

Die zu sortierenden Strings sind von stdin einzulesen.

Die sortierten Strings sind nach stdout auszugeben.

Hinweise :

- Die Eingabe jedes Strings wird jeweils durch ein Zeilenende abgeschlossen.
  Das Zeilenende selbst gehört aber nicht mehr zum String.
  Die Eingabe der Strings wird durch ein Dateiendezeichen(CTRL-Z) beendet.

- Für die einzelnen Strings ist immer nur soviel Speicherplatz zu allokieren, wie tatsächlich benötigt wird.

- Das Programm ist durch Definition und Verwendung geeigneter Funktionen modular zu gestalten.
  U.a. sind die folgenden drei Funktionen zu formulieren :

  `str_feld_ein(.....)` | Einlesen der Strings
  `str_feld_sort(.....)` | Sortieren der Strings
  `str_feld_aus(.....)` | Ausgabe der Strings

  In der Funktion `main()` dürfen nach der Ermittlung der Sortierrichtung im wesentlichen nur diese drei Funktionen aufgerufen werden.

- Das Quellprogramm ist so zu formulieren, daß es gegen eine Änderung der maximalen Stringanzahl und der maximalen Stringlänge parameterisierbar ist.

- Das Programm soll auch dann fehlerfrei enden, wenn die Eingabe sofort mit einem Dateiendezeichen (CTRL-Z) abgeschlossen wird, d.h. wenn überhaupt keine Strings eingelesen werden.

- Der Parameter "auf" bzw. "ab" bestimmt die tatsächliche Sortierrichtung und nicht nur die Ausgaberichtung der Strings.

- Verwenden Sie zum Testen beim Programmaufruf die Umleitung der Standard-Eingabe aus einer beliebigen Text-Datei.

## 9. Aufgabe

In einer Datei, deren Name wechseln kann, befinden sich eine nicht bekannte Anzahl unsortierter "double"-Werte in maschineninterner Darstellung.

Erstellen Sie ein ANSI-C-Programm, mit dem die Werte gelesen und intern in einer binären Baumstruktur aufsteigend sortiert gespeichert werden.

Anschliessend ist die sortierte Wertefolge auf den Maximalwert normiert in eine Textdatei - pro Zeile ein Wert - auszugeben.
Der Name der Textdatei soll ebenfalls variabel sein.

Am Bildschirm sind die Anzahl der gelesenen Werte, der Maximalwert und der Minimalwert (jeweils unnormiert) auszugeben.

Die Namen der Eingabe-(Double-Werte-)Datei und der Ausgabe-(Text-)Datei sind als Kommandozeilenparameter zu übergeben.
Wird nur ein oder kein Kommandozeilenparameter übergeben, so ist daß Programm mit einem Hinweis auf das richtige Aufrufformat zu beenden.

Kann die Eingabedatei nicht geöffnet werden (z.B. weil sie nicht existiert) oder kann die Ausgabedatei nicht geöffnet werden, so ist das Programm mit der Ausgabe eines entsprechenden Hinweises, der den Dateinamen enthalten muß, zu beenden.

Für Testzwecke wird eine geeignete Datei mit den "double"-Werten zur Verfügung gestellt.

Hinweise :

- Das Programm ist durch Definition und Verwendung geeigneter Funktionen modular zu gestalten.
  U.a. sind die folgenden drei Funktionen zu formulieren :

  `dwerte_ein(.....)` | Einlesen und sortiertes Abspeichern der double-Werte
  `dwerte_aus(.....)` | Ausgabe der normierten double-Werte in Textdatei
  `display_info(.....)` | Ausgabe der am Bildschirm über die eingelesenen Zahlen auszugebende Information

  Diese Funktionen können gegebenenfalls weitere zu definierende Funktionen aufrufen.

## 10. Aufgabe

Erstellen Sie ein C-Programm DUMP mit dem der Inhalt einer beliebigen Datei sedezimal und in ASCII-Interpretation am Bildschirm ausgegeben werden kann (siehe untenstehende Darstellung ). Dabei sind Steuerzeichen und Zeichen mit einem Code >=$80 in der ASCII-Interpretation als Punkt darzustellen.
Der Name der Datei ist als Kommandozeilenparameter zu übergeben.
Bei Fehlen dieser Angabe ist durch das Programm nach dem Dateinamen zu fragen.
Kann die angegebene Datei nicht geöffnet werden, so ist das Programm mit der Ausgabe eines entsprechenden Hinweises zu beenden.

Der Dump ist seitenweise (jeweils 16 Zeilen zu je 16 Bytes) durchzuführen. Nach der Darstellung einer Seite soll jeweils wie folgt fortgefahren werden: Bei Eingabe von

'+' oder <RETURN> | : Darstellung der nächsten Seite
'-', 'b' oder 'B' | : Darstellung der vorhergehenden Seite
'q' oder 'Q' | : Beendigung des Programms

Nach der Darstellung der letzten - eventuell nicht mehr vollständigen - Seite soll das Programm n i c h t automatisch beendet werden (sondern erst nach Eingabe von 'q' bzw 'Q').

Hinweis zur Lösung :

- Die die Ausgabe steuernden Zeichen sind mit der - leider nicht ANSI-C- - Funktion `getch()` einzulesen, damit nicht die Eingabe jedes Zeichens mit <RETURN> abgeschlossen werden muß.

  Beispiel für die Ausgabe des Programms DUMP :

      Dumping File *** c:display.com *** (11053 Bytes)

      Adresse      0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F    0123456789ABCDEF

      00000000 :  E9 51 29 90 90 CD AB 43 6F 70 79 72 69 67 68 74    .Q)....Copyright
      00000010 :  20 28 43 29 20 31 39 38 35 20 42 4F 52 4C 41 4E     (C) 1985 BORLAN
      00000020 :  44 20 49 6E 63 02 08 00 20 54 00 1E 30 00 00 00    D Inc... T..0...
      00000030 :  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00    ................
      00000040 :  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00    ................
      00000050 :  00 00 00 00 00 0C 53 69 65 6D 65 6E 73 20 50 43    ......Siemens PC
      00000060 :  2D 44 73 65 6C 65 63 74 65 64 50 19 00 04 1B 5B    -DselectedP....[
      00000070 :  30 6D 00 00 00 00 00 00 00 00 00 00 00 04 1B 5B    0m.............[
      00000080 :  30 6D 00 00 00 00 00 00 00 00 00 00 00 08 1B 5B    0m.............[
      00000090 :  30 30 3B 30 30 48 30 48 00 00 00 00 00 00 01 01    00;00H0H........
      000000A0 :  07 04 00 00 04 1B 5B 32 4A 00 03 1B 5B 66 00 00    ......[2J...[f..
      000000B0 :  04 1B 5B 31 4C 00 04 1B 5B 31 4D 00 00 00 03 1B    ..[1L...[1M.....
      000000C0 :  5B 4B 00 00 04 1B 5B 30 6D 00 04 1B 5B 32 6D 00    [K....[0m...[2m.
      000000D0 :  00 00 08 1B 5B 32 35 3B 30 31 48 30 48 00 00 00    ....[25;01H0H...
      000000E0 :  00 00 2E 8A 27 0A E4 F9 74 0E 43 2E 8A 07 50 E8    ....'...t.C...P.
      000000F0 :  4C 05 58 FE CC 75 F3 F8 C3 8B D8 43 4B 75 01 C3    L.X..u.....CKu..

      Adresse      0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F    0123456789ABCDEF

      Weiter mit <+> o. <RETURN>       Zurueck mit <-> o. <B>        Abbruch mit <Q>

Zum Inhaltsverzeichnis | Zum nächsten Abschnitt

###### Copyright © FH München, FB 04, Prof. Dr. Rainer Thomas
U - PC - 021 - 01 - TH - 07
U - PC - 021 - 02 - TH - 07
U - PC - 022 - 00 - TH - 05
U - PC - 023 - 00 - TH - 03
U - PC - 024 - 01 - TH - 06
U - PC - 024 - 02 - TH - 07
U - PC - 025 - 00 - TH - 05
U - PC - 026 - 00 - TH - 07
U - PC - 027 - 00 - TH - 04
U - PC - 028 - 00 - TH - 04