Einführung:

Eine niederländische BSN (BurgerServiceNummer) ist gültig, wenn sie die folgenden Regeln erfüllt:

• Es enthält nur Ziffern.
• Die Länge sollte entweder 8 oder 9 betragen.
• Wenn die Ziffern als Adurch indiziert sind I, sollte das Ergebnis der folgenden Summe 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI(HINWEIS: -1 statt 1!) Durch 11 teilbar und nicht 0 sein.

Herausforderung:

Eingabe: Ein String oder ein Char-Array, das die BSN darstellt.

Ausgabe: Ein wahres oder falsches Ergebnis, unabhängig davon, ob die Eingabe eine gültige BSN ist.

Herausforderungsregeln:

• Das Eingabeformat sollte ein String oder ein Char-Array sein. Sie dürfen kein Int-Array von Ziffern oder eine (möglicherweise oktale) Zahl verwenden. (Sie können es jedoch selbst in ein Int-Array von Ziffern konvertieren, jedoch nicht direkt als Argument.)
• Trotz der oben genannten Einschränkung der Eingabe können Sie davon ausgehen, dass alle Testfälle eine oder mehrere Ziffern enthalten ( [0-9]+).
• In Bezug auf die BSN mit der Länge 8 anstelle von 9 gibt die niederländische Wikipedia Folgendes an: " Für den Elftest und für andere praktische Zwecke wird eine führende Null hinzugefügt, um die Nummer der Länge 9 zu bilden. " ( Quelle )

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methode mit den richtigen Parametern und vollständige Programme verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

// Truthy test cases:
111222333
123456782
232262536
010464554
10464554
44016773

// Falsey test cases:
000000000
192837465
247594057
88888888
73
3112223342
000000012

05AB1E , 23 21 Bytes

`()DgLR*OD11Ö89¹gåP0Ê

Probieren Sie es online! oder als Testsuite

Erläuterung

`                        # push input as individual chars onto stack
 (                       # negate top value
  )                      # wrap in list
   DgLR                  # range [len(input) ... 1]
       *O                # multiply with list of digits and sum
         D11Ö            # is evenly divisible by 11
             89¹gå       # len(input) is 8 or 9
                  P      # product of sum/divisible by 11/len in (8,9)
                   0Ê    # not equal to 0

JavaScript (ES6) 57

Eingabe als Array von Zeichen. reduceRightrettet den Tag!

s=>!(i=1,t=s.reduceRight((t,v)=>t-v*++i),!t|t%11|(i|1)-9)

Prüfung

F=
s=>!(i=1,t=s.reduceRight((t,v)=>t-v*++i),!t|t%11|(i|1)-9)


;['111222333','123456782','232262536','010464554','10464554','44016773']
.forEach(t=>{
  var r=F([...t]);console.log(t,r)
})

;['000000000','192837465','247594057','88888888','73','3112223342','3112223342']
.forEach(t=>{
  var r=F([...t]);console.log(t,r)
})

R 86 67 Bytes

Edit: Vielen Dank an Jarko Dubbeldam, der das Dot-Produkt vorgeschlagen hat!

l=length(x<-scan(,""));s=as.double(x)%*%c(l:2,-1);!s%%11&s&l>7&l<10

Liest die Eingabe von stdin und speichert sie als Array / Vektor von Zeichen. Anschließend in numerisch konvertieren, mit dem Vektor multiplizieren 9...2,-1und alle Bedingungen prüfen.

JavaScript (ES6), 61 60 59 58 Byte

Nimmt ein Array von Zeichen als Eingabe. Rückgabe false/ true.

a=>!(a.map(c=>s-=--k?-c*k-c:c,k=a.length&9,s=0)|!s|k|s%11)

Testfälle

let f =

a=>!(a.map(c=>s-=--k?-c*k-c:c,k=a.length&9,s=0)|!s|k|s%11)

