Pengantar:

BSN Belanda (BurgerServiceNummer) valid ketika mematuhi aturan berikut:

• Hanya berisi digit.
• Panjangnya harus 8 atau 9 panjangnya.
• Ketika digit diindeks Amelalui I, hasil dari jumlah berikut: 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI(Perhatikan -1 bukannya 1!) Harus habis dibagi 11, dan tidak boleh 0.

Tantangan:

Input: String atau char-array yang mewakili BSN.

Keluaran: Hasil yang benar atau salah apakah input tersebut merupakan BSN yang valid.

Aturan Tantangan:

• Format input harus berupa string atau char-array. Anda tidak diizinkan untuk menggunakan int-array angka, atau nomor (mungkin oktal). (Namun Anda diizinkan untuk mengonversinya menjadi int-array angka, tetapi tidak secara langsung sebagai argumen.)
• Meskipun ada pembatasan pada input di atas, Anda dapat mengasumsikan semua test case akan berisi satu atau lebih digit ( [0-9]+)
• Mengenai BSN dengan panjang 8 dan bukan 9, Wikipedia Belanda menyatakan sebagai berikut: " Untuk uji sebelas dan untuk penggunaan praktis lainnya, nol terkemuka ditambahkan untuk membuat jumlah panjang 9. " ( sumber )

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat, program lengkap. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.
• Juga, silakan tambahkan penjelasan jika perlu.

Kasus uji:

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

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

05AB1E , 23 21 byte

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

Cobalah online! atau sebagai Test suite

Penjelasan

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

Input sebagai array karakter. reduceRighthemat hari ini!

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

Uji

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 byte

Sunting: Terima kasih kepada Jarko Dubbeldam karena menyarankan produk titik!

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

Membaca input dari stdin dan menyimpan sebagai array / vektor karakter. Selanjutnya dikonversi ke numerik, gandakan dengan vektor 9...2,-1dan periksa semua kondisi.

JavaScript (ES6), 61 60 59 58 byte

Mengambil array karakter sebagai input. Pengembalian false/ true.

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

Uji kasus

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 byte

Terima kasih kepada @MartinEnder karena telah menghemat 5 3 byte sambil memperbaiki kode saya !

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

Mengembalikan 0 jika tidak valid, 1 jika valid. Cobalah online!

R, 95 79 93 byte

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

Fungsi tanpa nama yang menggunakan string sebagai argumen. Pada awalnya saya mengedepankan persyaratan memiliki string sebagai input, bukan angka, tapi itu bagus, karena menghemat beberapa byte pada konversi.

Saya tidak yakin bagaimana menafsirkan array karakter, tetapi jika itu berarti bahwa Anda dapat menggunakan vektor dari angka "1" "2" "3" "4" etc- angka bersenar sebagai input, itu bahkan menjadi sedikit lebih pendek:

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

Pisahkan x menjadi vektor numerik, kemudian tambahkan 0 jika panjangnya 8, kemudian hitung produk titik dari vektor y dan c(9,8,7,6,5,4,3,2,-1). Menguji apakah hasilnya bukan nol dan dapat dibagi dengan 11.

Disimpan 16 byte berkat logika oleh @ Enigma, secara implisit menambahkan 0 dalam pembuatan vektor c(length(x):2,-1).

Lupa menambahkan cek untuk panjang 8/9, jadi +14 byte :(

Perl, 58 byte (52 + 6)

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

Jalankan dengan

perl -F// -lapE

Input melewati STDIN:

Pemakaian

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

Outputs 1sebagai nilai kebenaran, 0atau tidak ada nilai falsey.

C ++ 14, 107 106 byte

-1 byte sebagai intganti autoin untuk loop.

Sebagai lambda tanpa nama kembali melalui parameter referensi. Membutuhkan input untuk menjadi std::stringatau wadah char, suka 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;}

Tidak digabungkan dan digunakan:

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

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

Cobalah online!

Penjelasan

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

Bukan program MATL terpanjang yang pernah saya tulis , tapi saya suka bagaimana if/ elsepernyataan menjadi sangat panjang dengan sangat cepat dalam bahasa golf. Saya merasa bahwa solusi ini mungkin tidak optimal di MATL, tetapi sampai sekarang saya tidak dapat mengoptimalkannya lebih jauh. Saya sedang berpikir untuk menggunakan 0 ganda di suatu tempat, dan mungkin mengurangi tdi mana-mana.

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

Cobalah online! Penjelasan:

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 byte

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

Hasilnya adalah vektor kolom non-kosong, yang benar jika semua entri adalah nol .

Cobalah online!

Atau verifikasi semua kasus uji dengan setiap hasil pada jalur yang berbeda.

Penjelasan

Ini menguji tiga kondisi dalam urutan berikut:

1. Jumlah tertimbang bukan nol;
2. Jumlah tertimbang dibagi dengan 11;
3. Panjangnya 8 atau 9.

Pertimbangkan masukan '8925'untuk penjelasannya. ;adalah pemisah baris untuk matriks.

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

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

