Giới thiệu:

Một BSN của Hà Lan (BurgerServiceNummer) là hợp lệ khi nó tuân thủ các quy tắc sau:

• Nó chỉ chứa các chữ số.
• Chiều dài phải là 8 hoặc 9 chiều dài.
• Khi các chữ số được lập chỉ mục là Athông qua I, kết quả của tổng sau: 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI(LƯU Ý -1 thay vì 1!) Sẽ chia hết cho 11 và không được bằng 0.

Thử thách:

Dữ liệu vào: Một chuỗi hoặc mảng char đại diện cho BSN.

Output: Một truthy hoặc falsey kết quả cho dù đầu vào là một BSN hợp lệ.

Quy tắc thử thách:

• Định dạng đầu vào phải là một chuỗi hoặc mảng char. Bạn không được phép sử dụng một mảng các chữ số hoặc một số (có thể là số bát phân). (Tuy nhiên, bạn được phép tự chuyển đổi nó thành một mảng các chữ số, nhưng không trực tiếp làm đối số.)
• Mặc dù hạn chế về đầu vào ở trên, bạn có thể giả sử tất cả các trường hợp kiểm tra sẽ chứa một hoặc nhiều chữ số ( [0-9]+)
• Về BSN với độ dài 8 thay vì 9, Wikipedia tiếng Hà Lan nêu rõ như sau: " Đối với bài kiểm tra mười một và cho các mục đích sử dụng thực tế khác, một số 0 đứng đầu được thêm vào để tạo ra số độ dài 9. " ( nguồn )

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

Các trường hợp thử nghiệm:

// 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Ê

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

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

Đầu vào như một mảng ký tự. reduceRighttiết kiệm trong ngày!

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

Kiểm tra

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

Chỉnh sửa: Cảm ơn Jarko Dubbeldam đã gợi ý sản phẩm chấm!

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

Đọc đầu vào từ stdin và lưu trữ dưới dạng một mảng / vectơ ký tự. Sau đó chuyển đổi thành số, nhân với vectơ 9...2,-1và kiểm tra tất cả các điều kiện.

JavaScript (ES6), 61 60 59 58 byte

Lấy một mảng ký tự làm đầu vào. Trả về false/ true.

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

Các trường hợp thử nghiệm

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

Cảm ơn @MartinEnder đã lưu 5 3 byte trong khi sửa mã của tôi !

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

Trả về 0 nếu không hợp lệ, 1 nếu hợp lệ. Hãy thử trực tuyến!

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

Hàm không tên lấy một chuỗi làm đối số. Lúc đầu, tôi đã đọc được yêu cầu phải có một chuỗi làm đầu vào thay vì một số, nhưng điều đó tốt, bởi vì nó tiết kiệm một số byte khi chuyển đổi.

Tôi không chắc làm thế nào để diễn giải mảng các ký tự, nhưng nếu điều đó có nghĩa là bạn có thể sử dụng một vectơ các chữ số được xâu chuỗi "1" "2" "3" "4" etclàm đầu vào, nó sẽ trở nên ngắn hơn một chút:

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

Chia x thành một vectơ số, sau đó nối thêm 0 nếu độ dài bằng 8, sau đó tính toán sản phẩm chấm của vectơ y và c(9,8,7,6,5,4,3,2,-1) . Thử nghiệm nếu kết quả là cả khác không và chia hết cho 11.

Đã lưu 16 byte nhờ logic của @Enigma, hoàn toàn nối thêm 0 vào việc tạo vectơ c(length(x):2,-1) .

Quên để thêm kiểm tra độ dài 8/9, vì vậy +14 byte :(

Perl, 58 byte (52 + 6)

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

Chạy với

perl -F// -lapE

Đầu vào đi qua STDIN :

Sử dụng

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

Đầu ra 1cho giá trị trung thực, 0hoặc không có gì cho giá trị falsey.

C ++ 14, 107 106 byte

-1 byte intthay vì autotrong vòng lặp for.

Như lambda chưa được đặt tên trở lại thông qua tham số tham chiếu. Yêu cầu đầu vào phải là std::stringhoặc một thùng chứa char, như 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 và cách sử dụng:

#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+*-<<

Hãy thử trực tuyến!

Giải trình

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

Không phải là chương trình MATL dài nhất tôi từng viết , nhưng tôi thích cách các câu lệnh if/ elsecâu rất dài rất nhanh trong các ngôn ngữ chơi gôn. Tôi cảm thấy giải pháp này có thể không tối ưu trong MATL, nhưng đến giờ tôi không thể tối ưu hóa thêm nữa. Tôi đang nghĩ đến việc sử dụng số 0 ở đâu đó và có thể cắt giảm tmọi nơi.

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

Hãy thử trực tuyến! Giải trình:

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

Kết quả là một vectơ cột không trống, đó là sự thật nếu tất cả các mục của nó là khác không .

Hãy thử trực tuyến!

Hoặc xác minh tất cả các trường hợp thử nghiệm với mỗi kết quả trên một dòng khác nhau.

Giải trình

Điều này kiểm tra ba điều kiện theo thứ tự sau:

1. Tổng trọng số là khác không;
2. Tổng trọng số được chia cho 11;
3. Chiều dài là 8 hoặc 9.

Xem xét đầu vào '8925'cho lời giải thích. ;là dấu phân cách hàng cho ma trận.

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

gđếm tổng được sử dụng trong mười một proef của h, trong khi fcũng kiểm tra độ dài chính xác và mười một proef không bằng 0. Đặc biệt là các kiểm tra fmất rất nhiều byte.

EDIT: đã lưu 10 byte nhờ Lynn và divlàm tròn xuống.

Thạch , 21 byte

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

Dùng thử trực tuyến! hoặc chạy tất cả các trường hợp thử nghiệm

Các giá trị trả về trung thực là khác không (và trên thực tế là bội số của 11 tổng).

Làm sao?

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

Lấy một chuỗi làm đầu vào. Hàm thêm một'0' mặt trước của chuỗi cho dù nó có cần hay không và sử dụng các chỉ số phủ định của Python để thêm các phần tử, bắt đầu từ cuối chuỗi và hoạt động từ trước ra trước.

Việc -1xInày được xử lý riêng, sử dụng cuộc gọi thứ hai đến int(). Tôi không thể tìm ra cách tránh điều này mà không tốn nhiều byte hơn mức tôi đã lưu.

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)*ucũng sẽ hoạt động tốt, vì nó sẽ thêm 1thời gian s[-1]nhưng sau đó trừ đi hai lần, và nó cũng sẽ thêm 0thời gian (một cái gì đó) tất nhiên sẽ không ảnh hưởng đến tổng.