// truthy
console.log(f([..."111222333"]));
console.log(f([..."123456782"]));
console.log(f([..."232262536"]));
console.log(f([..."010464554"]));
console.log(f([..."10464554"]));
console.log(f([..."44016773"]));

// falsy
console.log(f([..."000000000"]));
console.log(f([..."192837465"]));
console.log(f([..."247594057"]));
console.log(f([..."88888888"]));
console.log(f([..."73"]));
console.log(f([..."3112223342"]));

C 112 101 96 98 104 Bytes

Vielen Dank an @MartinEnder für das Speichern von 5 bis 3 Bytes beim Reparieren meines Codes !

j,i,k,l;f(char*s){l=strlen(s);for(i=l,j=k=0;j<l;)k+=(s[j++]-48)*(i>1?i--:-1);return!(k%11)&&k&&(l^8)<2;}

Gibt 0 zurück, wenn ungültig, 1, wenn gültig. Probieren Sie es online!

R 95 79 93 Bytes

function(x){y=as.double(el(strsplit(x,"")));z=y%*%c((q<-length(y)):2,-1);(z&!z%%11&q>7&q<10)}

Unbenannte Funktion, die eine Zeichenfolge als Argument nimmt. Zuerst habe ich die Anforderung, einen String anstelle einer Zahl als Eingabe zu haben, überlesen, aber das ist gut so, weil es bei der Konvertierung einige Bytes einspart.

Ich bin mir nicht sicher, wie ich das Array von Zeichen interpretieren soll, aber wenn das bedeutet, dass Sie einen Vektor mit Zeichenfolgen "1" "2" "3" "4" etcals Eingabe verwenden können, wird es sogar ein bisschen kürzer:

function(x){y=as.double(x);z=y%*%c((q<-length(y)):2,-1);(z&!z%%11&q>7&q<10)}

Teilt x in einen numerischen Vektor, fügt eine 0 hinzu, wenn die Länge 8 ist, und berechnet dann das Punktprodukt von Vektor y und c(9,8,7,6,5,4,3,2,-1). Prüft, ob das Ergebnis sowohl ungleich Null als auch durch 11 teilbar ist.

Dank der Logik von @Enigma wurden 16 Bytes gespart und implizit die 0 bei der Erstellung des Vektors angehängt c(length(x):2,-1).

