Aprils Space

Mehrfach-Vorkommnisse einer Sache sind oft etwas Nützliches, weil darin eine Information, etwa eine Regelmäßigkeit, steckt. Manchmal sind Replicas auch notwendig, um Einheitlichkeit, etwa von Banknoten, oder um Verlässlichkeit, etwa einer experimentellen Anordnung, zu garantieren. Oft sind Mehrfach-Vorkommnisse aus Sicherheitsgründen gewünscht, etwa Kopien. Und manchmal sind Duplikate auch überflüssig, es kommt dabei auf den Zusammenhang an. Meist sind Duplikate in Datenbanken nicht gewünscht, weil unentdeckte Duplikate zum Beispiel Ergebnisse verfälschen können. So wäre es etwa recht unschön, wenn Buchungssätze zur selben Angelegenheit mehrfach vorkämen.
Für Datenbanken sollte man Vorkommnisse einer Sache und Speicherstelle einer Sache unterscheiden. In einem relationalen Datenbanksystem wird ein und dieselbe Sache gewöhnlich nur ein einziges Mal gespeichert. Mehrfache Vorkommnisse der Sache werden dann in Reports dynamisch generiert. Um dieselbe Informationsmenge in anderen Arten von Datenbanken bereitzustellen, sind Mehrfach-Speicherungen derselben Sache notwendig.
Es geht hier um eine Datenbank, zu einfach für Access, nicht einfach genug und zu üppig für Word, also das Richtige für Excel. Man stelle sich Projekte vor, an welchen jeweils einige Personen teilhaben. Die Größe der Personengruppen differieren von Projekt zu Projekt, die Anzahl der Teilnehmer ist jetzt nicht wichtig. Es kommt recht häufig vor, dass eine Person an mehreren Projekten mitwirkte. Neben der Projektgruppe könnte es noch einen Projektleiter und vielleicht auch eine Art Projektdesigner geben. Natürlich können noch viele weitere Informationen in die Datenbank einfließen, etwa der Name des Projekts, sein Aufführungs- oder Realisierungsdatum, das Projekt kann auch näher charakterisiert werden durch Kategorien und Unterkategorien, das Projekt könnte ferner kostenmäßig durchleuchtet werden, etc.
Wie in der untenstehenden Abbildung zu sehen, kommt zum Beispiel der Teilnehmer aa an mehreren Stellen vor. Und da eine Excel-Zelle eine Speicherstelle ist, wird aa entsprechend mehrfach gespeichert, so viele Male wie ein Projekt vorkommt, an dem er teilnahm. Um die Zugehörigkeitsbeziehungen zwischen Teilnehmern und Projekten darzustellen, sind in Excel so viele Listen notwendig, wie es Projekte gibt. Jede Zeile stellt eine eigene Liste dar. Das würde im Datenbanksystem Access anders aussehen. Dort würden nur zwei Listen benötigt, die der Projekte und die der Teilnehmer. Während Beziehungen zwischen Objekten (hier die Zugehörigkeitsbeziehung der “Teilnahme”) in Excel ikonisch in einer Matrix dargestellt werden müssen, werden diese in Access durch die höherstufige Zeichenbeziehung der Indizierung symbolisiert. Was im Excel-Blatt unten dargestellt ist, wird in Access durch die Liste der Projekte, die Liste der Teilnehmer und eine Relation 1:n zwischen Projekt und Teilnehmer erreicht. Doch zurück zur Excel-Datenbank.
Das wichtigste sind im Augenblick diejenigen beteiligten Personen, die zu den Projektgruppen gehören. Die Excel-Datenbank, in der all diese Informationen abgelegt sind, ist typischerweise ein zweidimensionales, in Zeilen und Spalten organisiertes Gebilde. Jedes Projekt nimmt eine Zeile des Tabellenblattes ein. Die Projekte liegen bereits alphanumerisch sortiert in diesem Blatt vor. In Spalte A also der Name des Projektes, in einigen Folgespalten beliebige Informationen zum Projekt, und im Beispiel unten ab Spalte J folgen sodann die Projektteilnehmer namentlich, also für jeden Teilnehmernamen eine weitere Spalte in der Projektzeile. Da die Projektgruppen verschieden groß sind, laufen manche Projekte bis Spalte W oder gar AA, andere nur bis Spalte N oder P. Die Datenbank hat also bildlich gesagt rechts einen Flatterrand.
Anbei eine Abbildung, die die Struktur der Datenbank verdeutlicht.

