Übungsaufgaben zu Zeichenketten und Prüfziffern

Übungsaufgaben zu Zeichenketten und Prüfziffern

https://bildung.social/@oerinformatik/

https://oer-informatik.de/zeichenketten-pruefziffern-uebungsaufgaben

Zeichenketten, Prüfziffer, GTIN, Luhn-Algorithmus, Modulo 97, Leitweg-ID, Lauflängenkodierung, Pseudocode, Struktogramm, Übungsaufgaben, Prüfungsvorbereitung

tl/dr; (Bearbeitungszeit insgesamt 87 min, mehrere Aufgaben): Zwei umfangreiche Übungsaufgaben zu Algorithmen über Zeichenketten: Prüfziffern nach GS1, Luhn und Modulo 97 berechnen, prüfen und berichtigen, große Zahlen schrittweise rechnen, Codes zerlegen und zusammensetzen, eindeutige Zufallscodes mit Prüfzeichen erzeugen, Lauflängenkodierung samt Mehrdeutigkeiten und gemischte Ausdrücke aus Text und Zahl. Alle Lösungen sind ausgeblendet und mit Punkteverteilung versehen [AI-Assisted]. (Zuletzt geändert am 29.10.2026)

Diese Übungsaufgaben gehören zum Artikel Zeichenketten und Prüfziffern: Algorithmen für Codes, Nummern und Texte. Er erklärt die Pseudocode-Operationen für Zeichenketten, die hier verwendet werden. Die Grundmuster (Durchlaufen, Summieren, Maximum, Suche) findest Du im Artikel Prozedurale Algorithmen mit Arrays.

Hinweise zur Bearbeitung: Von FIA wird erwartet, dass ihnen Aufgaben auf Profilkompetenz-Ebene (Aufgabe 3.1 und Aufgabe 3.2) keine Probleme bereiten. Wenn nichts anderes verlangt ist, darfst Du Deine Algorithmen in Pseudocode, als Struktogramm oder als Programmablaufplan angeben. Arrays und Zeichenketten beginnen mit dem Index 0, Variablen musst Du nicht deklarieren. Zur Verfügung stehen in allen Teilaufgaben:

Die Beispiellösungen verwenden die Schreibweise aus dem Artikel (:= für die Zuweisung, = und <> für Vergleiche, mod für den Rest, & für die Verkettung). Andere korrekte Lösungen sind ebenfalls richtig. Schreib Deine Lösung zuerst vollständig auf, bevor Du die Beispiellösung aufklappst.

Die Codebeispiele kannst Du in vier Notationen anzeigen. Die Notationen sind im Artikel Algorithmen mit Pseudocode dokumentieren beschrieben.

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

int anzahl = 0

anzahl: integer := 0

anzahl: integer := 0

anzahl = 0

Du möchtest eigene Aufgaben zum Üben von einem KI-Sprachmodell generieren lassen? Prompt ein-/ausblenden

Erstelle neue Übungsaufgaben zum Thema „Zeichenketten und Prüfziffern“.

Bauplan: Halte Dich an Aufbau, Kompetenzstufen, Operatoren,
Anforderungsbereiche, Punkte und Zeitschätzung, die im Artikel
https://oer-informatik.de/aufgaben-aufbau beschrieben sind.

Fachliche Grundlage:
- https://oer-informatik.de/zeichenketten-pruefziffern
- https://oer-informatik.de/algorithmen-prozedural
- https://oer-informatik.de/pseudocode
- https://oer-informatik.de/programmentwurfstechniken
- Stilbeispiel: https://oer-informatik.de/zeichenketten-pruefziffern-uebungsaufgaben

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- Zeichenketten
- Prüfziffer
- GTIN
- Luhn-Algorithmus
- Modulo 97
- Leitweg-ID
- Lauflängenkodierung
- Pseudocode
- Struktogramm

Kompetenzstufe: Profilkompetenz (alternativ: Basiskompetenz, Kernkompetenz, Expertise)
Anzahl: 1 Aufgabe mit Teilaufgaben
Bearbeitungszeit in Minuten ca.: <5 bis 30 min>
Szenario: eines der Szenarien aus dem Bauplan

Vorgehen:
1. Lies zuerst die verlinkten Artikel. Kannst Du keine Webseiten
   abrufen, sag mir das, statt zu raten.
2. Steht bei einer Angabe noch ein Platzhalter in <…>, frag mich
   zuerst danach. Richte Punkte und Zahl der Teilaufgaben nach der
   Bearbeitungszeit (ca. 0,9 min je Punkt).
3. Gib je Aufgabe Titel mit Kompetenzstufe, Ausgangssituation und
   Teilaufgaben mit Operator und Punktzahl aus, dazu die geschätzte
   Bearbeitungszeit.
4. Gib die Beispiellösungen mit Punkteverteilung erst aus, wenn ich
   danach frage.

Aufgabe 3.1: Nummern prüfen im Fahrrad-Onlineshop (Profilkompetenz)