Ich habe vergessen, einen Check für die Länge 8/9 hinzuzufügen, also +14 Bytes :(

Perl, 58 Bytes (52 + 6)

@N=(-1,2..9);$r+=$_*shift@N for reverse@F;$_=$r&&/^\d{8,9}$/&&!($r%11)

Laufen Sie mit

perl -F// -lapE

Eingabe übergeben durch STDIN:

Verwendung

echo 232262536 | perl -F// -lapE '@N=(-1,2..9);$r+=$_*shift@N for reverse@F;$_=$r&&/^\d{8,9}$/&&!($r%11)'

Ausgaben 1für als Wahrheitswert 0oder nichts für falsche Werte.

C ++ 14, 107 106 Bytes

-1 Byte für intstatt autofür Schleife.

Als unbenanntes Lambda, das über den Referenzparameter zurückkehrt. Benötigt Eingabe, um std::stringoder ein Container mit Zeichen, wie vector<char>.

[](auto c,int&r){int i=c.size();r=7<i&&i<10?-2*c.back()+96:~1<<9;for(int x:c)r+=(x-48)*i--;r=r%11<1&&r>0;}

Ungolfed und Nutzung:

#include<iostream>
#include<string>

auto f=
[](auto c, int& r){
 int i = c.size();
 //if the size is correct, init r to -2*I so we can add I safely later
 //otherwise such a big negative number, that the final test fails
 r = 7<i && i<10 ? -2*c.back()+96 : ~1<<9;
 for (auto x:c)
  r += (x-48)*i--;
 r = r%11<1 && r>0;
}
;

using namespace std;
using namespace std::literals;

int main(){
 int r;
 f("111222333"s,r); std::cout << r << std::endl;
 f("123456782"s,r); std::cout << r << std::endl;
 f("010464554"s,r); std::cout << r << std::endl;
 f("10464554"s,r); std::cout << r << std::endl;
 f("44016773"s,r); std::cout << r << std::endl;
 std::cout << std::endl;
 f("000000000"s,r); std::cout << r << std::endl;
 f("192837465"s,r); std::cout << r << std::endl;
 f("73"s,r); std::cout << r << std::endl;
 f("88888888"s,r); std::cout << r << std::endl;
 f("3112222342"s,r); std::cout << r << std::endl;
 std::cout << std::endl;
 f("99999999"s,r); std::cout << r << std::endl;
 f("999999999"s,r); std::cout << r << std::endl;
}

Befunge, 72 Bytes

>+~>:0`v
^1\-*68_\2/4-!00p*8>1-10p\910gv
@.!+!\%+56:*g00$  _^#!:g01+*-<<

Probieren Sie es online!

Erläuterung

>+~>:0`v            Read characters from stdin until EOF, converting each digit into
^1\-*68_              a number on the stack, and keeping a count of the characters read.

      \2/4-!00p     Save !(count/2-4), which is only true for valid lengths (8 and 9).
               *    Multiply the EOF (-1) with the final digit; this is the initial total.

8>1-10p\910gv       Loop over the remaining 8 digits, multiplying each of them by 9-i and
 ^#!:g01+*-<<         add to the total; i goes from 7 down to 0, so 9-i goes from 2 to 9.

               $    Drop the loop counter.
           *g00     Multiply total by the length calculation (invalid lengths become 0).
      %+65:         Make a copy of the total, and calculate modulo 11.
    !\              Boolean not the other copy to check for zero. 
  !+                !(total%11 + !(total)) is only true for non-zero multiples of 11.
@.                  Output the result and exit.

MATL, 36 Bytes

Nicht das längste MATL-Programm, das ich je geschrieben habe , aber ich mag es, wie if/ elseAnweisungen in Golfsprachen sehr schnell sehr lang werden. Ich bin der Meinung, dass diese Lösung in MATL möglicherweise nicht optimal ist, aber ich kann sie noch nicht weiter optimieren. Ich denke darüber nach, irgendwo die doppelte 0 zu verwenden und vielleicht tüberall die zu reduzieren .

48-tn8=?0wh]tn9=?P[a2:9]*st11\~Y&}x0

Probieren Sie es online! Erläuterung:

48-                                  % Subtract 48 (ASCII '0')
   tn                                % Duplicate. Get length.
     8=?                             % If length equals 8
        0wh                          %     Prepend 0 to the duplicate
           ]                         % End if.
            t                        % Duplicate again.
             n9=?                    % If length equals 9.
                 P                   %     Reverse the duplicate
                  [a2:9]*            %     Element-wise product with [-1 2 ... 9]
                         s           %     Sum
                          t11\       %     Duplicate sum, modulus 11
                              ~Y&    %     Result on stack: modulus==0 AND sum!=0
                                 }   % Else
                                  x0 %     Remove the duplicate. Put 0 on stack.
                                     % Display implicitly.

MATL , 26 Bytes

!UGg*R!s0&)s-t11\~Gn8-tg=v

Das Ergebnis ist ein nicht leerer Spaltenvektor, der wahr ist, wenn alle seine Einträge ungleich Null sind .

Probieren Sie es online!

Oder überprüfen Sie alle Testfälle mit jedem Ergebnis in einer anderen Zeile.

Erläuterung

Dies testet die drei Bedingungen in der folgenden Reihenfolge:

1. Die gewichtete Summe ist ungleich Null.
2. Die gewichtete Summe ist durch 11 teilbar.
3. Die Länge beträgt 8 oder 9.

Betrachten Sie die Eingabe '8925'für die Erklärung. ;ist das Zeilentrennzeichen für Matrizen.

!     % Implicit input. Transpose into a column vecvtor
      % STACK: ['8'; '9'; '2'; '5']
