Giriş:

Bir Hollandalı BSN (BurgerServiceNummer), aşağıdaki kurallara uyduğunda geçerlidir:

• Sadece rakam içeriyor.
• Uzunluk 8 veya 9 uzunlukta olmalıdır.
• Rakamlar Aiçinden olduğu gibi endekslendiğinde I, aşağıdaki toplamın sonucu: 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI(1! Yerine -1!) Not 11 ile bölünebilir olmalı ve 0 olmamalıdır.

Meydan okuma:

Giriş: BSN'yi temsil eden bir dize veya karakter dizisi.

Çıktı: Girinin geçerli bir BSN olup olmadığına ilişkin bir gerçek veya yanlış sonuç.

Mücadele Kuralları:

• Giriş formatı bir dizge veya karakter dizisi olmalıdır. İnt dizisi veya bir (muhtemelen sekizli) sayı kullanmanıza izin verilmez. (Ancak, kendiniz, ancak doğrudan bir argüman olarak değil, bir int dizisine dönüştürmenize izin verilir.)
• Yukarıdaki giriş üzerindeki kısıtlamaya rağmen, tüm test durumlarının bir veya daha fazla basamak içereceğini varsayabilirsiniz ( [0-9]+)
• BSN ile ilgili olarak, 9 yerine 8 uzunluğuyla, Hollandalı Vikipedi, şunları ifade eder: " Onbirlik test ve diğer pratik kullanımlar için, uzunluk 9'unu yapmak için önde gelen sıfır eklenir. " ( Kaynak )

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyonlar / yöntem ile uygun parametreler, tam programlar kullanabilirsiniz. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, lütfen gerekirse bir açıklama ekleyin.

Test durumları:

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

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

05AB1E , 23 21 bayt

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

Çevrimiçi deneyin! veya Test paketi olarak

açıklama

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

Karakter dizisi olarak giriş yapın. reduceRightgünü kurtarıyor!

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

Ölçek

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 bayt

Düzenleme: Nokta ürünü önerdiğiniz için Jarko Dubbeldam'a teşekkürler!

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

Stdin'den giriş okur ve karakter dizisi / vektörü olarak saklar. Daha sonra sayısal olarak dönüştürün, vektörle çarpın 9...2,-1ve tüm koşulları kontrol edin.

JavaScript (ES6), 61 60 59 58 bayt

Giriş olarak bir dizi karakter alır. Döndürür false/ true.

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

Test durumları

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 bayt

Kaydetmek için @MartinEnder sayesinde 5 3 bayt kodumu sabitleme ederken !

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

Geçersiz ise 0, geçerli ise 1 döndürür. Çevrimiçi deneyin!

R, 95 79 93 bayt

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

Bir dizgeyi argüman olarak alan isimsiz işlev. İlk başta bir string yerine sayı olarak giriş yapma gereğinin üstesinden geldim, ancak bu iyi, çünkü dönüşümde bazı baytları kurtarıyor.

Karakter dizisini nasıl yorumlayacağımdan emin değilim, ancak eğer dizge dizelerinin bir vektörünü "1" "2" "3" "4" etcgirdi olarak kullanabileceğiniz anlamına gelirse, bu biraz daha kısalır:

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

X'i sayısal bir vektöre böler, sonra uzunluk 8 ise 0 ekler ve y vektörünün dotproduct değerini hesaplar c(9,8,7,6,5,4,3,2,-1). Sonucun hem sıfır hem de 11 ile bölünebilir olup olmadığını test eder.

@Enigma mantığı sayesinde 16 bayt kurtarıldı, dolaylı olarak vektörün oluşturulmasına 0 ekleyin c(length(x):2,-1).

Uzunluk 8/9 için çek eklemeyi unuttum, yani +14 bayt :(

Perl, 58 bayt (52 + 6)

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

İle koş

perl -F// -lapE

Giriş geçti STDIN:

kullanım

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

Çıkışlar 1truthy değeri olarak için 0Falsey değerleri için ya da hiçbir şey.

C ++ 14, 107 106 bayt

Döngü intyerine -1 bayt auto.

Adsız lambda olarak referans parametresiyle döndürülüyor. Giriş olmasını std::stringveya benzeri bir char kabını gerektirir 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 ve kullanım:

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

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

Çevrimiçi deneyin!

açıklama

>+~>: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 bayt

Bugüne kadar yazdığım en uzun MATL programı değil , ancak golf dillerinde if/ elsecümlelerin çok çabuk uzamasını seviyorum . Bu çözümün MATL'de optimal olamayacağını düşünüyorum, ancak henüz daha fazla optimize edemiyorum. Duble 0'ı bir yerde kullanmayı düşünüyorum ve belki theryerde kesiliyor .

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

Çevrimiçi deneyin! Açıklama:

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 bayt

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

Sonuç, tüm girişlerin sıfır olmadığından çok açık olmayan boş bir sütun vektörüdür .

Çevrimiçi deneyin!

Veya tüm test durumlarını her bir sonuç için farklı bir satırda doğrulayın .

açıklama

Bu, üç koşulu aşağıdaki sırayla test eder:

1. Ağırlıklı toplam sıfır değildir;
2. Ağırlıklı toplam 11 ile bölünebilir;
3. Uzunluk 8 veya 9.

'8925'Açıklama için girişi göz önünde bulundurun . ;matrisler için satır ayırıcı.

!     % 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 bayt

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

gayrıca on bir proefte kullanılan toplamı sayar h, aynı fzamanda doğru uzunluğu kontrol eder ve onbir proef'in 0 olmadığını kontrol eder. Özellikle de çekleri fçok fazla bayt alır.

EDIT: Lynn sayesinde ve divyuvarlama sayesinde 10 bayt kurtardı .

Jöle , 21 bayt

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

TryItOnline! veya tüm test durumlarını çalıştır

Truthy return değerleri sıfır değildir (ve aslında 11 toplamın katıdır).

Nasıl?

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 bayt

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 bayt

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

Giriş olarak bir dize alır. İşlev '0', gerekip gerekmediğini dize önüne a ekler ve öğe eklemek için dizenin sonundan başlayarak ve arkaya doğru çalışan Python'un negatif dizinlerini kullanır.

Bu -1xI, ikinci bir çağrı kullanılarak ayrı ayrı ele alınır int(). Tasarruf ettiğimden daha fazla bayta mal olmadan bunu nasıl önleyeceğimi bilemedim.

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)*uo eklersiniz beri sadece de çalışmak 1kez s[-1]ama sonra iki kez çıkarma ve ayrıca eklemek istiyorum 0tabii toplamını etkilemeyeceği kez (bir şey).

