Beuth Hochschule WS17/18, S. 1

Beuth Hochschule WS17/18, S. 1 Inhaltsverzeichnis

Vergleichen (in Java)...1

1. Primitive Werte vergleichen...1

2. Strings vergleichen...1

3. String-Objekte sind natürlich geordnet...3

4. Weitere ("nicht-natürliche") Ordnungen für eine Klasse...5

5. Comparator-Objekte aus Comparator-Objekten erzeugen...7

Vergleichen (in Java) 1. Primitive Werte vergleichen In Java gibt es 8 primitive Typen (byte, char, short, int, long, float, double, boolean). Die ersten 7 gelten als numerisch, nur boolean ist ein nicht-numerischer Typ. Werte der 7 numerischen Typen kann man mit den 6 Operationen <, <=, ==, !=, >=, > vergleichen, und zwar "alle mit allen": Z.B. darf man einen byte-Wert mit einem double-Wert oder einen long -Wert mit einem char -Wert vergleichen. Besonders häufig werden aber zwei Werte des selben Typs miteinander verglichen. Die 6 Vergleichsoperationen liefern jeweils ein Ergebnis vom Typ boolean, d.h. einen der 2 Werte true und false. Aber wenn man z.B. zwei int-Werte n1 und n2 vergleicht, sind insgesamt 3 Ergebnisse möglich:n1 ist kleiner als n2, n1 ist gleich n2 und n1 ist größer als n2. Daraus folgt: Um alle 3 Ergebnisse zu unterscheiden muss man die Werte zweimal miteinander vergleichen, etwa so, wie im folgenden Beispiel: Beispiel-01: Alle 3 mögliche Vergleichsergebnisse unterscheiden (mit int-Variablen): 1 static void vergleiche01(int n1, int n2) { 2 if (n1 < n2) { 3 printf("%d ist kleiner als %d%n", n1, n2); 4 } else if (n1 > n2) { 5 printf("%d ist groesser als %d%n", n1, n2); 6 } else { 7 printf("%d ist gleich %d%n", n1, n2); 8 } 9 } Wenn man die Prozedur vergleiche01 mehrmals aufruft wie folgt 75 vergleiche01(100, 200); 76 vergleiche01(200, 100); 77 vergleiche01(200, 200); werden die folgenden Zeilen zum Bildschirm ausgegeben: 100 ist kleiner als 200 200 ist groesser als 100 200 ist gleich 200

2. Strings vergleichen

Das Vergleichen von Ausrücken eines Referenztyps wird hier am Beispiel von String -Variablen erläutert. Das Vergleichen von Ausdrücken anderer Typen geht dann mehr oder weniger ähnlich.

Als Beispiel betrachten wir hier die folgenden String-Variablen:

String s1 = ...;

String s2 = ...;

Diese Variablen sollen auf zwei String-Objekte beliebiger Länge (zwischen 0 und ca. 2.15 Milliarden) zeigen.

Mit Ausdrücken wie s1 == s2 oder s1 != s2 befiehlt man dem Ausführer, die Werte von s1 und s2 zu vergleichen. Das geht auf heute üblichen Rechnern ähnlich schnell, wie der Vergleich von zwei int-Werten oder von zwei long-Werten (und somit "sehr schnell").

Häufig will man aber nicht die Werte von Referenzvariablen (oder anderen Ausdrücken eines Referenztyps) miteinander vergleichen, sondern ihre Zielwerte (d.h. die Objekte auf die sie zeigen).

Wichtige Frage: Warum haben die Entwickler von Java nicht erlaubt, dass ein Ausdruck wie s1 < s2 erlaubt ist, und den Wert true liefert, wenn der String s1 (der Zielwert von s1) kleiner ist als der String s2? Im Prinzip wäre diese Festlegung durchaus möglich gewesen.

Antwort: Die Entwickler haben an den kompliziertesten Fall gedacht: Die beiden String-Objekte sollen verglichen werden und alle 3 möglichen Ergebnisse (s1 ist kleiner/gleich/größer s2) sollen unterschieden werden. Mit Operatoren wie < und >, die "nur ein boolean-Ergebnis" liefern, wären dazu 2 Vergleiche nötig (ähnlich wie oben im Beispiel-01). Wenn die Strings z.B. beide die Länge 2 Milliarden haben und sich nur im letzten char-Wert unterscheiden, wäre ein solcher Vergleich