U     % Convert each digit to number
      % STACK: [8; 9; 2; 5]
Gg    % Push a row array of ones as long as the input
      % STACK: [8; 9; 2; 5], [1 1 1 1]
*     % Multiply, element-wise with broadcast
      % STACK: [8 8 8 8; 9 9 9 9; 2 2 2 2; 5 5 5 5]
R     % Upper triangular part
      % STACK: [8 8 8 8; 0 9 9 9; 0 0 2 2; 0 0 0 5]
!     % Transpose
      % STACK: [8 0 0 0;8 9 0 0;8 9 2 0;8 9 2 5]
s     % Sum of each column. This multiplies last element by 1, second-last by 2 etc
      % STACK: [32 27 4 5]
0&)   % Split into last element and remaining elements
      % STACK: 5, [32 27 4]
s     % Sum of array
      % STACK: 5, 63
-     % Subtract
      % STACK: -58. This is the result of condition 1
t11\  % Duplicate. Modulo 11
      % STACK: -58, 8
~     % Logical negation
      % STACK: -58, 0. This gives condition 2
Gn    % Push numnber of entries in the input
      % STACK: -58, 0, 4
8-    % Subtract 8. For valid lengths (8 or 9) this gives 0 or 1
      % STACK: -58, 0, -4
tg    % Duplicate. Convert to logical: set nonzero values to 1
      % STACK: -58, 0, -4, 1
=     % 1 if equal, 0 otherwise. Lenghts 8 or 9 will give 1. This is condition 3
      % STACK: -58, 0, 0
v     % Vertically concatenate the entire stack. This is truthy iff all values 
      % are non-zero. Implicitly display
      % STACK: [-58; 0; 0]

Haskell, 116 112 102 Bytes

f x=div(length x)2==4&&g x>0&&h x
h=((==0).(`mod`11)).g
g=sum.zipWith(*)(-1:[2..]).map(read.(:[])).reverse

gzählt die Summe, die im elf-Proef von verwendet wird h, während fauch die korrekte Länge überprüft wird und das elf-Proef nicht 0 ist. Insbesondere die Überprüfungen von fnehmen eine Menge Bytes in Anspruch.

BEARBEITEN: Dank Lynn und divAbrunden 10 Bytes gespart .

Jelly , 21 Bytes

V€U×JN1¦µL:2=4×Sµ11ḍa

TryItOnline! oder führen Sie alle Testfälle aus

Rückgabewerte für Wahrheiten sind ungleich Null (und tatsächlich das Vielfache von 11).

Wie?

V€U×JN1¦µL:2=4×Sµ11ḍa - Main link: string of digits  e.g. "111222333"
V€                    - eval each - effectively cast each to an integer (keeps leading zeros)
  U                   - upend                        e.g. [ 3, 3, 3, 2, 2, 2, 1, 1, 1]
    J                 - range(length)                e.g. [ 1, 2, 3, 4, 5, 6, 7, 8, 9]
   ×                  - multiply                     e.g. [ 3, 6, 9, 8,10,12, 7, 8, 9]
      1¦              - apply to index 1 (first element)
     N                -     negate                   e.g. [-3, 6, 9, 8,10,12, 7, 8, 9]
        µ             - monadic chain separation   e.g. z=[-3, 6, 9, 8,10,12, 7, 8, 9]
         L            - length(z)                    e.g. 9
          :2          - integer divide by 2          e.g. 4
            =4        - equals 4?                    e.g. 1
               S      - sum(z)                       e.g. 66
              ×       - multiply                     e.g. 66
                µ     - monadic chain separation   e.g. z=66
                 11ḍ  - divides(11, z)               e.g. 1
                    a - and z (for z=0 case)         e.g. 66 (truthy)

Python 2, 102 Bytes

def f(i):S=sum(a*b for a,b in zip([-1]+range(2,10),map(int,i)[::-1]));return(7<len(i)<10)*(S%11<1)*S>0

