Es gibt beliebte Prüfziffernalgorithmen wie Luhn und gute , zum Beispiel den Damm-Algorithmus. Der einzige mögliche Grund für die Popularität von Algorithmen wie Luhn ist, dass es Code-Golf-Implementierungen von ihnen gibt. Dies bedeutet, dass wir als Gemeinschaft die Macht haben, die Welt zu verändern, indem wir Golf-Implementierungen besserer Algorithmen bereitstellen.

Diese Herausforderung besteht also darin, die Welt zu verändern, indem Sie eine Funktion oder ein komplettes Programm in der Sprache Ihrer Wahl schreiben, das mithilfe des Damm-Algorithmus eine Prüfziffer berechnet . Die Antwort mit der geringsten Anzahl von Zeichen (nicht Bytes) wird in wenigen Wochen als Gewinner ausgewählt. Beachten Sie, dass alle Hilfsfunktionen und die Deklaration der Operationstabelle in der Zeichenanzahl enthalten sein müssen. Im Falle eines Unentschieden wird die beliebteste Antwort gewählt.

Dieser Algorithmus dreht sich um eine Operationstabelle, die eine schwach vollständig antisymmetrische Quasigruppe der Ordnung 10 sein muss. Die Operationstabelle, die in dem Wikipedia-Artikel über den Damm-Algorithmus zu finden ist, ist diejenige, die bei dieser Herausforderung verwendet werden soll. Der Vollständigkeit halber werde ich es unten wiedergeben:

    |   0   1   2   3   4   5   6   7   8   9
----+----------------------------------------
0   |   0   3   1   7   5   9   8   6   4   2
1   |   7   0   9   2   1   5   4   8   6   3
2   |   4   2   0   6   8   7   1   3   5   9
3   |   1   7   5   0   9   8   3   4   2   6
4   |   6   1   2   3   0   4   5   9   7   8
5   |   3   6   7   4   2   0   9   5   8   1
6   |   5   8   6   9   7   2   0   1   3   4
7   |   8   9   4   5   3   6   2   0   1   7
8   |   9   4   3   8   6   1   7   2   0   5
9   |   2   5   8   1   4   3   6   7   9   0

Kurz gesagt (für Details siehe Wikipedia-Artikel ), funktioniert der Algorithmus wie folgt:

1. Sie beginnen mit einer Liste der zu verarbeitenden Ziffern und einer Zwischenziffer, die auf 0 gesetzt ist.
2. Für jede Ziffer in der Liste berechnen Sie eine neue Zwischenziffer, indem Sie die Ziffer als Spaltenindex und die vorherige Zwischenziffer als Zeilenindex verwenden.
3. Die letzte Zwischenziffer ist die Prüfziffer. Wenn Sie eine Nummer validieren, für die bereits eine Prüfziffer hinzugefügt wurde, ist die letzte Zwischenziffer 0, wenn die Nummer gültig ist.

Ihr Programm oder Ihre Funktion muss eine Zeichenfolge akzeptieren, die beliebige Zeichen außer null enthalten kann, sich jedoch nur mit den Ziffern in der Zeichenfolge befassen sollte. Es muss entweder die ursprüngliche Zeichenfolge mit der angehängten berechneten Prüfziffer drucken (falls ein Programm vorhanden ist) oder zurückgeben (falls eine Funktion vorhanden ist). Wenn Sie ein Programm schreiben möchten, akzeptiert das Programm die Eingabe entweder als Argument oder als Standardeingabe. Wenn die Eingabezeichenfolge leer ist oder keine Ziffern enthält, müssen Sie eine Null zurückgeben oder anhängen.

Einige Beispiele:

Input       |   Output
------------+-------------
42          |   427
427         |   4270
2 to 2      |   2 to 29
23 42 76-   |   23 42 76-5
-           |   -0

Pyth, 49 Zeichen

+z`u@sm>+0jCdT_6"Ľ򒉲򭉟񶯆𐱩򐞆󰆂򕟐򑽌򵋏󇋽򯴆󚙈𱑂񞑼쵥񪨶"+*TGvH:z"\D"k0

Enthält Gott weiß, welche Zeichen, also hier ist ein Python3-Programm, um das obige Programm genau auf Ihrem Computer zu generieren:

N = 317598642709215486342068713591750983426612304597836742095815869720134894536201794386172052581436790
M = 1000000
l = []
while N:
    l.insert(0, N % M)
    N //= M

n = "".join(chr(c) for c in l)

s = '+z`u@sm>+0jCdT_6"' + n + '"+*TGvH:z"\D"k0'

with open("golf.pyth", "wb") as f:
    f.write(s.encode("utf-8"))

print("Program length is {} characters.".format(len(s)))

Erläuterung:

+z`                                     Output the input followed by a
                                        stringified...
   u                         :z"\D"k0   Reduction starting with 0 of digits
                                        in input...
    @                  +*TGvH           Indexing ... by 10*prev + int(next).
     sm         "ZALGO"                 Sum all digits created by ... over the
                                        unicode garbage.
       >+0     6                        Prepend 0 if needed to...
          jCdT_                         Codepoint converted to sequence of
                                        digits.

CJam, 54 Zeichen

q_o{A,s&},{~0"끼´慜䪝膞䝮芜㮜ꡞ靓渏縰蒆㣉倔쵶"2G#bAb+A/T==:T;}/T

Es gibt ein nicht druckbares Zeichen, daher möchten Sie möglicherweise den folgenden Permalink verwenden.

Teste es hier.

Erläuterung

Die Zwischenziffer wird nachverfolgt T, die CJam auf 0 initialisiert.

q_o                                  "Read STDIN, duplicate it and print it.";
   {A,s&},                           "Filter out all non-digit characters.";
          {                     }/   "For each digit character.";
           ~                         "Eval to get the digit itself.";
            0                        "Push a zero.";
             "..."2G#b               "Push that long string and interpret the character
                                      codes as the digits of a base-2^16 number.";
                      Ab+            "Get base-10 digits and prepend the 0.";
                         A/          "Split into rows of 10.";
                           T=        "Select row based on interim digit.";
                             =       "Select column based on current digit.";
                              :T;    "Store in T and discard.";
                                   T "Push the interim digit to be printed.";

Python 3, 149 141 138 Zeichen

import re
l=""
for c in"ĽᝢႮ⏿ዿၮ∉᜝Ꮺൢ៫Njẜ᳼╭᛭ᰡඡᆸߡⓞ᠜ȍ῏᪆":l+="%04d"%ord(c)
def D(b):
 a="0"
 for i in re.sub("\D","",b):a=l[int(a+i)]
 return b+a

Beispiele:

 Input | Output
-------+--------
    42 | 427
   427 | 4270
2 to 2 | 2 to 29
   123 | 1234
  1234 | 12340
     - | -0

Vielen Dank an @MegaTom und @Sieg, die dabei geholfen haben, insgesamt 11 Zeichen zu entfernen

Ruby, 149 Zeichen

i="0";t="0#{'2uleblnnz0nbpv3kqkaufbjqebm57jdj6ubaba1mc2fyucqff69tbllrcvw393li'.to_i 36}";puts(gets.chomp.each_char{|c|i=(c=~/\d/?t[(i+c).to_i]:i)}+i)

Auf repl.it getestet

J, 117 Bytes

Enthält nur druckbare ASCII-Dateien. (Ich hatte Schwierigkeiten mit J und Unicode.) Erzeugt die Übergangstabelle aus den Permutationsindizes der Zeilen.

3 :'y,":(((_4(87)&#:inv\40-~a.i.''(3/3+wGf*Dl:(zaW+Hhw*(1p+;~.,y>m-<MZ)JCs'')A.i.10){~<@,~)/|.0,(#~10>])(1":i.10)i.y'

Verwendung:

   damm=.3 :'y,":(((_4(87)&#:inv\40-~a.i.''(3/3+wGf*Dl:(zaW+Hhw*(1p+;~.,y>m-<MZ)JCs'')A.i.10){~<@,~)/|.0,(#~10>])(1":i.10)i.y'

   damm '23 42 76-'
23 42 76-5

   damm ''
0

Probieren Sie es hier online aus.

Haskell, 131 Zeichen

import Data.Char
f n=n++(show$foldl(\x y->read[('0':(show.ord=<<"౧⚈ક×ዿၮ∉ɏᵕₖ᧔İɕSʢ凞㷽ᰡ衎텴䘗↩倭῏᪆"))!!(x*10+y)])0[read[i]|i<-n,isDigit i])

Testlauf:

> mapM_ (putStrLn.f) ["42", "427", "2 to 2", "23 42 76-", "-"]
427
4270
2 to 29
23 42 76-5
-0

k, 36 Zeichen

/ declare quasi-group  
M:"H"$'"0317598642709215486342068713591750983426612304597836742095815869720134894536201794386172052581436790"

/ declare function
  f:{x,$0{M y+10*x}/"H"$'x@&x in .Q.n}

/ get length of function
  #$f
36

/ execute function against test input
  .q.show f@'{x!x}("42";"427";"2 to 2";"23 42 76-";,"-")
"42"       | "427"
"427"      | "4270"
"2 to 2"   | "2 to 29"
"23 42 76-"| "23 42 76-5"
,"-"       | "-0"

q, 40 Zeichen (entspricht der Implementierung von k)

 f:{x,string 0{M y+10*x}/"H"$'x inter .Q.n}