ziemlich teuer und zwei solche Vergleiche ungefähr zweimal so teuer. Die Notwendigkeit eines zweiten Vergleichs wollte man verhindern und Vergleiche mit 3 verschiedenen Ergebnissen ermöglichen.

Deshalb vergleicht man String-Objekte in Java nicht mit boolean-Operationen (d.h. mit

Operationen, die ein Ergebnis vom Typ boolean liefern), sondern mit einer Objekt-Methode, die etwa wie folgt aussieht:

public int compareTo(String that) {

// Vergleicht this lexikografisch mit that und liefert // einen negativen Wert, 0 bzw. einen positiven Wert

// je nachdem ob this kleiner, gleich bzw. groesser ist als that.

...

}

Anmerkung 1: Der Original-Anfangskommentar in der Java-Standard-Bibliothek wurde hier sehr frei übersetzt, verkürzt und vereinfacht. Es schadet wahrscheinlich nichts, wenn Sie sich auch mal das Original ansehen.

Anmerkung 2: Der Vorteil der Methode compareTo (im Vergleich zu einer der boolean- Operationen <, <=, >=, >): Sie liefert eines von 3 Ergebnissen statt eines von nur 2 Ergebnissen.

Anmerkung 3: Ein String s1 ist lexikografisch kleiner als ein String s2, wenn s1 in einem Lexikon weiter vorne stehen müsste als s2.

Anmerkung 4: Im Internet wird die lexikografische Ordnung für Strings an vielen Stellen mit der lexikalischen Ordnung für Strings verwechselt. Die lexikalische Ordnung ist wie folgt definiert:

Ein String s1 ist lexikalisch kleiner als ein String s2, wenn entweder s1 kürzer ist als s2

oder s1 und s2 gleich lang sind und s1 lexikografisch kleiner ist als s2.

In der Java-Standardbibliothek gibt es keine Methode, die der lexikalischen Ordnung für Strings entspricht. Man kann sie aber selbst programmieren.

Anmerkung 5: Ein interessanter mathematischer Unterschied zwischen der lexikografischen und der

lexikalischen Ordnung für Strings (wenn die Länge der Strings nicht begrenzt ist): Bezüglich der

lexikografischen Ordnung gibt es zu zwei verschiedenen Strings immer unendlich viele Strings, die

zwischen die beiden gehören. Bezüglich der lexikalischen Ordnung sind es immer nur endlich viele.

Beuth Hochschule Vergleichen (in Java) WS17/18, S. 3 Beispiel-02: Alle 3 mögliche Vergleichsergebnisse unterscheiden (mit String-Variablen):

10 static void vergleiche02(String s1, String s2) {

11 int erg = s1.compareTo(s2); // 1 teurer Vergleich 12 if (erg < 0) { // 1 billiger Vergleich 13 printf("%-6s ist kleiner als %-6s%n", s1, s2);

14 } else if (erg > 0) { // 1 billiger Vergleich 15 printf("%-6s ist groesser als %-6s%n", s1, s2);

16 } else {

17 printf("%-6s ist gleich %-6s%n", s1, s2);

18 } 19 }

Wenn man die Prozedur vergleiche02 mehrmals aufruft wie folgt

82 String str1 = new String("Alfred");

83 String str2 = new String("Anna"); // str2 und

84 String str3 = new String("Anna"); // str3 haben verschiedene Werte!

85 vergleiche02(str1, str2);

86 vergleiche02(str2, str1);

87 vergleiche02(str2, str3);

werden die folgenden Zeilen zum Bildschirm ausgegeben:

Alfred ist kleiner als Anna Anna ist groesser als Alfred Anna ist gleich Anna

3. String-Objekte sind natürlich geordnet

Die Vereinbarung der Klasse java.lang.String beginnt etwa wie folgt:

