Wprowadzenie:

Holenderski BSN (BurgerServiceNummer) jest ważny, jeżeli jest zgodny z następującymi zasadami:

• Zawiera tylko cyfry.
• Długość powinna wynosić 8 lub 9.
• Kiedy cyfry są indeksowane jako Athrough I, wynik należy do sumy: 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI(! UWAGA -1 zamiast 1) powinna być podzielna przez 11, a nie powinno być 0.

Wyzwanie:

Dane wejściowe: ciąg znaków lub tablica znaków reprezentująca BSN.

Wyjście: truthy lub falsey wynik czy wejście jest poprawnym BSN.

Zasady konkursu:

• Format wejściowy powinien być ciągiem znaków lub tablicą znaków. Nie wolno używać wewnętrznej tablicy cyfr lub liczby (być może ósemkowej). (Możesz jednak przekonwertować go na wewnętrzną tablicę cyfr, ale nie bezpośrednio jako argument).
• Pomimo powyższego ograniczenia można założyć, że wszystkie przypadki testowe będą zawierać jedną lub więcej cyfr ( [0-9]+)
• W odniesieniu do BSN o długości 8 zamiast 9 holenderska Wikipedia stwierdza, co następuje: „ W przypadku testu jedenastego i innych praktycznych zastosowań dodaje się zero wiodące, aby uzyskać liczbę o długości 9. ” ( źródło )

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Odpowiedzi dotyczą standardowe zasady , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

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

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

05AB1E , 23 21 bajtów

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

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