Im Projekt 10010114 beispielsweise waren die Teilnehmer ka, tz, ee und nb involviert, am Projekt Alpha3 ebenfalls ka, sowie w, ll, ik und zt.

Die Menge aller Teilnehmer an allen Projekten bildet also wie oben zu sehen einen unsortierten Block, in dem Teilnehmernamen auch mehrfach vorkommen. Die Aufgabe besteht nun darin, in einem weiteren Tabellenblatt eine alphabetisch sortierte Liste von Teilnehmern ohne Duplikate zu generieren. Statt Namen mehrfach zu listen sollen die Duplikate gezählt werden und hinter die erste Inskription eines Namens ein entsprechender Zählvermerk, z.B. Peter Falk (4), gestellt werden. Die Duplikate sollen gelöscht werden. Das Ergebnis der gesamten Operation soll etwa wie folgt aussehen.

Die Informationen, die gewonnen werden sollen, sind also die Menge der an allen Projekten beteiligten Personen in alphabetischer Reihenfolge (Anzahl der Personen ist die Anzahl der Teilnehmer abzüglich der Duplikate) und die Anzahl der Teilnahmen einer jeden Person an Projekten. Um dies zu erreichen verwendet man das in Excel zur Verfügung stehende VBA. In einem ersten Schritt wird die alphabetisch sortierte Liste der Personen (also die Duplikat-freie Liste) erstellt. Anschließend kümmern wir uns um die Personennamen anzufügenden Zähleinträge bezüglich der Teilnahmen der Personen.

Alphabetische Sortierung und Eliminierung von Duplikaten

Das Programm hierzu gestaltet sich zunächst folgendermaßen:

Option Explicit
Option Base 1
‚
‚Concept, Code by april.shower
‚