public final class String implements Comparable<String>, ... {

Das Schlüsselwort final bewirkt, dass man von dieser Klasse keine Unterklassen (oder:

Erweiterungen) vereinbaren darf ( ... extends String ist verboten).

Die Schnittstelle Comparable<String> ist eine Instanz der generischen Schnittstelle

Comparable<T>. Mit der Angabe von implements Comparable<String> verspricht der Programmierer, alle in der Schnittstelle Comparable vereinbarten abstrakten Methoden zu

implementieren (nachdem darin alle Vorkommen des Typ-Parameters T durch den Typ String ersetzt wurden). Hier bedeutet "implementieren" so viel wie: Eine abstrakte Methode durch die Vereinbarung einer konkreten Methode ("normale Methode mit Rumpf") zu überschreiben.

Anmerkung 1: Die Angabe von implements Comparable<String> am Anfang der Klasse String hat auch noch folgende Wirkung: Jedes Objekt des Typs String ist gleichzeitig ein Objekt des Typs Comparable<Sring>. Daraus folgt, das z.B. eine Vereinbarung wie die folgende erlaubt ist:

Comparable<String> cso = "Hallo!";

Die Schnittstelle Comparable<T> enthält nur eine abstrakte Methode:

public abstract int compareTo(T o);

// Compares this object with o for order.

Der Original-Kommentar wurde hier leicht überarbeitet wiedergegeben.

Anmerkung 2: "for order" heißt etwa so viel wie "mit 3 Ergebnissen: kleiner, gleich oder größer".

Anmerkung 3: Innerhalb der Vereinbarung einer Schnittstelle dürfen die Schlüsselworte

public abstract auch weggelassen werden (und die Leser müssen sie sich dann "dazudenken").

Auch in der Online-Dokumentation der Java-Standardbibliothek werden die beiden Schlüsselworte

weggelassen und gelten (in einer Schnittstelle) als selbstverständlich.

Um die Schnittstelle Comparable<String> zu implementieren ist in der Klasse String die Methode compareTo wie folgt Methode vereinbart:

1140 public int compareTo(String that) { 1141 int len1 = this.value.length;

1142 int len2 = that.value.length;

1143 int lim = Math.min(len1, len2);

1144 char v1[] = this.value;

1145 char v2[] = that.value;

1146

1147 for (int k=0; k<lim; k++) { 1148 char c1 = v1[k];

1149 char c2 = v2[k];

1150 if (c1 != c2) return c1 - c2;

1151 }

1152 return len1 - len2;

1153 }

Der Original-Code wurde hier leicht überarbeitet wiedergegeben.

Anmerkung 2: Bevor er die Subtraktion c1 - c2 in Zeile 1150 durchführt, wandelt der Ausführer die char-Werte der beiden Variablen in entsprechende int-Werte um. Das tut er immer (so kann man sich vorstellen) "weil er mit char-Werten nicht rechnen kann". Falls c2 größer als c1 ist, würde ohne diese Umwandlung ein unerwünschtes Ergebnis herauskommen, da zum Typ char keine negativen Werte gehören und deshalb ein Unterlauf aufträte.

Def.: Eine Klasse K heißt natürlich geordnet, wenn sie die Schnittstelle Comparable<K> implementiert.

Die Objekt-Methode compareTo der Klasse String ist eine Implementierung der lexikografischen Ordnung. Obige compareTo-Methode legt also die lexikografische Ordnung als natürliche Ordnung der Klasse String fest.

Etwa 150 Klassen in der Standard-Bibliothek (darunter die Klassen BigDecimal, BigInteger, Boolean, Byte, Character, Double, Float, Integer, Long, Short) sind in diesem Sinne natürlich geordnet. Der Programmierer kann seine Klassen auf die gleiche Weise mit einer natürlichen Ordnung ausrüsten.

Die folgenden Beispiele zeigen Situationen, in denen die natürliche Ordnung (der Klasse String) eine Rolle spielt:

Beispiel-03: Eine Reihung von Strings natürlich sortieren

Die Klasse java.util.Arrays enthält zahlreiche Klassenmethoden zur Bearbeitung von Reihungen (eng. arrays).

import java.util.Arrays;

...

String[] sr3 = {"c", "a", "D", "B"};

printf("sr3 vorher: %s%n", Arrays.toString(sr3));

Arrays.sort(sr3); // sr3 wird "natürlich sortiert"

printf("sr3 nachher: %s%n", Arrays.toString(sr3));

Mit der Methode Arrays.toString wird die Reihung sr3 in einen lesbaren ("ausgebbaren") String umgewandelt. Mit der Methode Arrays.sort wird die Reihung sr3 entsprechend der natürlichen Ordnung der Klasse String sortiert. Die beiden printf-Befehle geben Folgendes aus:

sr3 vorher: [c, a, D, B]

sr3 nachher: [B, D, a, c]

Man sieht: Die natürliche Ordnung für Strings ist groß-klein-empfindlich (eng.: case sensitive), d.h.

alle Großbuchstaben sind kleiner als alle Kleinbuchstaben.

Beuth Hochschule Vergleichen (in Java) WS17/18, S. 5

Besipiel-04: Eine natürlich sortierte Sammlung von Strings erzeugen

Jedes Objekt der Klasse java.util.TreeSet ist eine sortierte Sammlung. Die Sammlung ts4 enthält String-Objekte und ist entsprechend der natürlichen Ordnung der Klasse String sortiert:

import java.util.TreeSet;

import java.util.Arrays;

...

TreeSet<String> ts4 = new TreeSet<>(Arrays.asList("c", "a", "D", "B"));

printf("ts4: %s%n", ts4.toString());

Die Methode Arrays.asList bietet eine besonders bequeme Möglichkeit, die Komponenten einer List-Sammlung anzugeben. In diesem Beispiel erzeugt sie eine Sammlung des Typs

List<String>. Die Komponenten dieser List-Sammlung werden in die TreeSet-Sammlung ts4 eingefügt. Der printf-Befehl gibt Folgendes aus:

ts4: [B, D, a, c]

Auch hier kann man erkennen, dass die natürliche Ordnung von Strings groß-klein-empfindlich ist.

4. Weitere ("nicht-natürliche") Ordnungen für eine Klasse

Mit der Schnittstelle Comparable und ihrer Methode compareTo kann man für eine Klasse (z.B. für die Klasse String) nur eine Ordnung definieren (und die wird dann natürliche Ordnung der Klasse genannt). Häufig will man aber die Objekte einer Klasse nach verschiedenen Ordnungen sortieren (z.B.

String-Objekte manchmal groß-klein-empfindlich (engl. case sensitive) oder groß-klein-

unempfindlich, oder Objekte einer Klasse Person manchmal nach Nachnamen und manchmal nach Vornamen und manchmal nach Geburtsjahr etc.). Solche Ordnungen werden hier (nicht als

unnatürliche Ordnungen sondern) als weitere Ordnungen bezeichnet.

Weitere Ordnungen sollte man mit Hilfe der generischen Schnittstelle Comparator<T> vereinbaren.

Die Schnittstelle Comparator<T> enthält (neben 19 anderen Methoden) nur eine abstrakte Methode:

public abstract int compare(T o1, T o2);

// Compares o1 and o2 for order.

Der Original-Kommentar wurde hier leicht überarbeitet wiedergegeben.

Im Gegensatz zur Methode compareTo, die nur einen Parameter hat (siehe oben), hat die Methode compare zwei Parameter.

Um eine weitere Ordnung für eine Klasse K zu definieren, wird häufig eine weitere Klasse W vereinbart, die nur die Schnittstelle Comparator<K> implementiert und sonst nichts weiteres hat oder tut. In der Klasse W wird also nur eine (konkrete Objekt-) Methode

public int compare(K k1, K k2) { ... } vereinbart.

Für die Klasse String wurde (zusätzlich zur natürlichen Ordnung) noch eine zweite Ordnung

vereinbart, und zwar durch die folgende geschachtelte ("innerhalb der Klasse String vereinbarte")

Klasse:

Beuth Hochschule Vergleichen (in Java) WS17/18, S. 7

1173 private static class CaseInsensitiveComparator

1174 implements Comparator<String>, java.io.Serializable { 1175 // use serialVersionUID from JDK 1.2.2 for interoperability

1176 private static final long serialVersionUID = 8575799808933029326L;

1177

1178 public int compare(String s1, String s2) { 1179 int len1 = s1.length();

1180 int len2 = s2.length();

1181 int min = Math.min(len1, len2);

1182 for (int i = 0; i < min; i++) { 1183 char c1 = s1.charAt(i);

1184 char c2 = s2.charAt(i);

1185 if (c1 != c2) {

1186 c1 = Character.toUpperCase(c1);

1187 c2 = Character.toUpperCase(c2);

1188 if (c1 != c2) {

1189 c1 = Character.toLowerCase(c1);

1190 c2 = Character.toLowerCase(c2);

1191 if (c1 != c2) {

1192 // No overflow because of numeric promotion 1193 return c1 - c2;

1194 } 1195 } 1196 } 1197 }

1198 return len1 - len2;

1199 } 1200

1201 /** Replaces the de-serialized object. */

1202 private Object readResolve() { return CASE_INSENSITIVE_ORDER; } 1203 }

Der Original-Code wurde hier leicht überarbeitet wiedergegeben.

Der Kommentar // No overflow because of numeric promotion in Zeile 1192 wurde oben erläutert (siehe Abschnitt 3., Anmerkung 2).

Die Klasse CaseInsensitiveComparator ist privat, aber auf ein Objekt dieser Klasse kann jeder Programmierer über das folgende Klassen-Attribut der Klasse String zugreifen:

1171 public static final Comparator<String> CASE_INSENSITIVE_ORDER 1172 = new CaseInsensitiveComparator();

Die folgenden Beispiele sollen zeigen, wie man dieses Objekt (und damit die weitere Ordnung, die es realisiert) benutzen kann:

Beispiel-05: Eine Reihung Von Strings groß-klein-unempfindlich sortieren:

import java.util.Arrays;

...

String[] sr5 = {"c", "a", "D", "B"};

printf("sr5 vorher: %s%n", Arrays.toString(sr5));

Arrays.sort(sr5, String.CASE_INSENSITIVE_ORDER);

printf("sr5 nachher: %s%n", Arrays.toString(sr5));

Die beiden printf-Befehle geben Folgendes aus:

sr5 vorher: [c, a, D, B]

sr5 nachher: [a, B, c, D]

Beispiel-06: Eine groß-klein-unempfindlich sortierte Sammlung von Strings vereinbaren:

import java.util.TreeSet;

import java.util.Arrays;

...

TreeSet<String> ts6 = new TreeSet<>(String.CASE_INSENSITIVE_ORDER);

ts6.addAll(Arrays.asList("c", "a", "D", "B"));

printf("ts6: %s%n", ts6.toString());

Der printf-Befehl gibt Folgendes aus:

ts6: [a, B, c, D]

Leider hat die Klasse TreeSet keinen Konstruktor, dem man

ein Comparator-Objekt (z.B. das Objekt String.CASE_INSENSITIVE_ORDER) und eine Sammlung (z.B. die Sammlung Arrays.asList("c", "a", "D", "B") ) als Parameter angeben kann.

Auf diese Weise kann man für eine Klasse K beliebig viele weitere Ordnungen vereinbaren, muss aber für jede dieser weiteren Ordnungen eine weitere Klasse W

, W

, ... vereinbaren.

5. Comparator-Objekte aus Comparator-Objekten erzeugen

Im vorigen Abschnitt wurde gezeigt, wie man eine weitere Ordnung für eine Klasse K definieren kann, indem man eine weitere Klasse W vereinbart, die die Schnittstelle Comparator<K> implementiert und ein Objekt dieser Klasse W erzeugen lässt. Da dieses Objekt nicht nur zum Typ W gehört, sondern auch zum Typ Comaparator<K>, bezeichnet man es häufig auch als Comparator-Objekt.

In diesem Abschnitt soll gezeigt werden, dass es manchmal noch einen einfacheren Weg gibt, um eine weitere Ordnung für eine Klasse K zu definieren: Wenn man schon ein oder zwei Comparator- Objekte hat, kann man daraus (mit Methoden aus der Schnittstelle Comparator) weitere Comparator-Objekte erzeugen.

Beispiel-07: In der Klasse String gibt es schon ein (öffentliches) Comparator-Objekt namens CASE_ISENSITIVE_ORDER (siehe vorigen Abschnitt). Die compare-Methode in diesem Objekt definiert eine (groß-klein-unempfindliche) aufsteigende Ordnung. Ein Comparator-Objekt für eine entsprechende absteigende Ordnung kann man wie folgt erzeugen lassen:

public static final Comparator<String> DECREASING_CASE_INSENITIVE_ORDER = String.CASE_INSENITIVE_ORDER.reversed();

Die parameterlose Objekt-Methode reversed ist in der Schnittstelle Comparator als default- Methode vereinbart (d.h. nicht als abstrakte Methode ohne Rumpf, sondern als normale Methode mit Rumpf). Sie wird in jedes Comparator-Objekt eingebaut.

In der folgenden Klasse Person werden 5 weitere Ordnungen (für die Klasse Person) vereinbart, die ersten beiden über zwei geschachtelte Klassen (namens Class_lst und Class_fst), die übrigen mit den Methoden reversed und thenComparing aus der Schnittstelle Comparator.

Ein Objekt der Klasse Person enthält nur 2 String-Attribute namens fstName (Vorname) und lstName (Nachname).

1 // File Person.java

2 /* --- 3 This program demonstrates

4 how to define several "additional orders" (as opposed to "the natural 5 order") for a class named Person by objects of type Comparator<Person> and 6 how to use reversed() and thenComparing() (default methods of the interface 7 Comparator) to generate new Comparator objects from existing ones.

8 --- */

Beuth Hochschule Vergleichen (in Java) WS17/18, S. 9

9 import java.util.Comparator;

10 import java.util.Arrays;

11

12 public class Person {

13 // --- 14 private String fstName; // first name

15 private String lstName; // last name

16 public Person(String fstName, String lstName) { 17 this.fstName = fstName;

18 this.lstName = lstName;

19 }

20 // --- 21 // Five total orders for the class Person:

22 // cp_lst_inc last name, increasing 23 // cp_fst_inc first name, increasing 24 // cp_lst_dec last name, decreasing 25 // cp_fst_dec first name, decreasing

26 // cp_lst_fst last name, if last names are equal, then first name 27 static final Comparator<Person> cp_lst_inc = new Class_lst();

28 static final Comparator<Person> cp_fst_inc = new Class_fst();

29 static final Comparator<Person> cp_lst_dec = cp_lst_inc.reversed();

30 static final Comparator<Person> cp_fst_dec = cp_fst_inc.reversed();

31 static final Comparator<Person> cp_lst_fst = 32 cp_lst_inc.thenComparing(cp_fst_inc);

33

34 private static class Class_lst implements Comparator<Person> { 35 public int compare(Person p1, Person p2) {

36 return p1.lstName.compareTo(p2.lstName);

37 } 38 } 39

40 private static class Class_fst implements Comparator<Person> { 41 public int compare(Person p1, Person p2) {

42 return p1.fstName.compareTo(p2.fstName);

43 } 44 }

45 // --- 46 static void print(String txt, Person[] ap) {

47 // Prints the txt followed by all elements of ap:

48

49 printf("%-8s: ", txt);

50 for (Person p : ap) printf("(%s, %s) ", p.lstName, p.fstName);

51 printf("%n");

52 }

53 // --- 54 static public void main(String[] sonja) {

55 printf("Person: Here we go!%n");

56 printf("---%n");

57 Person[] ap = {

58 new Person("Ann", "Ott"), 59 new Person("Pit", "Zen"), 60 new Person("Ela", "Dix"), 61 new Person("Ann", "Zen"), 62 new Person("Pit", "Dix"), 63 new Person("Ela", "Ott"), 64 new Person("Ann", "Dix"), 65

66 };

67 print("original", ap);

68 Arrays.sort(ap, cp_lst_inc); print("lst_inc", ap);

69 Arrays.sort(ap, cp_fst_inc); print("fst_inc", ap);

70 Arrays.sort(ap, cp_lst_dec); print("lst_dec", ap);

71 Arrays.sort(ap, cp_fst_dec); print("fst_dec", ap);

72 Arrays.sort(ap, cp_lst_fst); print("lst_fst", ap);

73 printf("---%n");

74 printf("Person: That's all!%n");

75 } // main

