Modulo-10 Prüfsumme eines Strings berechnen

[Codehunter]

Hallo!

Ich möchte gerne eine Prüfsummenberechnung implementieren. Habe ich aber noch nie gemacht. Alles was ich habe ist die im Anhang gezeigte Formel und davon das MOD 10. Soweit ich als Schwachmathematiker das beurteilen kann, gibt es da keine Gewichtung sondern lediglich die Quersumme der einzelnen ASCII-Codes MOD 10. Soweit richtig?

Zweite Frage: Wie verfahre ich mit Non-ASCII-Zeichen? Ordinalposition des Widechar oder die Bytes einzeln? Der zugrunde liegende Standard stammt noch aus der Vor-Unicode-Ära bzw. dem letzten Jahrtausend.

Grüße
Cody

[Delphi.Narium]

Analog zu https://www.activebarcode.de/codes/c.../modulo10.html eventuell sowas?

Delphi-Quellcode:

function Modulo10FromString(s : String) : Integer;
var
  i : Integer;
begin
  Result := 0;
  for i := 1 to Length(s) do begin
    case i mod 2 of
      0 : Result := Result + (Ord(s[i]) * 3);
      1 : Result := Result +  Ord(s[i]);
    else
      // Upps, das geht doch garnicht ;-)
    end;
  end;
  Result := Result Mod 10;
end;

(nur hingedaddelt und ungetestet)

Ob ASCII oder nicht, sollte eigentlich egal sein, es geht ja um alle Zeichen im String und nicht nur um die Zeichen im String, die eine bestimmte Anforderung erfüllen.

[Codehunter]

Zitat:

Zitat von Delphi.Narium (Beitrag 1426927)

Delphi-Quellcode:

function Modulo10FromString(s : String) : Integer;
var
  i : Integer;
begin
  Result := 0;
  for i := 1 to Length(s) do begin
    case i mod 2 of
      0 : Result := Result + (Ord(s[i]) * 3);
      1 : Result := Result +  Ord(s[i]);
    else
      // Upps, das geht doch garnicht ;-)
    end;
  end;
  Result := Result Mod 10;
end;

Das hätte aber eine 1/3-Gewichtung, die ich in der Formel nicht sehen kann. Daher schaut meine Version aktuell so aus:

Delphi-Quellcode:

function Checksum(const AStr: string): Byte;
var
  A: AnsiString;
  C: AnsiChar;
  I: Integer;
begin
  A:= AnsiString(AStr);
  I := 0;
  for C in A do begin
    I := I + Ord(C);
  end;
  Result := (I mod 10);
end;

[Delphi.Narium]

Ich schrieb analog zu https://www.activebarcode.de/codes/c.../modulo10.html

Zitat:

Zitat von Prüfziffernberechnung: Modulo 10

EAN-Nummer: 4 007630 00011
Prüfziffer: zu dieser Zeit unbekannt
Ziffern: 4 0 0 7 6 3 0 0 0 0 1 1
Multiplikation 1 3 1 3 1 3 1 3 1 3 1 3
Ergebnisse 4 0 0 21 6 9 0 0 0 0 1 3 Total = 44
Prüfsumme ausrechnen: Prüfsumme = Die Ergänzung zum nächsten Vielfachen von 10 (hier 50), also 6.
Prüfsumme: 6

Und daraus dann die Zeile Multiplikation 1 3 1 3 1 3 1 3 1 3 1 3 ergibt die Gewichtung. Will man die nicht, dann lässt man's halt ;-) und kommt auf Deine Variante.

Welche man wählt ist eigentlich egal, solange man sich dann an die gewählte Version hält und nicht (bei der Kommunikation mit anderen Systemen) quasi so 'ne Art "Mischkalkulation" bekommt.

[Codehunter]

Zitat:

Zitat von Delphi.Narium (Beitrag 1426930)

solange man sich dann an die gewählte Version hält und nicht (bei der Kommunikation mit anderen Systemen)

Genau das ist der Punkt. Die Formel ist alles was ich habe. Leider kein Testprogramm zum Gegenchecken. Wenns mal eins gab dann zu DOS-Zeiten und längst verschollen.

Auf der von dir verlinkten Seite war ich auch bevor ich hier gefragt habe. Die Prüfsummenberechnung bekomme ich ja hin, mit der Formel war ich mir hingegen gar nicht sicher.

[dummzeuch]

Zitat:

Zitat von Codehunter (Beitrag 1426919)

Ich möchte gerne eine Prüfsummenberechnung implementieren. Habe ich aber noch nie gemacht. Alles was ich habe ist die im Anhang gezeigte Formel und davon das MOD 10. Soweit ich als Schwachmathematiker das beurteilen kann, gibt es da keine Gewichtung sondern lediglich die Quersumme der einzelnen ASCII-Codes MOD 10. Soweit richtig?

Zweite Frage: Wie verfahre ich mit Non-ASCII-Zeichen? Ordinalposition des Widechar oder die Bytes einzeln? Der zugrunde liegende Standard stammt noch aus der Vor-Unicode-Ära bzw. dem letzten Jahrtausend.