Public Sub OrderingParticipants()
    Application.ScreenUpdating = False
    Worksheets(„Participants“).Cells.Clear
    Const c1 = „N.N.“
    Worksheets(„Project“).Activate
    ‚
    ‚prepairing worksheet(1)
    ‚=======================
    ‚deleting empty rows in sheet 1
    der
    ‚
    ‚determining number of at present used rows
    Dim z1 As Long
    z1 = 1
    Do Until IsEmpty(Cells(z1, 1))
        z1 = z1 + 1
    Loop
    ‚providing for a unintersected range of participants
    Dim e1 As Long
    For e1 = 1 To z1 – 1
        If IsEmpty(Cells(e1, 11)) Then
            If Cells(e1, 1).Characters.Count = 1 Then
                Cells(e1, 11).Value = Cells(e1, 1).Value
            Else
                Cells(e1, 11).Value = c1
            End If
        End If
    Next
    ‚
    ‚inserting empty row after row one (delimiting actor range from head row)
    Worksheets(„Projects“).Rows(2).Insert
    ‚
    ‚reading data into array
    ‚=======================
    ‚defining participant range in sheet >Projects<
    Dim b1 As Range
    Set b1 = Worksheets(1).Range(„K3“).CurrentRegion
    ‚
    ‚counting columns
    Dim z2 As Long
    z2 = b1.Columns.Count
    ‚reading into array
    Dim matrix1 As Variant
    matrix1 = b1.Value
    ‚
    ‚well-ordered copying from array to worksheet(2)
    ‚===============================================
    ‚array delivering sort criteria for worksheet(2)
    Dim ar1 As Variant
    ar1 = Array(„A“, „B“, „C“, „D“, „E“, „F“, „G“, „H“, „I“, „J“, „K“, „L“, „M“, „N“, „O“, „P“, „Q“, „R“, „S“, „T“, „U“, „V“, „W“, „X“, „Y“, „Z“)
    ‚
    ’sorting and transfering
    Dim e3 As Long, e4 As Long, z3 As Long, z4 As Long, z5 As Long, p1 As Long
    ‚row numerator array matrix1
    z3 = 1
    ‚column numerator array matrix1
    z4 = 1
    ‚column numerator participant worksheet
    z5 = 0
    ‚
    Do
        ‚delivering the characters as criteria from ar1-array
        z5 = z5 + 1
        ‚e4 varies colums
        For e4 = z4 To z2
            ‚e3 varies rows
            For e3 = z3 To UBound(matrix1)
                ’some don’t cares
                If Not (matrix1(e3, e4) = c1 Or IsEmpty(matrix1(e3, e4)) = True Or Len(matrix1(e3, e4)) = 1) Then
                    ‚if the kriterium >first character< matches
                    If Left(matrix1(e3, e4), 1) = ar1(z5) Then
                        ‚determining first empty row
                        p1 = 1
                        Do While Not IsEmpty(Worksheets(2).Cells(p1, z5))
                            p1 = p1 + 1
                        Loop
                        ‚copying matches to actors sheet into the next unused cell of the applicable column
                        Worksheets(2).Cells(p1, z5).Value = matrix1(e3, e4)
                    End If
                End If
            Next e3
        Next e4
    Loop Until z5 = UBound(ar1)
    ‚
    ‚fine finishing participants sheet
    ‚===========================
    ‚columns in participants table sorting alphabetically at any one time, deleting doubles, shifting up the rest of the column
    Dim z6 As Long, z7 As Long, z8 As Long, z9 As Long, z10 As Long, t1 As Long, t2 As Long, k2 As Long, sa1 As Range
    z10 = 0
    Set sa1 = Worksheets(2).Range(„A1“).CurrentRegion
    ‚denotes columns
    For z6 = 1 To z5
        ’sorting column in worksheet(2)
        sa1.Columns(z6).Sort key1:=sa1.Columns(z6), order1:=xlAscending, Header:=xlNo, ordercustom:=1, MatchCase:=False, Orientation:=xlTopToBottom
        t2 = 0
        k2 = 0
        Do Until IsEmpty(Worksheets(2).Cells(k2 + 1, z6))
            k2 = k2 + 1
        Loop
        ‚
        If k2 = 1 Then
            Worksheets(2).Cells(1, z6).Value = Worksheets(2).Cells(1, z6).Value & Space(1) & „(1)“
        ElseIf k2 > 1 Then
            For z7 = 1 To k2
                ‚adapting z7-loop to the actual number of rows of the column
                If z7 >= k2 – t2 Then
                    Exit For
                End If
                t1 = 0
                For z8 = 1 To k2
                    ‚in the case of two or more instances of a name take care of the same either capitalization or use of small initial letters
                    ’since the comparison operator >=< works ‚binary‘ by default, that is case sensitive
                    ‚as option the instruction „option compare text“ can be declared before the procedure in order to prevent case sensivity
                    If Worksheets(2).Cells(z7, z6).Value = Worksheets(2).Cells(z7 + z8, z6).Value Then
                        t1 = t1 + 1
                        t2 = t2 + 1
                    Else
                        Worksheets(2).Cells(z7, z6).Value = Worksheets(2).Cells(z7, z6).Value & Space(1) & „(“ & t1 + 1 & „)“
                        Exit For
                    End If
                Next z8
                ‚deleting doubles
                If t1 > 0 Then
                    For z9 = 1 To t1
                        ‚t1 times deleting of the z7+1 th row and shifting up the rest
                        Worksheets(2).Cells(z7 + 1, z6).Delete xlShiftUp
                    Next z9
                End If
            Next z7
        End If
        ‚count participants names
        z10 = z10 + k2 – t2
    Next z6
    ‚
    Application.ScreenUpdating = True
    ‚
    MsgBox „Updating Participants Done“ & vbCrLf & „Your Table of Participants now contains “ & z10 & “ Names“, vbApplicationModal
    ‚
End Sub
‚
Sub der()
    ‚delete empty rows
   Dim r1 As Integer, lr1 As Integer
   lr1 = Cells.SpecialCells(xlCellTypeLastCell).Row
   For r1 = lr1 To 1 Step -1
      If Application.CountA(Rows(r1)) = 0 Then
         Rows(r1).Delete
      End If
   Next r1
End Sub

