[GO] Beschleunigen Sie die Prüfziffer meiner Nummer ungefähr um etwa 10% (ich weiß es nicht, weil ich sie nicht gemessen habe).

Überlegen Sie sich zunächst die Berechnungsmethode genau

Vorher .

Schauen wir uns zunächst genauer an, wie die Inspektionsnummern berechnet werden (Prüfziffern). Aus Sicht des Programmierers können Sie sehen, dass die Berechnung nach dem folgenden Verfahren durchgeführt werden sollte.

1. Setzen Sie $ P und Q $ wie folgt. $ P $ ist eine Liste, die andere 11-stellige Zahlen als Prüfziffern in Meine Nummer als Elemente enthält, und $ P _ {0} $ in $ P $ steht für die erste Ziffer von 11-stelligen Zahlen. Und. Jedes Element $ Q_n $ von $ Q $ wird als $ n \ bmod 6 + 2 $ berechnet. $ N $ ist jedoch $ 0 \ le n \ le 10 $.
   • P = (P_{10}, P_{9}, P_{8}, ..., P_{0})
   • Q = (Q_{10}, Q_{9}, Q_{8}, ..., Q_{0}) = (6, 5, 4, 3, 2, 7, 6, 5, 4, 3, 2)
2. Suchen Sie $ r = (11- \ sum_ {n = 1} ^ {11} P_n \ cdot Q_n \ bmod 11) \ bmod 10 $ und geben Sie $ r $ als Inspektionsnummer aus.

Sobald Sie dies wissen, ist es einfach, in jeder Sprache zu schreiben. Da keine bedingte Verzweigung angezeigt wird, ist die Ausführungsgeschwindigkeit wahrscheinlich höher. Lass es uns jetzt schreiben.

Ruby

verify_my_number.rb

def verify_my_number(my_number)
  remain, given_check_digit = my_number.divmod(10)
  check_digit = 0

  11.times do |i|
    remain, p_i = remain.divmod(10)
    check_digit += p_i * (i % 6 + 2)
  end

  (11 - check_digit % 11) % 10 == given_check_digit
end

Perl

verify_my_number.pl

sub verify_my_number {
    my ($my_number) = @_;
    my $given_check_digit = $my_number % 10;
    my $check_digit = 0;

    for (my $i = 0; $i < 11; $i++) {
        $my_number /= 10;
        $check_digit += ($my_number % 10) * ($i % 6 + 2);
    }

    return (11 - $check_digit % 11) % 10 == $given_check_digit;
}

Es unterscheidet sich nicht so sehr von Ruby und ist auch nicht interessant, also werde ich eine andere Schreibweise ausprobieren. Ich glaube nicht, dass es einen Vorteil in Bezug auf die Geschwindigkeit gibt, nur weil es ein bisschen Spaß macht, zu schreiben.

verify_my_number2.pl

sub verify_my_number {
    my ($my_number) = @_;
    my $check_digit = 0;

    map {
        $check_digit += $my_number / (10 ** ($_ + 1)) % 10 * ($_ % 6 + 2);
    } (0 .. 10);

    return (11 - $check_digit % 11) % 10 == $my_number % 10;
}

C

verify_my_number.c

int
verify_my_number(long long int my_number)
{
        int check_digit = 0;
        int given_check_digit = my_number % 10;

        for (int i = 0; i < 11; i++) {
                my_number /= 10;
                check_digit += (my_number % 10) * (i % 6 + 2);
        }

        return (11 - check_digit % 11) % 10 == given_check_digit;
}

Go

verify_my_number.go

func verify_my_number(my_number int) bool {
    check_digit := 0
    given_check_digit := my_number % 10

    for i := 0; i < 11; i++ {
        my_number /= 10
        check_digit += (my_number % 10) * (i % 6 + 2)
    }

    return (11 - check_digit % 11) % 10 == given_check_digit
}

bash

verify_my_number.sh

function verify_my_number {
    n=`printf %012d $1`
    given_check_digit=$(($1 % 10))
    check_digit=`echo -n $n|grep -o .|paste -d\* - <(echo -n '654327654320'|grep -o .)|paste -d+ - - - - - - - - - - - -|sed -e 's/^/echo $(((11-(/' -e 's/$/)%11)%10))/'|sh`
    [ $check_digit -eq $given_check_digit ] && echo 'OK' || echo 'NG'
}

Excel Wenn Sie nur die Prüfziffer berechnen möchten, können Sie wie folgt schreiben.

=MOD(
  11 - MOD(
  (MOD(QUOTIENT($A1, 10000000000), 10) * 6 +
   MOD(QUOTIENT($A1, 1000000000), 10) * 5 +
   MOD(QUOTIENT($A1, 100000000), 10) * 4 +
   MOD(QUOTIENT($A1, 10000000), 10) * 3 +
   MOD(QUOTIENT($A1, 1000000), 10) * 2 +
   MOD(QUOTIENT($A1, 100000), 10) * 7 +
   MOD(QUOTIENT($A1, 10000), 10) * 6 +
   MOD(QUOTIENT($A1, 1000), 10) * 5 +
   MOD(QUOTIENT($A1, 100), 10) * 4 +
   MOD(QUOTIENT($A1, 10), 10) * 3 +
   MOD($A1, 10) * 2),
  11),
10)

Python Ich bin mir bei Python nicht sicher, aber vielleicht sieht es so aus? Ich denke nicht, dass es so schnell ist.

verify_my_number.py

def verify_check_digit(my_number):
    product = sum([
                    (my_number / (10 ** (i + 1)) % 10) * (i % 6 + 2)
                    for i in range(0, 11)
                 ])
    return (11 - product % 11) % 10 == my_number % 10