Brain-Flak , 345 Bayt

İçin +3 içerir -a

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

Truthy 1, Falsy yığının tepesinde 0'a sahip.

Çevrimiçi Deneyin!

Çarpma işlemini bir döngüde yapmanın daha kısa bir yolu olduğundan eminim, ancak henüz bulamadım.

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

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

Tamam, itiraf edeceğim, bu tam bir karmaşa gibi görünüyor. Ve biraz öyle. Ama, benimle kal ve bunu başaracağız.

Girdiyi $n( char-array olarak) alırız ve eksi Boolean değerine $ieşit olarak ayarlayıp 88 öğenin olup olmadığına bakarız $n. Yani, 8 madde varsa o $izaman olur 7.

Bir sonraki bölüm hesaplamayı çıktılarımızla birleştiriyor. İçeriden çalışarak $nbirlikte dönüyoruz $n|%{...}. Her yinelemede, iki sonuçtan birini ya -"$_"da - ya ortaya çıkarmak için sahte-üçlü kullanırız (($i+1)*+"$_"). Endeks olmadığına dayanmaktadır $iolduğu 0veya olmasın (yani biz isabet ettik -1xIalır meydan denklemden dava) sonraki seferde yuvarlak için sonradan indirildiği. Bunların hepsi parens içinde toplanmış ve -joinbirlikte +. Mesela 111222333bu noktada giriş yapmış olurduk 9+8+7+12+10+8+9+6+-3. Bu depolanmadan önce iex(kısa Invoke-Expressionve şuna benzer eval) borulanır $b. Sonra bunu alırız %11ve bir Boole gerçekleştiririz!(...)Bunun üzerine (yani, eğer 11 ile bölünebilir ise, bu kısım $true). Sıfır -and$bolmadığından emin olmak $biçin birleştiğinde . Bu Boolean sonucu boru hattında bırakılır ve çıktı kesindir.

Örnekler

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 bayt

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

CLI'nin yanlış olanın gerçekliğini yansıtması mümkün değildi. Bu şekilde yapmak zorunda kaldı. Herhangi bir fikir?

128 bayt: "true" ve "false" öğelerini 1 ve 0 olarak değiştirdi.

C #, 120 115 bayt

Bu, içinden döngüler char[]girdi olarak alır ve doğru ya da yanlış döndürür:

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

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

Eminim özellikle dağınık halde birkaç byte çıkarabilirim return. Herhangi bir fikir hoş geldiniz!

Düzenleme: Kevin sayesinde 5 bayt kaydedildi. Bunun &yerine kullanabileceğim hakkında hiçbir fikrim yoktu &&!

PHP, 86 85 84 83 82 79 bayt

Not: Negatif string endeksleri için PHP 7.1 kullanır.

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

Bu şekilde koş:

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

PHP için Sürüm <7.1 (+10 bayt)

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

açıklama

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.

Düzenlemeler

• Boş dize ve ayırt etmek için kısa yol "0", bir bayt kaydedildi
• Beri 10000000geçersiz, gerek ile karşılaştırmak greater than or equals, greater thanbir bayt tasarruf kısıtlamasını fazla
• En az anlamlı basamağı çıkartmanın daha kısa yolu
• Bir bayt tasarrufu yaparak, XOR yerine char'i negatif olarak işaretleyin
• Kullanılabilir -Rhale getirmek için 3 bayt kaydedildi$argn

Java 8, 115 98 bayt

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

Henüz kimsenin Java cevabı göndermediğine şaşırdım, bu yüzden işte bir tane.

Açıklama:

Burada dene.

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 bayt

Eh, bu bir şeydir, -argümanların geri kalanını ilk ağırlıktan alır, böylece özel ağırlık durumunu ele alır -1. Bu işlev nilgeçersiz uzunluktaki girişler için döner , ancak ifcümlelerde aynı şekilde çalışırlar false. uzunluğu 8 veya 9 değilse, (#{8 9}(count v))döndürür .nilv

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

Test durumları:

(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 bayt

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

Çevrimiçi deneyin!

Stax , 23 bayt

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

Çevrimiçi çalıştırın ve hata ayıklayın!

açıklama

Açıklamak için paketlenmemiş sürümü kullanır.

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.