Das Programm enthält eine Sub-Routine ‘der’, die lediglich Leerzeilen löscht, und eine aus drei Teilen bestehende Hauptroutine. Zunächst wird das Datenblatt in einen definierten Ausgangszustand gebracht und damit für das weitere Vorgehen geeignet präpariert. Insbesondere muss der Block der Teilnehmernamen einen ununterbrochenen Bereich bilden derart, dass er ohne weiteres in ein Array ‘matrix1’ gelesen werden kann.
Im zweiten Teil wird das Tabellenblatt ‘worksheet2’ aus dem Array ‘matrix1’ alphabetisch geordnet befüllt. Dazu liefert ein weiteres Array ‘ar1’ das alphabetische Ordnungskriterium. Das gleichzeitige Auslesen des Arrays, Sortieren zur Laufzeit und Eintragen in das neue Datenblatt geschieht durch ein vierfach geschachteltes Schleifen-Konstrukt (do, for, for, do). Ergebnis ist zunächst die spaltenmäßige alphabetische Sortierung aller Teilnehmer (natürlich losgelöst von jeder Teilnahme, also der Zuordnung zu Projekten (wie auf Blatt 1)).
Der dritte Teil führt dann eine innerspaltenmäßige Sortierung durch und überführt die entstandene Ordnung der Teilnehmer in eine Ordnung der Personen, indem die Duplikate gelöscht und eventuell noch darunter befindliche Namen entsprechend in die frei gewordenen Zellen nach oben geschoben werden. Dieses wird durch eine diesmal dreifach geschachtelte for-for-for-Schleife bewirkt. Dabei variiert die oberste for-Schleife ‘z6’ die Spalten. Die mittlere Schleife ‘z7’ hat die Aufgabe, die Personennamen zu durchlaufen und Duplikate zu löschen, und die innere Schleife ‘z8’ macht Duplikate ausfindig und zählt sie. Das z7-z8-Zusammenspiel bewirkt die Unterscheidbarkeit von Teilnehmern und bloßen Personen, indem die Duplikate durch sukzessive Vergleiche von jeweiliger Vorgängerzeile mit jeweiliger Nachfolgerzeile herausgefiltert werden.
Das Kernstück der Sache besteht also aus etwas ganz einfach Anmutendem, einem Vergleich.

Duplikate in Zählindizes ummünzen

In einem zweiten Schritt geht es nun darum, eine jede verbleibende Namensinstanz auf Basis der vorgefundenen Duplikate mit einem entsprechenden Zähleintrag, wie in dem zweiten Bild oben, zu versehen. Da die Duplikate ja bereits, zwecks Steuerung der Löschvorgänge, gezählt sind, kann das so aufwendig nicht sein. Es ist jetzt nur noch der dritte Part der Haupt-Routine zu betrachten und anscheinend muss nur die geeignete Stelle innerhalb des dreifach geschachtelten for-Konstrukts für die Anweisung zum Eintragen der Zählergebnisse ausgemacht werden. Ein schnell getaner Versuch (im Code-Teil blau markiert) brachte das Programm jedoch dazu, recht kuriose Ergebnisse bezüglich der Zähleinträge zu produzieren.
Im Falle meiner Anwendung des Programms geht es derzeit um etwa 700 Projekte und circa 2300 Namen. Die Kuriosität des Ergebnisses besteht darin, dass das Verhalten an den fehlerhaften Ergebnis-Stellen jedenfalls keiner offensichtlichen Regelmäßigkeit gehorcht. Möglicherweise ist die Datenbasis zu klein, um die Regularität zu sehen. Jedenfalls ließ die Routine gelegentlich Zähleinträge aus, und zwar stets in letzten Zeilen irgendwelcher Spalten, die ansonsten durch nichts sonderlich ausgezeichnet schienen. Weder zeigte sich eine spaltenmäßige Regelmäßigkeit, noch eine Regelmäßigkeit hinsichtlich der Anzahl von befüllten Zeilen in den betroffenen Spalten. Und es kam sogar vor, dass eine Spalte mit einer bestimmten Anzahl Zeilen in der letzten Zeile einen Zähleintrag aufwies, während eine andere Spalte mit derselben Anzahl Zeilen keinen Zähleintrag erhielt. Außerdem kam die Routine nicht zurecht mit einmaligen Vorkommnissen von Namen eines Initials. Das wurde durch die Formulierung einer Bedingung korrigiert wie sie die erste blaue Markierung zeigt.
Die Sache war Grund genug, sich ein Modell auszudenken, an welchem das Verhalten des abschließenden dritten Teils (das for-for-for-Konstrukt) der Routine kontrolliert werden kann. Das Modell sollte kompakt sein, aber auch ausreichend kritisch, um die typischerweise auftretenden Fälle zu beleuchten.

Ferner wird noch ein Fall bestehend aus der Zeilen-Folge {a, a, a, b, b, c, d, e, e, e, f, g, h, h} betrachtet.