Python 2, 96 bytes

def g(s):u=7<len(s)<10and sum(x*int(('0'+s)[-x])for x in range(2,10))-int(s[-1]);print(u%11<1)*u

Takes a string as input. The function adds a '0' to the front of the string whether it needs it or not, and uses Python's negative indices to add elements, starting from the end of the string and working back-to-front.

The -1xI is handled separately, using a second call to int(). I couldn't figure out how to avoid this without costing more bytes than I saved.

def g(s):u=7<len(s)<10and sum(x*int(('0'+s)[-x])for x in range(10))-2*int(s[-1]);print(u%11<1)*u would work just as well, since it would add 1 times s[-1] but then subtract it twice, and it would also add 0 times (something) which of course wouldn't affect the sum.

Brain-Flak , 345 Bytes

Beinhaltet +3 für -a

([]){{}({}[((((()()()){}){}){}){}]<>)<>([])}{}<>([][(()()()()){}]){({}[()]){([]){{}{}([])}}}{}([{}])({}({}){})({}({})({}){})({}(({}){}){})({}(({})({})){}{})({}(({})({}){}){})({}((({}))({}){}){}{})({}((({}){}){}){})(({}(((({})){}){}){}{}{}<(((()()())()){}{})>)){{}({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}[{}]<(())>){((<{}{}>))}{}(<()>)}{}

Die Wahrheit ist 1, Falsy hat eine 0 oben auf dem Stapel.

Probieren Sie es online!

Ich bin mir ziemlich sicher, dass es einen kürzeren Weg gibt, die Multiplikation in einer Schleife durchzuführen, aber ich habe ihn noch nicht gefunden.

#reverse and subtract 48 from all numbers (ASCII -> decimal)
([]){{}({}[((((()()()){}){}){}){}]<>)<>([])}{}<> 

([][(()()()()){}])       #height - 8
{({}[()]){               #if not 0 subtract 1
   ([]){{}{}([])}        #if still not 0 pop everything
}}{}                     #this loop pops everything unless there are 8 or 9 digits

([{}])                   # -I
({}({}){})               # H*2
({}({})({}){})           # G*3
({}(({}){}){})           # F*4
({}(({})({})){}{})       # E*5
({}(({})({}){}){})       # D*6
({}((({}))({}){}){}{})   # C*7
({}((({}){}){}){})       # B*8
(({}(((({})){}){}){}{}{} # A*9 pushed twice with:
<(((()()())()){}{})>))   # 11 under it


{{} #if not 0
({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}   # mod 11
[{}]<(())>){((<{}{}>))}{}                       # logical not
(<()>)                                          # push 0 to exit loop
}{}
                                                # implicit print

PowerShell v2 +, 96 Byte

param($n)$i=8-($n.count-eq8);!(($b=($n|%{(-"$_",(($i+1)*+"$_"))[!!$i--]})-join'+'|iex)%11)-and$b

OK, ich gebe zu, das sieht nach einem völligen Durcheinander aus. Und das ist es auch. Aber ertrage es mit mir und wir werden es schaffen.

Wir nehmen Eingaben $n(als char-array) und setzen sie $iauf 8minus einen Booleschen Wert, um festzustellen, ob 8 Elemente enthalten sind $n. Das heißt, wenn es 8 Elemente gibt, dann $iwäre 7.