76 // --- 77 // A method with a short name:

78 static void printf(String f, Object... v) {System.out.printf(f, v);}

79 // --- 80 } // class Person

81 /* --- 82 Output of this program:

83

84 Person: Here we go!

85 ---

86 original: (Ott, Ann) (Zen, Pit) (Dix, Ela) (Zen, Ann) (Dix, Pit) (Ott, Ela) (Dix, Ann) 87 lst_inc : (Dix, Ela) (Dix, Pit) (Dix, Ann) (Ott, Ann) (Ott, Ela) (Zen, Pit) (Zen, Ann) 88 fst_inc : (Dix, Ann) (Ott, Ann) (Zen, Ann) (Dix, Ela) (Ott, Ela) (Dix, Pit) (Zen, Pit) 89 lst_dec : (Zen, Ann) (Zen, Pit) (Ott, Ann) (Ott, Ela) (Dix, Ann) (Dix, Ela) (Dix, Pit) 90 fst_dec : (Zen, Pit) (Dix, Pit) (Ott, Ela) (Dix, Ela) (Zen, Ann) (Ott, Ann) (Dix, Ann) 91 lst_fst : (Dix, Ann) (Dix, Ela) (Dix, Pit) (Ott, Ann) (Ott, Ela) (Zen, Ann) (Zen, Pit) 92 ---

93 Person: That's all!

94 --- */