(ca. 50 min Bearbeitungszeit)

Du bist Auszubildende*r im Entwicklungsteam der CSB-Rad GmbH in Bielefeld. Cem Sarıkaya, Geschäftsführer Technik und IT, leitet das Projekt „Lager 4.0“: Lagerplätze und Artikel bekommen Barcode-Etiketten, die mit Handscannern gelesen werden. Gleichzeitig häufen sich Fehler bei Nummern, die Kund*innen oder Beschäftigte von Hand eingeben. Du sollst zusammen mit Jonas, Deinem Mit-Azubi, mehrere Prüffunktionen für das Shop-Backend entwickeln.

a) Für Artikel ohne Herstellerbarcode druckt CSB-Rad eigene 13-stellige Nummern im GTIN-Format. Sie beginnen mit 29 (Nummernbereich für den internen Gebrauch), es folgen die fünfstellige Artikel-ID, eine fünfstellige Variantennummer und die Prüfziffer. Die Prüfziffer wird nach GS1 berechnet:

• Die Ziffern werden von rechts beginnend abwechselnd mit 3 und 1 gewichtet; die Ziffer direkt links neben der Prüfziffer hat das Gewicht 3.

• Die Produkte werden addiert.

• Die Prüfziffer ergänzt die Summe zum nächsten Vielfachen von 10 (ist die Summe bereits ein Vielfaches von 10, ist die Prüfziffer 0).

aa) Berechne die Prüfziffer für die Bremse BRE-HYD-01 (Artikel-ID 8) in der Variante 412, also für die Ziffernfolge 290000800412. Stelle Deinen Rechenweg in einer Tabelle dar. (3 Punkte)

ab) Erstelle eine Funktion pruefzifferGs1(ziffern: integer[]): integer, die für ein Array beliebiger Länge mit den Ziffern ohne Prüfziffer die Prüfziffer nach GS1 berechnet und zurückgibt. Die Funktion soll auch für Sendungsnummern mit 17 Ziffern funktionieren. (6 Punkte)

int pruefzifferGs1(int ziffern[]) {
    int n = length(ziffern)
    int summe = 0
    for (int i = 0 … n-1) {
        if ((n - 1 - i) % 2 == 0) {            // gerader Abstand zum rechten Ende
            summe = summe + ziffern[i] * 3
        } else {
            summe = summe + ziffern[i]
        }
    }
    return (10 - summe % 10) % 10
}

FUNCTION pruefzifferGs1(ziffern: array of integer) : integer
    n: integer := length(ziffern)
    summe: integer := 0
    for i := 0 to n - 1 do
        if ((n - 1 - i) mod 2 = 0) then        // gerader Abstand zum rechten Ende
            summe := summe + ziffern[i] * 3
        else
            summe := summe + ziffern[i]
        end if
    end for
    RETURN (10 - summe mod 10) mod 10
END pruefzifferGs1

Funktion pruefzifferGs1(ziffern: integer[]): integer
    n: integer := laenge(ziffern)
    summe: integer := 0
    zähle i von 0 bis n - 1
        wenn (n - 1 - i) mod 2 = 0 dann        // gerader Abstand zum rechten Ende
            summe := summe + ziffern[i] * 3
        sonst
            summe := summe + ziffern[i]
        Ende wenn
    Ende zähle
    Rückgabe (10 - summe mod 10) mod 10
Ende pruefzifferGs1

def pruefzifferGs1(ziffern):
    n = len(ziffern)
    summe = 0
    for i in range(n):
        if (n - 1 - i) % 2 == 0:               # gerader Abstand zum rechten Ende
            summe = summe + ziffern[i] * 3
        else:
            summe = summe + ziffern[i]
        # Ende if
    # Ende for
    return (10 - summe % 10) % 10
# Ende pruefzifferGs1

ac) Erstelle eine Funktion istGueltigeGtin(code: string): boolean, die eine gescannte Nummer prüft. Sie gibt nur dann wahr zurück, wenn der Code genau 13 Zeichen lang ist, nur aus Ziffern besteht und die letzte Ziffer der Prüfziffer entspricht, die Deine Funktion aus ab) für die ersten 12 Ziffern berechnet. (6 Punkte)

boolean istGueltigeGtin(String code) {
    if (strLen(code) != 13) {
        return false
    }
    int ziffern[12]
    for (int i = 0 … 12) {
        if (!istZiffer(code[i])) {
            return false
        }
        if (i < 12) {
            ziffern[i] = ziffernwert(code[i])
        }
    }
    return pruefzifferGs1(ziffern) == ziffernwert(code[12])
}

FUNCTION istGueltigeGtin(code: String) : boolean
    if (length(code) <> 13) then
        RETURN false
    end if
    ziffern: array [0..11] of integer
    for i := 0 to 12 do
        if (NOT istZiffer(code[i])) then
            RETURN false
        end if
        if (i < 12) then
            ziffern[i] := ziffernwert(code[i])
        end if
    end for
    RETURN pruefzifferGs1(ziffern) = ziffernwert(code[12])