Der nächste Abschnitt kombiniert die Berechnung mit unserer Ausgabe. Arbeiten von innen, durchlaufen wir $nmit $n|%{...}. Bei jeder Iteration verwenden wir ein Pseudoternäres, um eines von zwei Ergebnissen zu erhalten - entweder -"$_"oder (($i+1)*+"$_"). Der Index basiert darauf, ob dies der Fall $iist 0oder nicht (dh wir haben den -1xIFall aus der Herausforderungsgleichung getroffen), der für die nächste Runde nachher dekrementiert wird. Diese sind alle in Parens versammelt und -joinzusammen mit +. Zum Beispiel mit Eingaben 111222333zu diesem Zeitpunkt hätten wir 9+8+7+12+10+8+9+6+-3. Das wird zu iex(kurz für Invoke-Expressionund ähnlich zu eval) geleitet, bevor es in gespeichert wird $b. Dann nehmen wir das %11und führen ein Boolesches Nicht durch!(...)auf das (dh, wenn es durch 11 teilbar ist, ist dieser Teil $true). Dies ist gekoppelt mit, -and$bum sicherzustellen, dass der $bWert ungleich Null ist. Dieses boolesche Ergebnis verbleibt in der Pipeline und die Ausgabe ist implizit.

Beispiele

PS C:\Tools\Scripts\golfing> 111222333,123456782,232262536,010464554,10464554,44016773|%{"$_ -> "+(.\dutch-burgerservicenummer.ps1 ([char[]]"$_"))}
111222333 -> True
123456782 -> True
232262536 -> True
10464554 -> True
10464554 -> True
44016773 -> True

PS C:\Tools\Scripts\golfing> 000000000,192837465,247594057,88888888,73,3112223342,000000012|%{"$_ -> "+(.\dutch-burgerservicenummer.ps1 ([char[]]"$_"))}
0 -> False
192837465 -> False
247594057 -> False
88888888 -> False
73 -> False
3112223342 -> False
12 -> False

PHP 139 128 Bytes

 $u=-1;$i=$argv[1];while($u<=strlen($i)){$c+=($u*(substr($i,-(abs($u)),1)));$u +=$u<0?3:1;}echo($c>0&&!($c%11)&&$u>8&&$u<11?1:0);

Die CLI konnte nicht dazu gebracht werden, nur das Wahre oder das Falsche wiederzugeben. Musste es so machen. Irgendwelche Ideen?

128 Bytes: "true" und "false" auf 1 und 0 gesetzt.

C #, 120 115 Bytes

Dies durchläuft die char[]als Eingabe empfangenen und gibt true oder false zurück:

bool b(char[]n){int r=0,k,i=0,l=n.Length;for(;i<l;i++){k=i==l-1?-1:l-i;r+=k*(n[i]-48);}return r>0&r%11<1&l<10&l>7;}

Geige: https://dotnetfiddle.net/3Kaxrt

Ich bin sicher, ich kann ein paar Bytes herauskratzen, besonders in den chaotischen return. Irgendwelche Ideen willkommen!

Bearbeiten: 5 Bytes dank Kevin gespeichert. Ich hatte keine Ahnung, was ich &statt dessen gebrauchen könnte &&!

PHP, 86 85 84 83 82 79 Bytes

Hinweis: Verwendet PHP 7.1 für negative String-Indizes.

for($l=log10($a=$argn);~$c=$a[-++$x];)$s+=$x>1?$x*$c:-$c;echo$s%11<1&$l>7&$l<9;

Laufen Sie wie folgt:

echo 010464554 | php -nR 'for($l=log10($a=$argn);~$c=$a[-++$x];)$s+=$x>1?$x*$c:-$c;echo$s%11<1&$l>7&$l<9;';echo
> 1

Version für PHP <7.1 (+10 Bytes)

echo 010464554 | php -nR 'for($l=log10($a=$argn);~$c=$a[strlen($a)-++$x];)$s+=$x>1?$x*$c:-$c;echo$s%11<1&$l>7&$l<9;';echo

Erläuterung

for(
  $l=log10(         # Take the log of the input number.
    $a=$argn        # Set input to $a
  );
  ~$c=$a[-++$x];    # Iterate over digits of input (reverse). Negate to
                    # change every char to extended ASCII (all truthy),
                    # without changing empty sting (still falsy, ending
                    # the loop).
)
  $s+=$x>1?         # Add current char to the sum...
     ?$x*$c:-$c;    # multiplied by $x, unless $x is 1; subtract it.
