소개:

네덜란드어 BSN (BurgerServiceNummer)은 다음 규칙을 준수 할 때 유효합니다.

• 숫자 만 포함합니다.
• 길이는 8 또는 9 여야합니다.
• 숫자가 Athrough 로 색인화 될 때 I다음 합계의 결과 : 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI(1 대신 -1!)는 11로 나눌 수 있으며 0이 아니어야합니다.

도전:

입력 : BSN을 나타내는 문자열 또는 문자 배열.

출력 : truthy 또는 falsey 입력이 유효인지 BSN 결과.

도전 규칙 :

• 입력 형식은 문자열 또는 문자 배열이어야합니다. int-array 자릿수 또는 (아마도 8 진수) 숫자를 사용할 수 없습니다. (단, 직접 숫자로 int- 배열로 변환 할 수는 있지만 직접 인수로 사용할 수는 없습니다.)
• 위의 입력에 대한 제한에도 불구하고 모든 테스트 사례에 하나 이상의 숫자 ( [0-9]+) 가 포함된다고 가정 할 수 있습니다.
• 길이 8 대신에 9로 BSN에 대해서는, 네덜란드 인 위키 백과는 다음을 말한다 : " 열한 테스트 및 다른 실용적인 용도, 길이 9의 숫자를 만들기 위해 추가 앞에 0 "( 소스 )

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수가있는 기능 / 방법, 전체 프로그램을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 필요한 경우 설명을 추가하십시오.

테스트 사례 :

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

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

05AB1E , 23 21 바이트

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

온라인으로 사용해보십시오! 또는 테스트 스위트

설명

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

자바 스크립트 (ES6) 57

문자 배열로 입력하십시오. reduceRight하루를 저장합니다!

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

테스트

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 바이트

편집 : 도트 제품을 제안 해 주신 Jarko Dubbeldam에게 감사드립니다!

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

stdin에서 입력을 읽고 문자 배열 / 벡터로 저장합니다. 이후 숫자로 변환하고 벡터 9...2,-1와 곱하고 모든 조건을 확인하십시오.

자바 스크립트 (ES6), 61 60 59 58 바이트

문자 배열을 입력으로 사용합니다. false/를 반환 true합니다.

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

테스트 사례

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 바이트

내 코드를 수정하는 동안 5 3 바이트 를 절약 한 @MartinEnder에게 감사드립니다 !

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

유효하지 않은 경우 0을, 유효하면 1을 리턴합니다. 온라인으로 사용해보십시오!

R, 95 79 93 바이트

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

문자열을 인수로 취하는 이름없는 함수. 처음에는 숫자 대신 입력으로 문자열을 가져야하는 요구 사항을 읽었지만 변환에 약간의 바이트가 절약되므로 좋습니다.

문자 배열을 해석하는 방법을 잘 모르겠지만 문자열 숫자 벡터 "1" "2" "3" "4" etc를 입력으로 사용할 수 있다면 조금 더 짧아집니다.

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

x를 숫자 형 벡터로 나누고 길이가 8 인 경우 0을 더한 다음 벡터 y의 내적을 계산합니다. c(9,8,7,6,5,4,3,2,-1) . 결과가 0이 아니고 11로 나눌 수 있는지 테스트합니다.

@Enigma의 논리 덕분에 16 바이트를 절약하고 벡터 생성시 0을 암시 적으로 추가했습니다 c(length(x):2,-1).

길이 8/9에 대한 검사를 추가하지 않았으므로 +14 바이트 :(

펄, 58 바이트 (52 + 6)

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

로 실행

perl -F// -lapE

통과 한 입력 STDIN :

용법

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

1진솔한 값으로 출력 0하거나 거짓된 값으로 출력 하지 않습니다.

C ++ 14, 107 바이트

에 대한 -1 바이트 int대신에autofor 루프 .

참조 매개 변수를 통해 반환되는 명명되지 않은 람다. 입력은 std::string또는 이와 같은 char 컨테이너 여야합니다 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;}

언 골프 및 사용법 :

#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 바이트

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

온라인으로 사용해보십시오!

설명

>+~>: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 바이트

아니 긴 MATL 프로그램 내가 지금까지 쓴 방법과 같은,하지만 난 if/ else문 언어 골프에서 매우 빠르게 아주 긴 얻을. 이 솔루션이 MATL에서 최적이 아닐 수도 있지만 아직은 더 이상 최적화 할 수 없습니다. 어딘가에 이중 0을 사용하려고 생각하고 어딘가에서 줄어 듭니다 t.

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

온라인으로 사용해보십시오! 설명:

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 바이트

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

결과는 비어 있지 않은 열 벡터이며, 모든 항목이 0이 아닌 경우 에는 사실 입니다.

온라인으로 사용해보십시오!

또는 각 결과가 다른 줄에 모든 테스트 사례 를 확인하십시오 .

설명

이렇게하면 세 가지 조건이 다음 순서로 테스트됩니다.

1. 가중 합계는 0이 아닙니다.
2. 가중 합계는 11로 나눌 수 있습니다.
3. 길이는 8 또는 9입니다.

'8925'설명을 위해 입력 을 고려하십시오 . ;행렬의 행 구분 기호입니다.

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

하스켈, 116 (112) 102 바이트

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의 열한 계수에 사용 된 합계를 세는 h동시에 f올바른 길이를 검사하고 열한 계수는 0이 아닙니다. 특히f 에는 많은 바이트가 사용됩니다.