END istGueltigeGtin

Funktion istGueltigeGtin(code: string): boolean
    wenn laenge(code) <> 13 dann
        Rückgabe false
    Ende wenn
    ziffern: integer[12]
    zähle i von 0 bis 12
        wenn nicht istZiffer(code[i]) dann
            Rückgabe false
        Ende wenn
        wenn i < 12 dann
            ziffern[i] := ziffernwert(code[i])
        Ende wenn
    Ende zähle
    Rückgabe pruefzifferGs1(ziffern) = ziffernwert(code[12])
Ende istGueltigeGtin

def istGueltigeGtin(code):
    if len(code) != 13:
        return False
    # Ende if
    ziffern = [0] * 12
    for i in range(13):
        if not istZiffer(code[i]):
            return False
        # Ende if
        if i < 12:
            ziffern[i] = ziffernwert(code[i])
        # Ende if
    # Ende for
    return pruefzifferGs1(ziffern) == ziffernwert(code[12])
# Ende istGueltigeGtin

b) Mira Engel, Kundin der Bestellung 3, meldet, dass die Sendungsverfolgung ihre Nummer nicht kennt. Im Shop steht die Sendungsnummer 00340434160000123456. Sie besteht aus dem Datenbezeichner 00 und der 18-stelligen Nummer der Versandeinheit (SSCC), deren letzte Ziffer die Prüfziffer nach GS1 ist (Verfahren wie in a).

ba) Überprüfe die Sendungsnummer, berichtige sie gegebenenfalls und begründe Dein Ergebnis. (4 Punkte)

bb) Die Handscanner liefern die Sendungsnummer als Zeichenkette mit 20 Zeichen. Beschreibe, wie Du mit den vorgegebenen Funktionen und pruefzifferGs1 prüfst, ob die enthaltene SSCC gültig ist. (2 Punkte)

c) Natalia Wróbel aus der Buchhaltung schickt die Rechnungen an den Zweckverband Radwege OWL als XRechnung. Das Rechnungsportal des Zweckverbands hat die letzte Rechnung mit der Meldung „Leitweg-ID ungültig“ abgewiesen. Im Kundenstamm steht die Leitweg-ID 05711000-ZVRAD-63.

Für die Prüfung der Leitweg-ID gilt (Verfahren ISO 7064 MOD 97-10):

• Die Bindestriche werden entfernt, jeder Buchstabe wird durch seinen Wert ersetzt (A = 10, B = 11, …, Z = 35, Groß- und Kleinschreibung egal).

• Die entstehende Ziffernfolge wird als ganze Zahl gelesen.

• Die Leitweg-ID ist gültig, wenn diese Zahl geteilt durch 97 den Rest 1 lässt.

Die Zahl ist zu lang für jeden Ganzzahl-Datentyp. Den Rest kannst Du aber schrittweise berechnen: Für jede Ziffer wird rest := (rest * 10 + ziffer) mod 97 gerechnet, für jeden Buchstaben (der für zwei Ziffern steht) rest := (rest * 100 + wert) mod 97.

ca) Beschreibe, warum die Leitweg-ID nicht einfach mit einer Umwandlungsfunktion in eine Ganzzahl umgewandelt und dann durch 97 geteilt werden kann, und warum das schrittweise Verfahren trotzdem den richtigen Rest liefert. (2 Punkte)

cb) Entwickle eine Funktion pruefeLeitwegId(id: string): boolean, die eine Leitweg-ID nach dem Verfahren oben prüft. Bindestriche werden übersprungen. Enthält die ID ein anderes Zeichen als Ziffer, Buchstabe oder Bindestrich, gibt die Funktion falsch zurück. (8 Punkte)

boolean pruefeLeitwegId(String id) {
    int rest = 0
    for (int i = 0 … strLen(id)-1) {
        char c = id[i]
        if (istZiffer(c)) {
            rest = (rest * 10 + ziffernwert(c)) % 97
        } else {
            if (istBuchstabe(c)) {
                rest = (rest * 100 + ziffernwert(c)) % 97
            } else {
                if (c != '-') {
                    return false             // unzulässiges Zeichen
                }
            }
        }
    }
    return rest == 1
}

FUNCTION pruefeLeitwegId(id: String) : boolean
    rest: integer := 0
    for i := 0 to length(id) - 1 do
        c: char := id[i]
        if (istZiffer(c)) then
            rest := (rest * 10 + ziffernwert(c)) mod 97
        else
            if (istBuchstabe(c)) then
                rest := (rest * 100 + ziffernwert(c)) mod 97
            else
                if (c <> '-') then
                    RETURN false             // unzulässiges Zeichen
                end if
            end if
        end if
    end for
    RETURN rest = 1
END pruefeLeitwegId