Gehen wir beispielhaft mal einige Fälle durch, um die Funktionsweise des Konstrukts zu sehen. Die äußere for-Schleife z6 nimmt die Werte 1 bis z5 an. z5 wiederum ist ein Zähler, der sich aus dem Hochzählen der Elemente des Array ar1 ergibt, also der Literale, die das Ordnungskriterium abgeben. z6 denotiert also die Nummer der Spalte. Tritt die Routine in die Spalte ein, werden deren Zeileneinträge zunächst ebenfalls alphabetisch sortiert. Anschließend werden die Einträge der Spalte in der Variable k2 gezählt. In den Modellfällen ist k2 = 4. Die for-Schleife z7 läuft nur an, wenn es überhaupt Einträge in der Spalte z6 gibt. Zudem machte es ursprünglich Probleme, wenn es nur einen einzigen Eintrag in der Spalte gab; das wurde durch die unterschiedliche Behandlung k2=1 und k2>1 behoben. z7 denotiert die Zeilennummern der Spalte z6 und läuft bis k2. Die innere for-Schleife läuft ebenfalls bis k2 und stellt eine Art Zähler für die Nachfolgezeilen der aktuell in z7 betrachteten Zeile dar. Die Idee dabei ist, dass z8 relativ zu z7 Spalten-Abschnitte jeweils identischen Zelleninhalts sucht. z8 sucht also Duplikat-Abschnitte relativ zum jeweils aktuellen z7. Im Fall a gibt es einen solchen Abschnitt nicht, im Fall b reicht der Duplikat-Abschnitt von Zeile 2 bis Zeile 4, und im Fall c gibt es zwei jeweils einzeilige Abschnitte, die Duplikate relativ zu anderen Zeilen enthalten, nämlich die Zeile 2 und die Zeile 4.
z8 vergleicht nun den Inhalt der in z7 indizierten Zeile mit der nächsten Nachfolgezeile. Bei Identität werden t1 und t2 hochgezählt. Bei Nicht-Identität wird die z8-Schleife abgebrochen. Das ist zulässig, weil aufgrund der vorherigen alphabetischen Sortierung der Spalte nicht mit einem weiteren Duplikat relativ zu z7 an irgendeiner späteren Stelle gerechnet werden kann. Die Stelle vor diesem Abbruch per exit scheint nun geeignet, einen entsprechenden Zähleintrag entsprechend der Anzahl der mit t1 festgestellten Duplikate vorzunehmen. Ist t1 = 0, wie im Fall a so ist kein Duplikat vorhanden und der Zähleintrag lautet auf “t1 + 1”, also “(1)”. Wenn t1 = 0, wird die Bedingung für eine Löschung verfehlt und z7 zählt sich weiter und betrachtet die nächste Zeile. z8 vergleicht wiederum die dritte Zeile mit der zweiten, t1 bleibt 0, Zähleintrag in Zeile 2 wiederum (1), keine Löschung, z7 tritt in die dritte Zeile, und z8 stellt keine Übereinstimmung mit der vierten Zeile fest. Schließlich nimmt z7 den Wert 4 an. An dieser Stelle fehlt jedoch eine Nachfolgezeile mit Inhalt, den z8 mit z7 vergleichen könnte.
Ich fürchte, der Zeitpunkt, zu dem ich die Zeit hätte, nachzuprüfen, wie sich VBA verhält, wenn ein regulärer Zelleninhalt verglichen werden soll mit etwas, was ‘leere Zelle’ bedeutet, wird nie kommen. Daher sehe ich in einem solchen Vergleich der Einfachheit halber eine mögliche Fehlerquelle. Statt sich darauf verlassen, dass das VBA-Verhalten für den Zweck schon passend definiert sein wird, sollte das Programm besser von selbstdefinierten Mitteln Gebrauch machen. Daher müssen die Laufweiten der Schleifen und eventuellen sonstigen Abbruchbedingungen mal überdacht werden. Die z7-Schleife sollte nicht so viele Male laufen wie es gefüllte Zeilen in der Spalte gibt (k2 mal), sondern nur bis k2 – 1, also in den Modellfällen der Tabelle oben bis zur dritten Zeile. Denn mindestens eine jeweils nächste Zeile wird zu Vergleichszwecken in der z8-Schleife benötigt. Ebenso verhält es sich mit der Laufweite der z8-Schleife, die höchstens k2-1 mal laufen sollte, wie im Fall b augenscheinlich wird.
Nun ist es aber so, dass eventuell Zeilen gelöscht werden, nämlich wenn Duplikate vorkommen, und der Rest, so vorhanden, hochgerückt wird, so dass, aufgrund der vorherigen absoluten Festlegung der Anzahl Zeilen (k2) und der Laufweite (k2 – 1), sowohl z7 als auch z8 in eine Leerzeile laufen könnten, wodurch wiederum ein unliebsamer Verlass auf irgendwelche geeigneten Verhaltensdefinitionen von VBA nötig würde. Folglich muss neben den Laufweiten-Begrenzungen, die greifen, wenn nichts zu löschen war, mit zusätzlichen Abbruchbedingungen für die Schleifen, die dann wirken, wenn Löschungen stattfanden, gearbeitet werden. Metaphorisch gesprochen soll das gesamte Konstrukt die aufgrund seines Wirkens aktuellen Tatsachen kennen und seinen Status daran anpassen. Nachdem beispielsweise im Fall b die z8-Schleife drei Duplikate ermittelte, welche anschließend gelöscht wurden, sollte die z7-Schleife anschließend nicht noch zweimal leer weiterlaufen. Oder nehmen wir den Fall e. Hier soll z7 nicht dreimal laufen, aber auch nicht zweimal, denn wenn es dahin kommt, dass z7 die vierte Zeile betrachtet, dann folgt dahinter wiederum keine weitere Zeile, die z8 zu Vergleichszwecken heranziehen könnte. Also darf z7 im Fall e nur einmal laufen, und z8 muss drei mal laufen.
Wie geht der Fall a nun zu Ende, wenn die z7-Laufweite auf k2 – 1 angepasst wurde? z7 hat den Wert 3, z8 den Wert 1, es wird keine Übereinstimmung mit Zeile 4 festgestellt, so dass weiterhin t1 = 0 und t2 = 0 und Wechsel in den else-Zweig. Dort wird der Zähleintrag für die Zeile z7=3, nämlich “(1)”, veranlasst und die z8-Schleife per exit beendet. Eine Löschung findet nicht statt, da t1 = 0. Es folgt die next z7-Anweisung. Die z7-Schleife beginnt jedoch, da z7 den Wert 4 annähme, keinen neuen Lauf. Daher wird die Zeile 4 nicht mehr untersucht und kann auch keinen Zähleintrag erhalten. Und damit ist eine Fehlerquelle identifiziert.
Was folgt daraus? Zunächst, wenn z7 den Wert 3 und z8 den Wert 1 angenommen hat, ist der letzte mögliche Vergleich erfolgt und der Fall a vollständig durchlaufen, denn z7 (=3) + z8 (=1) = k2 (=4). Es ist lediglich so, dass aus diesem letzten Vergleich bisher nicht alle erforderlichen Konsequenzen gezogen wurden. Die Nicht-Identität von z7 und z7 + z8 bedeutet nicht nur, dass es in der Spalte nur eine Inskription von der Art, wie sie in der von z7 denotierten Zeile steht, gibt, sondern auch, und zwar unter der Voraussetzung, dass z7 + z8 = k2, dass es nur eine Inskription gibt von der Art, wie sie in der von z7 + z8 denotierten Zeile steht. Die in dieser Situation zulässige, aber bisher fehlende Konsequenz, besteht darin, wegen der Nicht-Identität von Zeile 3 und 4 nicht nur einen Zähleintrag für Zeile 3, sondern auch für Zeile 4 im else-Zweig zu veranlassen. Die Zulässigkeit hängt aber von einer zur Laufzeit erfüllten Bedingung z7 + z8 = k2 ab.
Wie wirken sich diese Korrekturen auf Fall b und c aus? Im Fall b stellt die Routine bei z7 = 1 drei Duplikate fest (t1 = 3). Bei z8 = 3 ist der Fall vollständig durchlaufen, z8 hat seine maximale Laufweite k2 – 1 erreicht, die anschließende Löschroutine entfernt die Zeilen 2 bis 4, und next z7 weist zum nächsten z7-Lauf (k2 – 1 ist hier noch nicht erreicht) an, der aufgrund der Löschungen jedoch ins Leere liefe, wenn nicht nach dem Eintritt in den z7-Lauf eine Abbruchbedingung formuliert wäre: z7 >= k2 – t2, hier also 2 >= 4 – 2. Dadurch bricht an dieser Stelle z7 ab und die Routine wendet sich der nächsten Kolumne (z6) zu, ohne dass ein Zähleintrag in der übrig gebliebenen ersten Zeile vorgenommen worden wäre. Also gibt es Fälle, in denen die Anweisung zu einem Zähleintrag sowie der Abbruch der z8-Schleife nicht erst im else-Zweig, sondern schon im if-Zweig erforderlich werden.
Wie lautet diese Bedingung? Der Grund für den Abbruch der Schleife und den Zähleintrag an dieser Stelle kann nur sein, dass z7 + z8 = k2 (und nicht dass keine weitere Übereinstimmung vorhanden ist, denn das führte in den else-Zweig). Betrachten wir daraufhin aber den Fall c. Wenn dort z7 = 1 und z8 = 1, ist die Bedingung z7 + z8 = k2 nicht erfüllt, t1 und t2 werden 1. Bei z8 = 2 wird keine Identität mehr festgestellt, im else-Zweig wird ein Zähleintrag für die erste Zeile generiert und z8 beendet. Die zweite Zeile wird gelöscht, der Rest nach oben geschoben. Bei z7 = 2 wird die vormals dritte Zeile (ein “y”) betrachtet. z8 = 1 vergleicht die neue zweite Zeile (“y”) mit der neuen dritten Zeile (“y”) und stellt Identität fest, bleibt also im if-Zweig. Aufgrund der Löschung der zweiten Zeile ist durch diesen Vergleich der Fall realiter vollständig durchlaufen. Das heißt, die Routine muss an dieser Stelle zu Ende kommen und die geforderten Zähleinträge durchführen. Die für den if-Zweig ins Auge gefasste Abbruchbedingung z7 + z8 = k2 (hier 2 + 1 = 4)  greift jedoch nicht, die Routine läuft ihrer Form wegen weiter.
Es ist klar, dass das Problem durch die Löschung von Zeilen und Neupositionierung der restlichen Zeilen entsteht. Wie ist dies zu berücksichtigen? Sehen wir uns die Verwendungs- und Wirkungsweise der Zähler t1 und  t2 an. Beide werden aus demselben Anlass hochgezählt, – ein (weiteres) Duplikat wird festgestellt -, aber verschieden verwendet. t1 soll die Duplikate innerhalb einer ununterbrochenen Serie von z8-Läufen kumulieren und damit einen Duplikat-Abschnitt definieren. Nach Verlassen der z8-Serie bestimmt t1 die Anzahl der Löschvorgänge der z7 + 1 ten Zeile. Dadurch werden alle zur aktuellen z8-Serie gehörigen Duplikat-Zeilen gelöscht und eventuell vorhandene Restzeilen entsprechend hochgerückt. Eintritt in einen weiteren z7-Lauf setzt t1 zurück, wodurch es zur Bestimmung eines anderen Duplikat-Abschnittes in einer neuen z8-Serie zur Verfügung steht. Mit dem Zurücksetzen von t1 geht aber auch Information verloren. Daher wird t2 anders verwendet. Es soll die Anzahl sämtlicher in einer Spalte vorhandenen Duplikate aller Duplikat-Serien aufsummieren. Denn diese Information ist erforderlich zur Bestimmung des gerade aktuellen Zustandes der bearbeiteten Spalte. Die Länge der Spalte ist daher nicht einfach k2, sondern muss als k2 – t2 bestimmt werden, also als Ausgangslänge abzüglich der Löschungen. Und die gesuchte Abbruchbedingung ist nicht z7 + z8 = k2, sondern z7 + z8 = k2 – t2.
Noch einmal zum Fall c. Wenn z7 = 2, hat t2 aus dem vorherigen Durchlauf von z7 den Wert 1, die zweite Zeile wurde gelöscht, der Rest hochgerückt. z8 vergleicht nun Zeile 2 mit Zeile 3 und erhöht wegen Übereinstimmung (im if-Zweig) t1 auf 1 und t2 auf 2. Der Fall ist an dieser Stelle vollständig durchlaufen, also ist der ausstehende Zähleintrag zu veranlassen und die Schleife abzubrechen. Die Bedingung für Zähleintrag und Abbruch soll nun also z7 + z8 = k2 – t2 sein. Doch diese Bedingung wird an dieser Stelle nicht erfüllt, denn 2 + 1 = 4 – 2 ist falsch. Wo liegt der Fehler? Nun, es gibt keinen Fehler (soweit ich sehe), die Überlegung ist nur noch nicht ganz zu Ende gebracht. Es muss noch berücksichtigt werden, dass ein solches Schleifen-Konstrukt ein prozessuales Gebilde ist. Und es ist für das Zutreffen eines Kriteriums von entscheidender Bedeutung, in welches Phase sich der Vorgang befindet. Es gilt also, die richtige Stelle für die Bedingung zu erraten. Sehen wir uns das Geschehen noch einmal an. In dem Zeitpunkt, in dem t2 hochgezählt wird, ist lediglich die Feststellung getroffen, dass es ein Duplikat gibt. Das ist zwar Anlass für eine Löschung und damit eine Verkürzung von k2 (k2 – n), aber die Löschung ist zu diesem Zeitpunkt noch gar nicht durchgeführt. Die Bedingung kann an dieser Stelle nicht zutreffen, insofern sie einen Vorgriff auf eine spätere Phase, in der die Löschung tatsächlich vollzogen wurde, darstellt. Der Zähleintrag und der Schleifenabbruch erfolgen, was die Länge der Spalte angeht, im Vorblick auf eine später stattfindende Löschung. Und der Umstand, dass später eine Löschung stattfinden wird und damit die Länge der Spalte wiederum abnimmt, wäre auch erst für einen neuerlichen z7-Lauf relevant (wenn er denn stattfände). Es verhält sich also so, dass erstens ein Duplikat festgestellt wird, was zweitens aber erst in einer späteren Phase gelöscht wird, so dass drittens die Länge der Spalte aktuell noch unverändert ist (weshalb an dieser Stelle realiter k2 nicht um t2 verkürzt ist). Und viertens muss die spätere tatsächliche Löschung in einem noch späteren eventuell stattfindenden z7- respektive z8-Lauf berücksichtigt werden können. Denn zu dem Zeitpunkt ist die Spalte dann tatsächlich um eine Duplikat-Serie kürzer geworden. Wie ist das zu bewerkstelligen? Nun, dazu ist ein Zähler (unten “dr” genannt) erforderlich der anders eingesetzt wird, nämlich an anderer Stelle hochzählt, eben zum Zeitpunkt des tatsächlichen Löschens, während er zum Zeitpunkt der Abfrage des Abbruch- und Zähleintrag-Kriteriums noch den Vorwert besitzt.