gmenghitung jumlah yang digunakan dalam sebelas-proef h, sementara fjuga memeriksa untuk panjang yang benar dan bahwa sebelas-proef tidak 0. Terutama cek fmengambil banyak byte.

EDIT: disimpan 10 byte berkat Lynn dan divpembulatan ke bawah.

Jelly , 21 byte

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

TryItOnline! atau jalankan semua test case

Nilai-nilai pengembalian yang sebenarnya adalah nol (dan, pada kenyataannya, merupakan kelipatan dari 11 jumlah).

Bagaimana?

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 byte

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 byte

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

Mengambil string sebagai input. Fungsi menambahkan a '0'ke bagian depan string, apakah itu memerlukan atau tidak, dan menggunakan indeks negatif Python untuk menambahkan elemen, mulai dari ujung string dan bekerja kembali ke depan.

Ini -1xIditangani secara terpisah, menggunakan panggilan kedua ke int(). Saya tidak tahu cara menghindari ini tanpa biaya lebih banyak byte daripada yang saya simpan.

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)*uakan bekerja dengan baik, karena itu akan menambah 1waktu s[-1]tetapi kemudian kurangi dua kali, dan itu juga akan menambah 0waktu (sesuatu) yang tentu saja tidak akan mempengaruhi jumlah.

Brain-Flak , 345 Bytes

Termasuk +3 untuk -a

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

Truthy adalah 1, Falsy memiliki 0 di bagian atas tumpukan.

Cobalah secara Online!

Saya cukup yakin ada cara yang lebih pendek untuk melakukan perkalian dalam satu lingkaran, tetapi saya belum menemukannya.

#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, saya akui, ini sepertinya berantakan total. Dan itu agak. Tapi, bersabarlah dan kami akan melewatinya.

Kami mengambil input $n(sebagai char-array) dan menetapkan $isama dengan 8minus nilai Boolean untuk apakah ada 8 item dalam $n. Artinya, jika ada 8 item, maka $iakan menjadi 7.

Bagian selanjutnya menggabungkan perhitungan dengan output kami. Bekerja dari dalam, kami mengulanginya $ndengan $n|%{...}. Setiap iterasi, kami menggunakan pseudo-ternary untuk menghasilkan satu dari dua hasil - baik -"$_"atau (($i+1)*+"$_"). Indeks ini didasarkan pada apakah $iini 0atau tidak (yaitu, kami telah memukul -1xIkasus dari persamaan tantangan), yang mendapat pasca-dikurangi untuk go-babak berikutnya. Itu semua dikumpulkan di parens dan diedit -joinbersama +. Sebagai contoh, dengan input yang 111222333kami miliki saat ini 9+8+7+12+10+8+9+6+-3. Itu disalurkan ke iex(kependekan Invoke-Expressiondan mirip dengan eval) sebelum disimpan ke $b. Kami kemudian mengambil itu %11dan melakukan Boolean-tidak!(...)pada itu (yaitu, jadi jika habis dibagi 11, bagian ini $true). Itu digabungkan dengan -and$buntuk memastikan bahwa $bitu bukan nol. Hasil Boolean ditinggalkan di jalur pipa dan hasilnya tersirat.

Contohnya

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 byte

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

Tidak bisa mendapatkan CLI untuk hanya mengulangi kebenaran salah. Harus melakukannya dengan cara ini. Ada ide?

128 byte: Mengubah "true" dan "false" ke 1 dan 0.

C #, 120 115 byte

Ini loop melalui char[]menerima sebagai input dan mengembalikan benar atau salah:

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

Saya yakin saya bisa mengikis beberapa byte, terutama di berantakan return. Ada ide selamat datang!

Sunting: Disimpan 5 byte berkat Kevin. Aku tidak tahu saya bisa menggunakan &bukan &&!

PHP, 86 85 84 83 82 79 byte

Catatan: menggunakan PHP 7.1 untuk indeks string negatif.

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

Jalankan seperti ini:

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

Versi untuk PHP <7.1 (+10 byte)

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

Penjelasan

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.

Tweaks

• Cara yang lebih pendek untuk membedakan antara string kosong dan "0", menyimpan satu byte
• Karena 10000000tidak valid, tidak perlu membandingkan dengan greater than or equals, greater thancukup, menghemat satu byte
• Cara yang lebih pendek untuk mengurangi digit paling tidak signifikan
• Meniadakan char, bukan XOR, menyimpan byte
• Disimpan 3 byte dengan menggunakan -Ragar $argntersedia

Java 8, 115 98 byte

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

Saya terkejut belum ada yang mengirim jawaban Java, jadi di sini ada satu.

Penjelasan:

Coba di sini.

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 byte

Nah ini adalah sesuatu, -kurangi sisa argumen dari yang pertama sehingga menangani kasus berat khusus -1. Fungsi ini mengembalikan nilinput dengan panjang yang tidak valid, tetapi pada ifklausa mereka beroperasi sama dengan false. (#{8 9}(count v))kembali niljika panjangnya vbukan 8 atau 9.

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

Kasus uji:

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

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

Cobalah online!

Stax , 23 byte

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

Jalankan dan debug online!

Penjelasan

Gunakan versi yang belum dibongkar untuk menjelaskan.

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.