Funktion pruefeLeitwegId(id: string): boolean
    rest: integer := 0
    zähle i von 0 bis laenge(id) - 1
        c: char := id[i]
        wenn istZiffer(c) dann
            rest := (rest * 10 + ziffernwert(c)) mod 97
        sonst
            wenn istBuchstabe(c) dann
                rest := (rest * 100 + ziffernwert(c)) mod 97
            sonst
                wenn c <> '-' dann
                    Rückgabe false           // unzulässiges Zeichen
                Ende wenn
            Ende wenn
        Ende wenn
    Ende zähle
    Rückgabe rest = 1
Ende pruefeLeitwegId

def pruefeLeitwegId(id):
    rest = 0
    for i in range(len(id)):
        c = id[i]
        if istZiffer(c):
            rest = (rest * 10 + ziffernwert(c)) % 97
        else:
            if istBuchstabe(c):
                rest = (rest * 100 + ziffernwert(c)) % 97
            else:
                if c != '-':
                    return False             # unzulässiges Zeichen
                # Ende if
            # Ende if
        # Ende if
    # Ende for
    return rest == 1
# Ende pruefeLeitwegId

cc) Deine Funktion ermittelt für 05711000-ZVRAD-63 den Rest 48. Ermittle daraus ohne erneuten Durchlauf durch alle Zeichen, welche zweistellige Prüfziffer richtig wäre, und begründe Dein Vorgehen. (3 Punkte)

d) Ab Januar 2027 bekommt jedes Fahrrad nach der ersten Inspektion in der Werkstatt Sennestadt eine zehnstellige Servicenummer, die Kund*innen im Werkstattportal eingeben. Die letzte Ziffer ist eine Prüfziffer nach dem Luhn-Verfahren:

• Von rechts beginnend wird jede zweite Ziffer verdoppelt, beginnend mit der Ziffer links neben der Prüfziffer.

• Ist ein verdoppelter Wert größer als 9, wird seine Quersumme verwendet.

• Alle Werte werden addiert. Die Summe wird auf die nächstgrößere durch 10 teilbare Zahl aufgerundet (ist sie schon durch 10 teilbar, bleibt sie). Die Prüfziffer ist die Differenz zwischen aufgerundetem Wert und Summe.

Jonas hat dazu folgende Funktion geschrieben:

Funktion pruefeServicenummer(nr: string): boolean
    summe := 0
    zähle i von 0 bis laenge(nr) - 2
        z := ziffernwert(nr[i])
        wenn i mod 2 = 0 dann
            z := z * 2
            wenn z > 9 dann
                z := z - 10
            Ende wenn
        Ende wenn
        summe := summe + z
    Ende zähle
    pz := 10 - summe mod 10
    Rückgabe pz = ziffernwert(nr[laenge(nr) - 1])
Ende pruefeServicenummer

da) Ermittle mit einem Schreibtischtest für die Servicenummer 3057182648 die Werte von z und summe nach jedem Schleifendurchlauf sowie den Rückgabewert der Funktion. Gib an, ob die Nummer nach der Vorschrift gültig ist. (3 Punkte)

db) Nenne die beiden Fehler in Jonas’ Funktion und korrigiere sie. Gib außerdem an, unter welcher Voraussetzung die Bedingung i mod 2 = 0 die richtigen Ziffern verdoppelt. (5 Punkte)

    int aufgerundet = summe
    if (summe % 10 != 0) {
        aufgerundet = summe + 10 - summe % 10
    }
    int pz = aufgerundet - summe

    aufgerundet: integer := summe
    if (summe mod 10 <> 0) then
        aufgerundet := summe + 10 - summe mod 10
    end if
    pz: integer := aufgerundet - summe

    aufgerundet: integer := summe
    wenn summe mod 10 <> 0 dann
        aufgerundet := summe + 10 - summe mod 10
    Ende wenn
    pz: integer := aufgerundet - summe

    aufgerundet = summe
    if summe % 10 != 0:
        aufgerundet = summe + 10 - summe % 10
    # Ende if
    pz = aufgerundet - summe

dc) Sophie Bertram fragt, ob das Werkstattportal mit der Prüfung der Servicenummer schon sicherstellt, dass ein Fahrrad mit dieser Nummer existiert. Begründe Deine Antwort. (2 Punkte)

e) Die Lipper SchließTec KG vergibt für gleichschließende Schlösser Schließungscodes wie VS-7Q4K2M9. Mit dem Code können Schlüssel nachbestellt werden; Birgit Haas, Vertriebsleiterin bei SchließTec, bittet deshalb darum, die Codes vertraulich zu behandeln. Jonas schlägt vor, an jeden Code ein Prüfzeichen anzuhängen, „damit sich niemand einen Code ausdenken und Schlüssel für fremde Schlösser bestellen kann“. Nimm Stellung zu diesem Vorschlag. (3 Punkte)

f) Im Projekt „Lager 4.0“ bekommt jeder Lagerplatz ein Etikett. Die Lagerplätze stehen im zweidimensionalen Array lager: int[][]; jede Zeile ist ein Lagerplatz mit den Spalten 0 = Regal (1 bis 40), 1 = Ebene (1 bis 6), 2 = Fach (1 bis 30), 3 = Artikel-ID, 4 = Bestand. Ausschnitt:

Für die Entnahme soll der Handscanner anzeigen, an welchem Lagerplatz ein Artikel am meisten Bestand hat. Der Lagerplatz wird als Zeichenkette im Format R07-E2-F05 angegeben: R, zweistellige Regalnummer, -E, Ebene, -F, zweistellige Fachnummer.

Erstelle eine Funktion lagerplatzText(lager: integer[][], artikelId: integer): string, die den Lagerplatz mit dem höchsten Bestand des Artikels in diesem Format zurückgibt. Liegt der Artikel an keinem Lagerplatz, gibt sie eine leere Zeichenkette zurück. Bei gleichem Bestand genügt der erste Lagerplatz. (8 Punkte)

String lagerplatzText(int lager[,], int artikelId) {
    int maxBestand = -1
    int pos = -1
    for (int i = 0 … length(lager)-1) {
        if (lager[i, 3] == artikelId && lager[i, 4] > maxBestand) {
            maxBestand = lager[i, 4]
            pos = i
        }
    }
    if (pos == -1) {
        return ""
    }
    return "R" + zweistellig(lager[pos, 0]) + "-E" + zuText(lager[pos, 1]) + "-F" + zweistellig(lager[pos, 2])
}

String zweistellig(int zahl) {
    if (zahl < 10) {
        return "0" + zuText(zahl)
    }
    return zuText(zahl)
}

FUNCTION lagerplatzText(lager: array of array of integer, artikelId: integer) : String
    maxBestand: integer := -1
    pos: integer := -1
    for i := 0 to length(lager) - 1 do
        if (lager[i, 3] = artikelId) AND (lager[i, 4] > maxBestand) then
            maxBestand := lager[i, 4]
            pos := i
        end if
    end for
    if (pos = -1) then
        RETURN ""
    end if
    RETURN "R" & zweistellig(lager[pos, 0]) & "-E" & zuText(lager[pos, 1]) & "-F" & zweistellig(lager[pos, 2])
END lagerplatzText

FUNCTION zweistellig(zahl: integer) : String
    if (zahl < 10) then
        RETURN "0" & zuText(zahl)
    end if
    RETURN zuText(zahl)
END zweistellig

Funktion lagerplatzText(lager: integer[][], artikelId: integer): string
    maxBestand: integer := -1
    pos: integer := -1
    zähle i von 0 bis laenge(lager) - 1
        wenn lager[i][3] = artikelId und lager[i][4] > maxBestand dann
            maxBestand := lager[i][4]
            pos := i
        Ende wenn
    Ende zähle
    wenn pos = -1 dann
        Rückgabe ""
    Ende wenn
    Rückgabe "R" & zweistellig(lager[pos][0]) & "-E" & zuText(lager[pos][1]) & "-F" & zweistellig(lager[pos][2])
Ende lagerplatzText

Funktion zweistellig(zahl: integer): string
    wenn zahl < 10 dann
        Rückgabe "0" & zuText(zahl)
    Ende wenn
    Rückgabe zuText(zahl)
Ende zweistellig

def lagerplatzText(lager, artikelId):
    maxBestand = -1
    pos = -1
    for i in range(len(lager)):
        if lager[i][3] == artikelId and lager[i][4] > maxBestand:
            maxBestand = lager[i][4]
            pos = i
        # Ende if
    # Ende for
    if pos == -1:
        return ""
    # Ende if
    return "R" + zweistellig(lager[pos][0]) + "-E" + zuText(lager[pos][1]) + "-F" + zweistellig(lager[pos][2])
# Ende lagerplatzText

def zweistellig(zahl):
    if zahl < 10:
        return "0" + zuText(zahl)
    # Ende if
    return zuText(zahl)
# Ende zweistellig

Aufgabe 3.2: Badges und Türschilder für das Barcamp (Profilkompetenz)

(ca. 37 min Bearbeitungszeit)

Du bist Auszubildende*r und gehörst zum Orga-Team des Barcamps „Lernen.Digital.Leben 2027“, das am Samstag, 13.03.2027, am Ratz und Rübe Berufskolleg (RRB) in Bielefeld stattfindet. Dimitrios Papadopoulos, der die Organisation leitet, hat Dir die Weiterentwicklung der Software für Badges und Türschilder übertragen. Mia Schröder (Azubi FIA im 3. Lehrjahr) und Emre Aksoy aus dem Technikteam arbeiten mit Dir zusammen.

a) Bisher bestehen die Badge-Codes aus BC27, einem Buchstaben für die Ticketart (z. B. R für Referent*in, S für Schüler*in) und der dreistelligen Anmeldenummer, etwa BC27R005. Weil man daraus die Codes anderer Teilnehmender erraten kann, bekommt jede Person künftig einen Code aus sieben Zeichen der Zeichenkette ALPHABET = "ACDEFHJKMNPRTUVWXY34679". Diese 23 Zeichen lassen sich auf Badge und Bildschirm kaum verwechseln; der Wert eines Zeichens ist sein Index in ALPHABET ('A' = 0, 'C' = 1, …, '9' = 22).