Der dritte Part der Hauptroutine sieht nunmehr folgendermaßen aus:

Dim z6 As Long, z7 As Long, z8 As Long, z9 As Long, z10 As Long, t1 As Long, t2 As Long, k2 As Long, dr As Long, sa1 As Range
    z9 = 0
    z10 = 0
    Set sa1 = Worksheets(2).Range(„A1“).CurrentRegion
    ‚
    For z6 = 1 To z5
        ‚anzahl tatsächlich gelöschter zeilen zu beginn jeder neuen kolummne null setzen
        dr = 0
        ‚
        ’sorting column in worksheet(2)
        sa1.Columns(z6).Sort key1:=sa1.Columns(z6), order1:=xlAscending, Header:=xlNo, ordercustom:=1, MatchCase:=False, Orientation:=xlTopToBottom
        t2 = 0
        t1 = 0
        k2 = 0
        ‚last used row of a column
        Do Until IsEmpty(Worksheets(2).Cells(k2 + 1, z6))
            k2 = k2 + 1
        Loop
        ‚
        If k2 = 1 Then
            Worksheets(2).Cells(1, z6).Value = Worksheets(2).Cells(1, z6).Value & Space(1) & „(1)“
        ElseIf k2 > 1 Then
            For z7 = 1 To k2 – 1
                If z7 >= k2 – dr Then
                    Exit For
                End If
                t1 = 0
                ‚
                for z8 = 1 to k2 – 1
                    If Worksheets(2).Cells(z7, z6).Value = Worksheets(2).Cells(z7 + z8, z6).Value Then
                        t1 = t1 + 1
                        t2 = t2 + 1
                        ‚
                        if z7 + z8 = k2 – dr then
                            Worksheets(2).Cells(z7, z6).Value = Worksheets(2).Cells(z7, z6).Value & Space(1) & „(“ & t1 + 1 & „)“
                            exit for
                        end if
                    Else
                        Worksheets(2).Cells(z7, z6).Value = Worksheets(2).Cells(z7, z6).Value & Space(1) & „(“ & t1 + 1 & „)“
                        ‚
                        if z8 = k2 – z7 – dr then
                            Worksheets(2).Cells(z7 + z8, z6).Value = Worksheets(2).Cells(z7 + z8, z6).Value & Space(1) & „(1)“
                        end if
                        Exit For
                    End If
                Next z8
                ‚gathering doubles and deleting, shifting up the rest
                If t1 > 0 Then
                    ‚wenn es mindestens eine Nachfolgezelle gleichen Inhalts gibt
                    For z9 = 1 To t1
                        Worksheets(2).Cells(z7 + 1, z6).Delete xlShiftUp
                        ‚zählt anzahl tatsächlich gelöschter zeilen hoch
                        dr = dr + 1
                    Next z9
                End If
            Next z7
            End If
        ‚count actor names
        z10 = z10 + k2 – t2
    Next z6

Das Durchspielen der Zeilen-Folge {a, a, a, b, b, c, d, e, e, e, f, g, h, h} muss hier jetzt nicht mehr vorgeführt werden. Der neue Code bearbeitet auch dieses Beispiel entsprechend den Anforderungen. Wer trotzdem eine Unzulänglichkeit findet, mag das gerne zur Kenntnis bringen.