`                        # 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

Dane wejściowe jako tablica znaków. reduceRightratuje dzień!

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

Test

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 86 bajtów

Edycja: Podziękowania dla Jarko Dubbeldam za sugestię produktu kropkowego!

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

Odczytuje dane wejściowe ze standardowego wejścia i zapisuje jako tablicę / wektor znaków. Następnie przekonwertuj na liczbę, pomnóż przez wektor 9...2,-1i sprawdź wszystkie warunki.

JavaScript (ES6), 61 60 59 58 bajtów

Pobiera na wejściu tablicę znaków. Zwraca false/ true.

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

Przypadki testowe

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 bajtów

Dzięki @MartinEnder za zapisanie 5 3 bajtów podczas naprawy mojego kodu !

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;}

Zwraca 0, jeśli jest niepoprawne, 1, jeśli jest poprawne. Wypróbuj online!

R 95 79 93 bajtów

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

Funkcja bez nazwy, która przyjmuje ciąg znaków jako argument. Na początku zignorowałem wymóg posiadania łańcucha wejściowego zamiast liczby, ale to dobrze, ponieważ pozwala zaoszczędzić trochę bajtów podczas konwersji.

Nie jestem pewien, jak interpretować tablicę znaków, ale jeśli to oznacza, że ​​możesz użyć wektora cyfr ciągów "1" "2" "3" "4" etcjako danych wejściowych, staje się on nieco krótszy nawet:

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

Dzieli x na wektor numeryczny, a następnie dodaje 0, jeśli długość wynosi 8, a następnie oblicza iloczyn iloczynu wektora y i c(9,8,7,6,5,4,3,2,-1). Sprawdza, czy wynik jest zarówno niezerowy, jak i podzielny przez 11.

Zaoszczędzono 16 bajtów dzięki logice @Enigma, domyślnie dołączając 0 podczas tworzenia wektora c(length(x):2,-1).

Zapomniałem dodać czek dla długości 8/9, więc +14 bajtów :(

Perl, 58 bajtów (52 + 6)

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

Biegnij z

perl -F// -lapE

Dane wejściowe przekazywane STDIN:

Stosowanie

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

Wyjścia 1dla jako wartość truthy, 0albo nic o wartościach falsey.

C ++ 14, 107 106 bajtów

-1 bajt dla intzamiast autow pętli for.

Jako nienazwana lambda powraca poprzez parametr referencyjny. Wymaga wejścia std::stringlub kontenera znaków , takich jak 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;}

Niegolfowane i użytkowanie:

#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 bajty

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

Wypróbuj online!

Wyjaśnienie

>+~>: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 bajtów

Nie jest to najdłuższy program MATL, jaki kiedykolwiek napisałem , ale podoba mi się, jak if/ elsewypowiedzi bardzo szybko stają się bardzo długie w językach golfowych. Wydaje mi się, że to rozwiązanie może nie być optymalne w MATL, ale na razie nie mogę go dalej optymalizować. Zastanawiam się nad użyciem gdzieś podwójnego 0 i być może zmniejszysz twszędzie.

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

Wypróbuj online! Wyjaśnienie:

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 bajtów

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

Wynikiem jest niepusty wektor kolumny, co jest prawdą, jeśli wszystkie jego wpisy są niezerowe .

Wypróbuj online!

Lub sprawdź wszystkie przypadki testowe z każdym wynikiem w innym wierszu.

Wyjaśnienie

Testuje to trzy warunki w następującej kolejności:

1. Suma ważona jest niezerowa;
2. Suma ważona jest podzielna przez 11;
3. Długość wynosi 8 lub 9.

Rozważ dane wejściowe '8925'dla wyjaśnienia. ;jest separatorem wierszy dla macierzy.

!     % 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 bajtów

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

gzlicza sumę użytą w jedenastu-proef h, a fjednocześnie sprawdza poprawność długości i czy jedenaście-proef nie jest równe 0. Zwłaszcza kontrole fzajmują dużo bajtów.

EDYCJA: zaoszczędzono 10 bajtów dzięki Lynn i divzaokrąglając w dół.

Galaretka , 21 bajtów

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

TryItOnline! lub uruchom wszystkie przypadki testowe

Prawdziwe wartości zwracane są niezerowe (i są w rzeczywistości wielokrotnością 11 sum).

W jaki sposób?

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 bajty

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 bajtów

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

Pobiera ciąg jako dane wejściowe. Funkcja dodaje a '0'na początku łańcucha, czy tego potrzebuje, czy nie, i używa ujemnych wskaźników Pythona do dodawania elementów, zaczynając od końca łańcucha i pracując od początku do końca.

-1xIJest traktowane oddzielnie, za pomocą drugiego wywołanie int(). Nie mogłem wymyślić, jak tego uniknąć, nie kosztując więcej bajtów niż zaoszczędziłem.

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)*udziałałby równie dobrze, ponieważ dodawałby 1czasy, s[-1]ale następnie odejmowałby go dwukrotnie, a także dodawałby 0czasy (coś), co oczywiście nie wpłynęłoby na sumę.

Brain-Flak , 345 bajtów

Obejmuje +3 za -a

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

Prawda to 1, Falsy ma 0 na szczycie stosu.

Wypróbuj online!

Jestem prawie pewien, że istnieje krótszy sposób na pomnożenie w pętli, ale jeszcze go nie znalazłem.

#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 bajtów

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

OK, przyznaję, to wygląda na kompletny bałagan. I tak jest. Ale, znosząc mnie, przejdziemy przez to.

Bierzemy dane wejściowe $n(jako char-array) i ustawiamy na wartość $irówną 8minus wartość logiczną dla tego, czy jest w niej 8 elementów $n. Oznacza to, że jeśli jest 8 pozycji, to $ibyłoby 7.

Następna sekcja łączy obliczenia z naszą wydajnością. Pracując od środka, zapętlamy $nsię $n|%{...}. W każdej iteracji używamy pseudo-trójki, aby uzyskać jeden z dwóch wyników - albo -"$_"albo (($i+1)*+"$_"). Indeks opiera się na tym, czy $ijest ( 0czy nie, trafiliśmy na -1xIprzypadek z równania wyzwania), który jest dekrementowany po kolejnej rundzie. Wszystkie są zebrane w pareny i -joinrazem z nimi +. Na przykład z wkładem 111222333w tym momencie mielibyśmy 9+8+7+12+10+8+9+6+-3. To jest przesyłane do iex(skrót Invoke-Expressioni podobne do eval) przed zapisaniem w $b. Następnie bierzemy to %11i wykonujemy wartość logiczną!(...)na tym (tj. jeśli więc można podzielić przez 11, ta część jest $true). Jest to połączone z, -and$baby zapewnić, że $bjest niezerowa. Ten wynik logiczny jest pozostawiany w potoku, a dane wyjściowe są niejawne.

Przykłady

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 bajtów

 $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);

Nie można zmusić interfejsu CLI do po prostu odzwierciedlenia prawdy fałszu. Musiałem zrobić to w ten sposób. Jakieś pomysły?

128 bajtów: zmieniono „prawda” i „fałsz” na 1 i 0.

C #, 120 115 bajtów

Pętla przechodzi przez to, char[]co otrzymuje jako dane wejściowe i zwraca true lub false:

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;}

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

Jestem pewien, że potrafię zeskrobać kilka bajtów, zwłaszcza w nieuporządkowanym miejscu return. Wszelkie pomysły mile widziane!

Edycja: Zaoszczędzono 5 bajtów dzięki Kevinowi. Nie miałem pojęcia, że ​​mógłbym użyć &zamiast &&!

PHP, 86 85 84 83 82 79 bajtów

Uwaga: używa PHP 7.1 do ujemnych indeksów ciągów.

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

Uruchom tak:

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

Wersja dla PHP <7.1 (+10 bajtów)

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

Wyjaśnienie

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.

Poprawki

• Krótszy sposób rozróżnienia pustego ciągu i "0"zapisanego bajtu
• Ponieważ 10000000jest nieprawidłowy, nie trzeba go porównywać greater than or equals, greater thanwystarczy zaoszczędzić bajt
• Krótszy sposób na odjęcie najmniej znaczącej cyfry
• Neguj char zamiast XOR, oszczędzając bajt
• Zapisano 3 bajty za pomocą, -Raby $argnudostępnić

Java 8, 115 98 bajtów

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;}

Dziwi mnie, że nikt jeszcze nie opublikował odpowiedzi w języku Java, więc oto jedna.

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów

Cóż, to jest coś, -odejmuje resztę argumentów od pierwszego, aby obsłużyć specjalny przypadek wagi -1. Ta funkcja zwraca nildane wejściowe o niepoprawnej długości, ale w ifklauzulach działają one tak samo jak false. (#{8 9}(count v))zwraca, niljeśli długość vnie jest równa 8 lub 9.

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

Przypadki testowe:

(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 bajtów

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

Wypróbuj online!

Stax , 23 bajty

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

Uruchom i debuguj online!

Wyjaśnienie

Używa rozpakowanej wersji do wyjaśnienia.

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.