Die ersten sechs Zeichen werden zufällig gewählt, das siebte ist ein Prüfzeichen. Das Check-in-Terminal erkennt einen gültigen Code so: Es gewichtet die Werte der sieben Zeichen von links nach rechts mit 7, 6, 5, 4, 3, 2 und 1, addiert die Produkte, und die Summe muss durch 23 teilbar sein. Beim Erzeugen wird das Prüfzeichen deshalb so gewählt, dass es die gewichtete Summe der ersten sechs Zeichen zum nächsten Vielfachen von 23 ergänzt: Es hat den Wert (23 - summe mod 23) mod 23.

Beispiel: Für MW3FAY mit den Werten 8, 15, 18, 4, 0, 17 ergibt sich 7 · 8 + 6 · 15 + 5 · 18 + 4 · 4 + 3 · 0 + 2 · 17 = 286, 286 mod 23 = 10, Prüfzeichen hat den Wert 13, also 'U'. Der Code lautet MW3FAYU; das Terminal rechnet 286 + 1 · 13 = 299 = 13 · 23.

Die bereits vergebenen Codes verwaltet der Check-in-Server in einer Menge vergeben (entspricht Set<String> in Java bzw. set in Python) mit den Methoden enthaelt(code: string): boolean und hinzufuegen(code: string). Außerdem steht zufallszahl(von: integer, bis: integer): integer zur Verfügung; sie liefert eine ganze Zufallszahl von von bis einschließlich bis.

Mia hat einen ersten Entwurf geschrieben:

Funktion erzeugeBadgeCode(vergeben: Menge): string
    code := ""
    summe := 0
    wiederhole
        zähle i von 0 bis 5
            wert := zufallszahl(0, laenge(ALPHABET))
            code := code & ALPHABET[wert]
            summe := summe + (7 - i) * wert
        Ende zähle
        code := code & ALPHABET[summe mod 23]
    solange vergeben.enthaelt(code)
    Rückgabe code
Ende erzeugeBadgeCode

aa) Mias Entwurf enthält vier Fehler. Benenne sie und beschreibe jeweils, was beim Barcamp-Check-in passieren würde. (4 Punkte)

ab) Dimitrios möchte außerdem verhindern, dass das Programm bei fast vollem Nummernraum endlos weitersucht. Stelle die korrigierte Funktion erzeugeBadgeCode(vergeben: Menge): string als Struktogramm dar. Sie bricht nach höchstens 50 Versuchen ab und gibt dann eine leere Zeichenkette zurück; einen gefundenen Code nimmt sie in vergeben auf. (8 Punkte)

Als Pseudocode:

JANA Pseudo-Pascal Pseudo-Pascal (deutsch) Pseudo-Python all none

String erzeugeBadgeCode(Menge vergeben) {
    String code = ""
    int versuche = 0
    repeat {
        code = ""
        int summe = 0
        for (int i = 0 … 5) {
            int wert = zufallszahl(0, strLen(ALPHABET) - 1)
            code = code + ALPHABET[wert]
            summe = summe + (7 - i) * wert
        }
        code = code + ALPHABET[(23 - summe % 23) % 23]
        versuche = versuche + 1
    } until (!vergeben.enthaelt(code) || versuche >= 50)
    if (vergeben.enthaelt(code)) {
        return ""
    }
    vergeben.hinzufuegen(code)
    return code
}

FUNCTION erzeugeBadgeCode(vergeben: Menge) : String
    code: String := ""
    versuche: integer := 0
    repeat
        code := ""
        summe: integer := 0
        for i := 0 to 5 do
            wert: integer := zufallszahl(0, length(ALPHABET) - 1)
            code := code & ALPHABET[wert]
            summe := summe + (7 - i) * wert
        end for
        code := code & ALPHABET[(23 - summe mod 23) mod 23]
        versuche := versuche + 1
    until (NOT vergeben.enthaelt(code)) OR (versuche >= 50)
    if (vergeben.enthaelt(code)) then
        RETURN ""
    end if
    vergeben.hinzufuegen(code)
    RETURN code
END erzeugeBadgeCode

Funktion erzeugeBadgeCode(vergeben: Menge): string
    code: string := ""
    versuche: integer := 0
    wiederhole
        code := ""
        summe: integer := 0
        zähle i von 0 bis 5
            wert: integer := zufallszahl(0, laenge(ALPHABET) - 1)
            code := code & ALPHABET[wert]
            summe := summe + (7 - i) * wert
        Ende zähle
        code := code & ALPHABET[(23 - summe mod 23) mod 23]
        versuche := versuche + 1
    solange vergeben.enthaelt(code) und versuche < 50
    wenn vergeben.enthaelt(code) dann
        Rückgabe ""
    Ende wenn
    vergeben.hinzufuegen(code)
    Rückgabe code