편집 : Lynn과 div반올림 덕분에 10 바이트를 절약 했습니다.

젤리 , 21 바이트

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

TryItOnline! 또는 모든 테스트 사례를 실행

확실한 반환 값은 0이 아니며 실제로는 11의 배수입니다.

방법?

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)

파이썬 2, 102 바이트

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

파이썬 2, 96 바이트

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

문자열을 입력으로 사용합니다. 이 기능은'0' 문자열의 필요 여부에 관계없이 문자열 앞에 를 파이썬의 음수 색인을 사용하여 문자열의 끝에서 시작하여 앞뒤로 요소를 추가합니다.

에 -1xI대한 두 번째 호출을 사용하여int() . 내가 저장 한 것보다 더 많은 바이트를 소비하지 않고 이것을 피하는 방법을 알 수 없었습니다.

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그것은 1시간 을 더한 s[-1]다음 두 번 빼기 때문에 잘 작동 합니다. 또한 0합에 영향을 미치지 않는 시간 (무언가)을 더할 것입니다.

브레인 플락 , 345 바이트

에 +3 포함 -a

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

Truthy는 1이고 Falsy는 스택 맨 위에 0이 있습니다.

온라인으로 사용해보십시오!

루프에서 곱셈을하는 더 짧은 방법이 있다고 확신하지만 아직 찾지 못했습니다.

#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 바이트

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

좋아, 인정할 것이다. 이것은 완전한 혼란처럼 보인다. 그리고 그것은 다소입니다. 그러나 나와 함께 견뎌내면 우리는 그것을 극복 할 것입니다.

입력 $n( char배열)을 취하고 에 8 개의 항목이 있는지 여부에 대해 부울 값 $i을 8뺀 값 과 같습니다 $n. 즉, 8 개의 품목 $i이 있다면7 입니다.

다음 섹션에서는 계산과 출력을 결합합니다. 내부에서 협력을 통해 우리는 루프 $n와 $n|%{...}. 중 - 반복 할 때마다, 우리는이 개 결과 중 하나 마련하는 의사 원을 사용 -"$_"하거나 (($i+1)*+"$_"). 인덱스가 있는지 여부에 기반 $i입니다 0여부 (즉, 우리가 공격 한 -1xI도착, 도전 식의 경우) 다음의 목마에 대한 게시물을-감소. 그것들은 모두 괄호 안에 모여서 -join함께 합쳐집니다 +. 예를 들어, 111222333이 시점에서 입력 하면을 가질 수 있습니다 9+8+7+12+10+8+9+6+-3. 그것은 그것에 저장되기 전에 ( 와 iex짧고 Invoke-Expression비슷하게 eval) 파이프됩니다 ($b . 그런 다음 그 값을 가져%11 불리언을 수행하지 않습니다!(...)그것에 (즉, 11로 나눌 수 있다면,이 부분은입니다$true). 그것은 0이 아닌 -and$b것을 보장하기 위해 결합 $b됩니다. 해당 부울 결과는 파이프 라인에 남아 있으며 출력은 암시 적입니다.

예

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 139128 바이트

 $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가 true를 true로 에코하도록 할 수 없습니다. 이런 식으로해야했습니다. 어떤 아이디어?

128 바이트 : "true"및 "false"를 1과 0으로 바꿨습니다.

C #을 120 115 바이트

이것은 char[]입력으로 수신하고 true 또는 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;}

피들 : https://dotnetfiddle.net/3Kaxrt

나는 특히 지저분한에서 몇 바이트를 긁을 수 있다고 확신한다 return. 어떤 아이디어라도 환영합니다!

편집 : Kevin 덕분에 5 바이트가 절약되었습니다. &대신 사용할 수있을 줄 몰랐어요 &&!

PHP, 86 85 84 83 82 79 바이트

참고 : 음수 문자열 인덱스에는 PHP 7.1을 사용합니다.

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

다음과 같이 실행하십시오.

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 <7.1 버전 (+10 바이트)

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

설명

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.

조정

• 빈 문자열과을 구별하는 더 짧은 방법 "0", 바이트 저장
• 때문에 10000000무효, 필요와 비교 없습니다 greater than or equals, greater than바이트를 저장하는 접미사
• 최소 유효 숫자를 빼는 더 짧은 방법
• XOR 대신 char를 무효화하여 바이트 저장
• 사용 가능 -R하도록 $argn사용 하여 3 바이트 절약

자바 8, 115 98 바이트

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

아무도 Java 답변을 아직 게시하지 않았으므로 여기에 하나가 있습니다.

설명:

여기에서 시도하십시오.

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

클로저, 114 바이트

글쎄, 이것은 뭔가, -첫 번째 인수에서 나머지 인수를 빼서 특수한 가중치를 처리합니다 -1. 이 함수는 nil유효하지 않은 길이의 입력을 반환 하지만 if절에서와 동일하게 작동합니다 false. 길이 가 8 또는 9가 아닌 경우를 (#{8 9}(count v))반환 nil합니다 v.

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

테스트 사례 :

(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"]}

펄 5 , 63 + 2 ( -F) = 65 바이트

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

온라인으로 사용해보십시오!

Stax , 23 바이트

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

온라인으로 실행하고 디버그하십시오!

설명

압축이 풀린 버전을 사용하여 설명합니다.

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.