"Quersumme" gibt es eigentlich nur bei Zahlen. Gemeint ist die Summe der ASCII-Codes aller Zeichen im String. Und nein, eine Gewichtung nach Position gibt es da nicht. Deshalb ist diese Prüfsumme anfällig führ Zeichendreher:

Pruefsumme('abc') = Pruefsumme('bac')

Alles ist andere als ideal.

Was Non-ASCII angeht, so kann dir das keiner von uns sagen sondern nur derjenige, der dir die Vorgabe gemacht hat.

Ohne weitere Angaben würde ich bei Non-ASCII eine Exception werfen (und dabei auf denjenigen zielen, der die Vorgabe gemacht hat).

[Delphi.Narium]

Also fragen wir mal so:

Wofür brauchst Du das?

Dann kann man eventuell bei der Suche / Implementierung der erforderlichen Variante helfen.

Die verlinkte Seite beschreibt halt den Algorithmus für eine bestimmte Implementierung für einen konkreten Sachverhalt.

Weitere Info:
https://de.wikipedia.org/wiki/Luhn-Algorithmus
https://barmatrixcode.de/pz-modulo10
http://www.pruefziffernberechnung.de...ensindex.shtml
und vieles mehr:
Module 10

Ohne konkrete Aufgabenstellung sehe ich kaum 'ne Möglichkeit, den von Dir konkret benötigten Algorithmus zu finden.

[Codehunter]

Zitat:

Zitat von dummzeuch (Beitrag 1426934)

"Quersumme" gibt es eigentlich nur bei Zahlen. Gemeint ist die Summe der ASCII-Codes aller Zeichen im String. Und nein, eine Gewichtung nach Position gibt es da nicht. Deshalb ist diese Prüfsumme anfällig führ Zeichendreher:

Pruefsumme('abc') = Pruefsumme('bac')

Alles ist andere als ideal.

Was Non-ASCII angeht, so kann dir das keiner von uns sagen sondern nur derjenige, der dir die Vorgabe gemacht hat.

Ohne weitere Angaben würde ich bei Non-ASCII eine Exception werfen (und dabei auf denjenigen zielen, der die Vorgabe gemacht hat).

Die Doku ist, wie gesagt, uralt (1995). Da gab es zwar schon Unicode bei Windows, aber diese Systeme liefen auf DOS. Daraus und der Logik wie die Daten verarbeitet werden, schließe ich auf diese ganz einfache Variante, die Unicodezeichen als mehrere ASCII-Zeichen verarbeiten würde.

Das mit den möglichen Kollisionen scheint damals wohl noch niemanden interessiert zu haben. Ich glaube da ging es auch weniger um Manipulationsfestigkeit als die Erkennung von Übertragungsfehlern. Ob Rückwärtskompatibilität gefragt ist oder nicht muss ich intern klären. Wenn nicht wäre dein Hinweis richtig und sinnvoll anzuwenden.

Zitat:

Zitat von Delphi.Narium (Beitrag 1426936)

Ohne konkrete Aufgabenstellung sehe ich kaum 'ne Möglichkeit, den von Dir konkret benötigten Algorithmus zu finden.

So komisch es auch klingen mag, ich habe nicht mehr als den Hinweis

Zitat:

Der Modulo-10-Check wird plaziert. Jedes Zeichen vor der Kontrollsumme wird in die Berechnung der Kontrollsumme mit einbezogen. Wenn die Kontrollsumme auf der Position n+1 plaziert ist, wird wie folgt berechnet:

gefolgt von der Formel. Ende.

Die Daten sind zeilenorientierte Klartextdaten. Je Zeile wäre eine Checksumme zu schreiben und zwischen Daten und Zeilenumbruch zu setzen.

[Delphi.Narium]

Hast Du schon eine "fertige" Datei (von Anno 1995 oder so), die man als Vorlage nutzen könnte, und durch umgekehrtes "studieren geht über probieren" ;-) auseinander nehmen könnte, um den Algorithmus daraus zu rekonstruieren?

Nach Deiner Beschreibung würd' ich aber nicht drauf achten, ob nun Unicode oder nicht, sondern zeichenweise vorgehen.

Dann müsste bei 'nem aus DOS-Zeiten übernommen String das gleiche Ergebnis rauskommen, wie bei einer neu eingegebene Zeichenfolge in Unicode.

Unter DOS war A = 65
unter Unicode ist es = 0065

Wenn man zeichenweise vorgeht, bleibt der Wert von A erhalten.
Teilt man nun die 0065 in 00 und 65 auf kommt ohne Gewichtung das Gleiche heraus, mit Gewichtung aber nicht mehr.

Für mich erscheint es sinnvoller zeichenweise vorzugehen, unabhängig davon, in wievielen Bits und Bytes ein Zeichen hardware-/softwareseitig nun abgelegt wird.

[TigerLilly]

Das ist eine Sache, wo man die Hand heben sollte + laut "Problem" rufen sollte. Die Formel (so wie damals) zu implementieren ist ja nicht schwer + ein paar Sonderfälle abzufangen, auch nicht. ABER: Da können jetzt andere Daten als damals kommen. Und so etwas betrifft in der Regel nicht nur eine Stelle, sondern viele und ist ein Indiz für ein richtig gutes Problem.