Brain-Flak , 345 byte

Bao gồm +3 cho -a

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

Truthy là 1, Falsy có 0 trên đỉnh của ngăn xếp.

Hãy thử trực tuyến!

Tôi khá chắc chắn rằng có một cách ngắn hơn để thực hiện phép nhân trong một vòng lặp, nhưng tôi chưa tìm thấy nó.

#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, tôi sẽ thừa nhận, điều này trông giống như một mớ hỗn độn. Và nó là như vậy. Nhưng, hãy chịu đựng tôi và chúng ta sẽ vượt qua nó.

Chúng tôi lấy đầu vào $n(dưới dạng char-array) và đặt $ibằng với 8giá trị Boolean cho dù có 8 mục trong $n. Có nghĩa là, nếu có 8 mục, thì $isẽ được 7.

Phần tiếp theo kết hợp tính toán với đầu ra của chúng tôi. Làm việc từ bên trong, chúng tôi lặp qua $nvới $n|%{...}. Mỗi lần lặp, chúng tôi sử dụng một pseudo-ternary để đến với một trong hai kết quả - một trong hai -"$_"hoặc (($i+1)*+"$_"). Chỉ số này dựa trên việc $icó 0hay không (nghĩa là chúng ta đã gặp -1xItrường hợp từ phương trình thách thức), được giảm sau cho vòng tiếp theo. Tất cả được tập hợp lại trong parens và -joined cùng với +. Ví dụ: với đầu vào 111222333tại thời điểm này, chúng tôi sẽ có 9+8+7+12+10+8+9+6+-3. Đó là đường ống đến iex(viết tắt củaInvoke-Expression và tương tự eval) trước khi được lưu trữ vào $b. Sau đó chúng tôi lấy nó %11và thực hiện Boolean-not!(...)trên đó (nghĩa là, nếu nó chia hết cho 11, phần này là$true). Điều đó được kết hợp với -and$bđể đảm bảo rằng $bkhác không. Kết quả Boolean đó được để lại trên đường ống và đầu ra là ẩn.

Ví dụ

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

Không thể có được CLI để chỉ lặp lại đúng sự thật. Phải làm theo cách này. Có ý kiến ​​gì không?

128 byte: Biến "true" và "false" thành 1 và 0.

C #, 120 115 byte

Vòng lặp này thông qua char[]nó nhận làm đầu vào và trả về true hoặc 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;}

Câu đố: https://dotnetfiddle.net/3Kaxrt

Tôi chắc chắn rằng tôi có thể loại bỏ một vài byte, đặc biệt là trong sự lộn xộn return. Mọi ý tưởng đều được chào đón!

Chỉnh sửa: Đã lưu 5 byte nhờ Kevin. Tôi không có ý tưởng tôi có thể sử dụng &thay vì &&!

PHP, 86 85 84 83 82 79 byte

Lưu ý: sử dụng PHP 7.1 cho các chỉ số chuỗi âm.

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

Chạy như thế này:

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

Phiên bản cho 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

Giải trình

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.

Tinh chỉnh

• Cách ngắn hơn để phân biệt giữa chuỗi rỗng và "0" , đã lưu một byte
• Vì 10000000không hợp lệ, không cần so sánh với greater than or equals,greater than đủ, lưu một byte
• Cách ngắn hơn để trừ chữ số có nghĩa nhỏ nhất
• Phủ định char thay vì XOR, tiết kiệm một byte
• Đã lưu 3 byte bằng cách sử dụng -Rđể $argncung cấp

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

Tôi ngạc nhiên không ai đã đăng một câu trả lời Java, vì vậy đây là một câu trả lời.

Giải trình:

Hãy thử nó ở đây.

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

Vâng, đây là một cái gì đó, tạo -ra phần còn lại của các đối số từ cái đầu tiên để xử lý trường hợp đặc biệt của trọng lượng -1. Hàm này trả về nilcác đầu vào có độ dài không hợp lệ, nhưng trên ifcác mệnh đề chúng hoạt động giống như false. (#{8 9}(count v))trả về nilnếu độ dài vkhông phải là 8 hoặc 9.

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

Các trường hợp thử nghiệm:

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

Hãy thử trực tuyến!

Stax , 23 byte

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

Chạy và gỡ lỗi trực tuyến!

Giải trình

Sử dụng phiên bản giải nén để giải thích.

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.