Ende erzeugeBadgeCode

def erzeugeBadgeCode(vergeben):
    code = ""
    versuche = 0
    do:
        code = ""
        summe = 0
        for i in range(6):
            wert = zufallszahl(0, len(ALPHABET) - 1)
            code = code + ALPHABET[wert]
            summe = summe + (7 - i) * wert
        # Ende for
        code = code + ALPHABET[(23 - summe % 23) % 23]
        versuche = versuche + 1
    while (vergeben.enthaelt(code) and versuche < 50)
    if vergeben.enthaelt(code):
        return ""
    # Ende if
    vergeben.hinzufuegen(code)
    return code
# Ende erzeugeBadgeCode

Ebenfalls richtig: eine kopfgesteuerte Schleife mit einer Variablen gefunden oder ein vorzeitiges Rückgabe code innerhalb einer Zählschleife über die 50 Versuche.

Bewertung:

• Wiederholung mit beiden Bedingungen (Code vergeben und weniger als 50 Versuche) 2 Punkte,

• code und summe innerhalb der Wiederholung zurücksetzen, Versuche zählen 1 Punkt,

• Zufallsindex im Bereich 0 bis 22, Zeichen über den Index 1 Punkt,

• gewichtete Summe mit Gewicht 7 - i 1 Punkt,

• Prüfzeichen als Ergänzung (23 - summe mod 23) mod 23 1 Punkt,

• nach der Schleife unterscheiden: leere Zeichenkette oder Code aufnehmen und zurückgeben 1 Punkt,

• formal korrektes Struktogramm (DIN 66261) 1 Punkt.

ac) Emre fragt, wozu der Aufwand gut ist. Begründe kurz, warum die Codes nicht mehr fortlaufend nummeriert werden, warum ein eigenes Alphabet verwendet wird und was das Prüfzeichen leistet – und was nicht. (3 Punkte)

b) Die zwölf E-Ink-Türschilder bekommen ihre Anzeige per MQTT vom Info-Server. Das Schwarz-Weiß-Display ist 800 Pixel breit. Im Prototyp überträgt Emre jede Bildzeile als Zeichenkette aus 'W' (weißes Pixel) und 'S' (schwarzes Pixel). Weil es nur zwei Farben gibt, schlägt er eine Lauflängenkodierung vor, die gar keine Zeichen speichert, sondern nur die Längen der Läufe:

• Die Läufe wechseln sich ab; der erste Lauf ist immer weiß.

• Die Längen werden als Dezimalzahlen, durch Kommas getrennt, übertragen.

• Beginnt eine Zeile mit einem schwarzen Pixel, ist die erste Länge 0.

Beispiel: WWWWSSSSSSSWWWWWWWWWWWWS (24 Zeichen) wird zu 4,7,12,1 (8 Zeichen).

ba) Kodiere von Hand die Zeilen SSSWWWWWSWW und WSWSWSWS. Beurteile anhand Deiner Ergebnisse, für welche Bildinhalte sich die Kodierung lohnt. (3 Punkte)

bb) Entwickle eine Funktion kodiere(zeile: string): string, die eine Bildzeile nach dieser Vorschrift kodiert. (8 Punkte)

String kodiere(String zeile) {
    String ergebnis = ""
    char farbe = 'W'
    int anzahl = 0
    for (int i = 0 … strLen(zeile)-1) {
        if (zeile[i] == farbe) {
            anzahl = anzahl + 1
        } else {
            ergebnis = ergebnis + zuText(anzahl) + ","
            farbe = zeile[i]
            anzahl = 1
        }
    }
    ergebnis = ergebnis + zuText(anzahl)       // letzter Lauf
    return ergebnis
}

FUNCTION kodiere(zeile: String) : String
    ergebnis: String := ""
    farbe: char := 'W'
    anzahl: integer := 0
    for i := 0 to length(zeile) - 1 do
        if (zeile[i] = farbe) then
            anzahl := anzahl + 1
        else
            ergebnis := ergebnis & zuText(anzahl) & ","
            farbe := zeile[i]
            anzahl := 1
        end if
    end for
    ergebnis := ergebnis & zuText(anzahl)      // letzter Lauf
    RETURN ergebnis
END kodiere

Funktion kodiere(zeile: string): string
    ergebnis: string := ""
    farbe: char := 'W'
    anzahl: integer := 0
    zähle i von 0 bis laenge(zeile) - 1
        wenn zeile[i] = farbe dann
            anzahl := anzahl + 1
        sonst
            ergebnis := ergebnis & zuText(anzahl) & ","
            farbe := zeile[i]
            anzahl := 1
        Ende wenn
    Ende zähle
    ergebnis := ergebnis & zuText(anzahl)      // letzter Lauf
    Rückgabe ergebnis
Ende kodiere