echo
  $s%11<1 &         # Check if sum is divisible by 11, and
  $l>7   &          # log of the input is greater than 7, and
  $l<9;             # log of the input is less than 9. Outputs 0 or 1.

Optimierungen

• Kürzere Möglichkeit zur Unterscheidung zwischen leerer Zeichenfolge und "0", ein Byte gespeichert
• Da 10000000ungültig ist, keine Notwendigkeit , mit zu Vergleichen greater than or equals, greater thangenügt, um ein Byte Speicher
• Kürzere Methode zum Subtrahieren der niedrigstwertigen Ziffer
• Negiere char anstelle von XOR und spare ein Byte
• 3 Bytes mit gespeichert -R, um $argnverfügbar zu machen

Java 8, 115 98 Bytes

b->{int l=b.length,i=0,r=0,x;for(;l>7&l<10&i<l;r+=(b[i++]-48)*(x<2?-1:x))x=l-i;return r>0&r%11<1;}

Ich bin überrascht, dass noch niemand eine Java-Antwort gepostet hat. Hier ist eine.

Erläuterung:

Probieren Sie es hier aus.

b->{                  // Method with character-array as parameter and boolean return-type
  int l=b.length,     //  Length of the array
      i=0,            //  Index-integer, starting at 0
      r=0,            //  The result-sum, starting at 0
      x;              //  Temp integer `x`
  for(;l>7&l<10       //  Start looping if the length is either 8 or 9
       &i<l;          //  And continue looping while the index is smaller than the length
      r+=             //    After every iteration, increase the result-sum by:
         (b[i++]-48)  //     The current digit
         *(           //     Multiplied by:
           x<2?       //      If `x` is 1:
            -1        //       Multiply by -1
           :          //      Else:
            x))       //       Simply multiply by `x` 
    x=l-i;            //   Set `x` to the length minus the current index
                      //  End of loop (implicit / single-line body)
  return r>0          //  Return if the result-sum is larger than 0,
    &r%11<1;          //   and if the result-sum is divisible by 11
}                     // End of method

Clojure, 114 Bytes

Nun, das ist etwas, -das den Rest der Argumente vom ersten abzieht, um den speziellen Fall des Gewichts zu behandeln -1. Diese Funktion gibt nilfür Eingaben mit ungültiger Länge zurück, aber für ifKlauseln funktionieren sie genauso wie false. (#{8 9}(count v))Gibt zurück, nilwenn length of vnicht 8 oder 9 ist.

(fn[v](if(#{8 9}(count v))(#(and(< % 0)(=(mod % 11)0))(apply -(map *(range 1 10)(reverse(map #(-(int %)48)v)))))))

Testfälle:

(pprint (group-by f (map str [123456782 232262536 "010464554" 10464554 44016773 "000000000" 192837465 247594057 88888888 73 3112223342 "000000012"])))
{true  ["123456782" "232262536" "010464554" "10464554" "44016773"],
 false ["000000000" "192837465" "247594057" "88888888" "000000012"],
 nil   ["73" "3112223342"]}

Perl 5 , 63 + 2 ( -F) = 65 Bytes

$F[-1]*=-1;map$s+=++$i*$_,reverse@F;say/^.{8,9}$/&&$s&&!($s%11)

Probieren Sie es online!

Stax , 23 Bytes

╪╦µΘç}<╔▼◘╞i∟~¿≥←║▐√ 4u

Online ausführen und debuggen!

Erläuterung

Verwendet die entpackte Version, um zu erklären.

i%8A:byr{]ei^*mBN+|+c11%!L|A
i                               Suppress implicit eval
 %8A:b                          Length is 8 or 9 (Element #1 on the final stack)
      yr                        Reverse input
        {     m                 Map each element with
         ]e                         Its numerical value
           i^*                      Multiplied current 1-based loop index
               BN+              Negate the first element
                  |+            Sum (Element #2 on the final stack)
                    c11%!       Sum is multiple of 11 (Element #3 on the final stack)
                         L|A    Collect all the three elements and `and` them.