def kodiere(zeile):
    ergebnis = ""
    farbe = 'W'
    anzahl = 0
    for i in range(len(zeile)):
        if zeile[i] == farbe:
            anzahl = anzahl + 1
        else:
            ergebnis = ergebnis + zuText(anzahl) + ","
            farbe = zeile[i]
            anzahl = 1
        # Ende if
    # Ende for
    ergebnis = ergebnis + zuText(anzahl)       # letzter Lauf
    return ergebnis
# Ende kodiere

bc) Mia hat die Gegenstelle auf dem Türschild programmiert:

Funktion dekodiere(daten: string): string
    ergebnis := ""
    farbe := 'W'
    anzahl := 0
    zähle i von 0 bis laenge(daten)
        wenn i < laenge(daten) und istZiffer(daten[i]) dann
            anzahl := anzahl * 10 + ziffernwert(daten[i])
        sonst
            zähle k von 1 bis anzahl
                ergebnis := ergebnis & farbe
            Ende zähle
            wenn farbe = 'W' dann
                farbe := 'S'
            sonst
                farbe := 'W'
            Ende wenn
            anzahl := 0
        Ende wenn
    Ende zähle
    Rückgabe ergebnis
Ende dekodiere

Ermittle für den Aufruf dekodiere("0,5,3,12") die Werte, die anzahl jeweils beim Erreichen des Sonst-Zweigs hat, und den Rückgabewert. Erkläre, warum die Zählschleife bis laenge(daten) und nicht bis laenge(daten) - 1 läuft. (3 Punkte)

bd) Im Team gibt es zwei Vorschläge, die Datenmenge weiter zu verringern:

• Mia: „Die Kommas weglassen – die Zahlen stehen ja ohnehin hintereinander.“

• Emre: „Jede Länge als ein Byte (Binärwert 0 bis 255) senden statt als Dezimaltext mit Komma.“

Beurteile beide Vorschläge. Gib für Emres Vorschlag an, wie eine vollständig weiße Bildzeile übertragen werden kann. (4 Punkte)

c) Die Badge-Drucker drucken den Namen in einer Zeile mit höchstens 18 Zeichen.

ca) Erstelle eine Funktion badgeName(vorname: string, nachname: string): string nach folgender Regel:

• Passt „Vorname Nachname“ (mit einem Leerzeichen) in 18 Zeichen, wird er so gedruckt.

• Sonst wird der Vorname auf den Anfangsbuchstaben mit Punkt gekürzt („V. Nachname“), wenn das passt.

• Passt auch das nicht, werden die ersten 17 Zeichen des Nachnamens mit einem Punkt gedruckt.

Gib außerdem an, was Deine Funktion für Dimitrios Papadopoulos und für Petra Schulze-Albers liefert. (5 Punkte)

String badgeName(String vorname, String nachname) {
    String name = vorname + " " + nachname
    if (strLen(name) <= 18) {
        return name
    }
    name = teilText(vorname, 0, 1) + ". " + nachname
    if (strLen(name) <= 18) {
        return name
    }
    return teilText(nachname, 0, 17) + "."
}

FUNCTION badgeName(vorname: String, nachname: String) : String
    name: String := vorname & " " & nachname
    if (length(name) <= 18) then
        RETURN name
    end if
    name := teilText(vorname, 0, 1) & ". " & nachname
    if (length(name) <= 18) then
        RETURN name
    end if
    RETURN teilText(nachname, 0, 17) & "."
END badgeName

Funktion badgeName(vorname: string, nachname: string): string
    name: string := vorname & " " & nachname
    wenn laenge(name) <= 18 dann
        Rückgabe name
    Ende wenn
    name := teilText(vorname, 0, 1) & ". " & nachname
    wenn laenge(name) <= 18 dann
        Rückgabe name
    Ende wenn
    Rückgabe teilText(nachname, 0, 17) & "."
Ende badgeName

def badgeName(vorname, nachname):
    name = vorname + " " + nachname
    if len(name) <= 18:
        return name
    # Ende if
    name = teilText(vorname, 0, 1) + ". " + nachname
    if len(name) <= 18:
        return name
    # Ende if
    return teilText(nachname, 0, 17) + "."
# Ende badgeName

cb) Für die Türschilder hat Mia folgende Zeile geschrieben; slot ist der Index des Session-Slots (0 bis 4), raum der Raumname:

kopf := "Slot " + slot + 1 + " | " + raum

Ermittle den Inhalt von kopf für slot = 1 und raum = "A.104", erläutere die Ursache und korrigiere die Zeile. (3 Punkte)

Links und weitere Informationen

• Zeichenketten und Prüfziffern: Algorithmen für Codes, Nummern und Texte

• Prozedurale Algorithmen mit Arrays: suchen, zählen, Extremwerte und Gruppenwechsel

• Übungsaufgaben zu prozeduralen Algorithmen mit Arrays

• Algorithmen mit Pseudocode dokumentieren

• Übersicht der Programmentwurfsmethoden

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “Übungsaufgaben zu Zeichenketten und Prüfziffern” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/zeichenketten-pruefziffern-uebungsaufgaben veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/algorithmik/algorithmen. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 29.10.2026.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]