Introduction:

Un BSN néerlandais (BurgerServiceNummer) est valide lorsqu'il respecte les règles suivantes:

• Il ne contient que des chiffres.
• La longueur doit être de 8 ou 9 de long.
• Lorsque les chiffres sont indexés comme à Atravers I, le résultat de la somme suivante: 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI(NOTEz le -1 au lieu de 1!) Doit être divisible par 11 et ne doit pas être 0.

Défi:

Entrée: chaîne ou tableau de caractères représentant le BSN.

Sortie: un résultat vrai ou faux si l'entrée est un BSN valide.

Règles du défi:

• Le format d'entrée doit être une chaîne ou un tableau de caractères. Vous n'êtes pas autorisé à utiliser un int-tableau de chiffres ou un nombre (éventuellement octal). (Vous êtes cependant autorisé à le convertir vous-même en un tableau de chiffres int, mais pas directement en argument.)
• Malgré la restriction de l'entrée ci-dessus, vous pouvez supposer que tous les cas de test contiendront un ou plusieurs chiffres ( [0-9]+)
• En ce qui concerne le BSN de longueur 8 au lieu de 9, Wikipedia néerlandais déclare ce qui suit: " Pour le test à onze et pour d'autres utilisations pratiques, un zéro de tête est ajouté pour faire le nombre de longueur 9. " ( source )

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés, des programmes complets. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test:

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

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

05AB1E , 23 21 octets

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

Essayez-le en ligne! ou comme suite de tests

Explication

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

Entrez comme un tableau de caractères. reduceRightsauve la journée!

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

Tester

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 octets

Edit: Merci à Jarko Dubbeldam d'avoir suggéré le produit scalaire!

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

Lit l'entrée de stdin et stocke comme un tableau / vecteur de caractères. Convertissez ensuite en numérique, multipliez avec le vecteur 9...2,-1et vérifiez toutes les conditions.

JavaScript (ES6), 61 60 59 58 octets

Prend un tableau de caractères en entrée. Renvoie false/ true.

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

Cas de test

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 octets

Merci à @MartinEnder pour avoir économisé 5 3 octets tout en corrigeant mon code !

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

Renvoie 0 si non valide, 1 si valide. Essayez-le en ligne!

R, 95 79 93 octets

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

Fonction sans nom qui prend une chaîne en argument. Au début, je dépassais l'exigence d'avoir une chaîne en entrée au lieu d'un nombre, mais c'est bien, car cela économise quelques octets lors de la conversion.

Je ne sais pas comment interpréter le tableau de caractères, mais si cela signifie que vous pouvez utiliser un vecteur de chiffres "1" "2" "3" "4" etcen chaîne comme entrée, il devient même un peu plus court:

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

Divise x en un vecteur numérique, puis ajoute un 0 si la longueur est 8, puis calcule le produit scalaire du vecteur y et c(9,8,7,6,5,4,3,2,-1). Teste si le résultat est à la fois différent de zéro et divisible par 11.

16 octets enregistrés grâce à la logique de @Enigma, ajoutant implicitement le 0 à la création du vecteur c(length(x):2,-1).

J'ai oublié d'ajouter un chèque pour la longueur 8/9, donc +14 octets :(

Perl, 58 octets (52 + 6)

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

Courir avec

perl -F// -lapE

Entrée transmise STDIN:

Usage

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

Sorties 1pour la valeur véridique, 0ou rien pour les valeurs de falsey.

C ++ 14, 107 106 octets

-1 octet pour intau lieu de autodans pour la boucle.

Comme lambda sans nom retournant via le paramètre de référence. Nécessite une entrée std::stringou un conteneur de caractères, comme 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;}

Non golfé et utilisation:

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

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

Essayez-le en ligne!

Explication

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

Ce n'est pas le programme MATL le plus long que j'ai jamais écrit , mais j'aime la façon dont if/ les elsedéclarations deviennent très longues très rapidement dans les langues de golf. Je pense que cette solution n'est peut-être pas optimale dans MATL, mais pour l'instant je ne peux pas l'optimiser davantage. Je pense utiliser le double 0 quelque part, et peut-être réduire le tpartout partout.

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

Essayez-le en ligne! Explication:

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 octets

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

Le résultat est un vecteur de colonne non vide, qui est vrai si toutes ses entrées ne sont pas nulles .

Essayez-le en ligne!

Ou vérifiez tous les cas de test avec chaque résultat sur une ligne différente.

Explication

Cela teste les trois conditions dans l'ordre suivant:

1. La somme pondérée n'est pas nulle;
2. La somme pondérée est divisible par 11;
3. La longueur est de 8 ou 9.

Considérez l'entrée '8925'pour l'explication. ;est le séparateur de lignes pour les matrices.

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

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

gcompte la somme utilisée dans le onze-proef de h, tout en vérifiant fégalement la longueur correcte et que le onze-proef n'est pas 0. Surtout les contrôles de fprennent beaucoup d'octets.

EDIT: économisé 10 octets grâce à Lynn et divarrondi.

Gelée , 21 octets

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

TryItOnline! ou exécutez tous les cas de test

Les valeurs de retour véridiques sont non nulles (et sont, en fait, le multiple de 11 somme).

Comment?

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 octets

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 octets

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

Prend une chaîne en entrée. La fonction ajoute un '0'au début de la chaîne, qu'elle en ait besoin ou non, et utilise les indices négatifs de Python pour ajouter des éléments, en commençant par la fin de la chaîne et en travaillant de l'avant vers l'avant.

Le -1xIest géré séparément, à l'aide d'un deuxième appel à int(). Je ne pouvais pas comprendre comment éviter cela sans coûter plus d'octets que ce que j'avais économisé.

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)*ufonctionnerait tout aussi bien, car il ajouterait des 1temps s[-1]mais le soustrait ensuite deux fois, et il ajouterait également des 0temps (quelque chose) qui, bien sûr, n'affecteraient pas la somme.

Brain-Flak , 345 octets

Comprend +3 pour -a

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

Truthy vaut 1, Falsy a un 0 en haut de la pile.

Essayez-le en ligne!

Je suis presque sûr qu'il existe un moyen plus court de faire la multiplication en boucle, mais je ne l'ai pas encore trouvée.

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

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

OK, je l'admets, cela ressemble à un gâchis complet. Et ça l'est un peu. Mais, restez avec moi et nous passerons au travers.

Nous prenons l'entrée $n(sous la forme d'un chartableau) et la définissons $iégale à 8moins une valeur booléenne pour savoir s'il y a 8 éléments $n. Autrement dit, s'il y a 8 éléments, alors$i serait le cas 7.

La section suivante combine le calcul avec notre sortie. Travaillant de l'intérieur, nous parcourons $navec $n|%{...}. Chaque itération, nous utilisons un pseudo-ternaire pour arriver à l'un des deux résultats - soit -"$_"ou (($i+1)*+"$_"). L'indice est basé sur le fait de l' $iêtre 0ou non (c'est-à-dire que nous avons atteint le -1xIcas de l'équation de défi), qui est post-décrémenté pour le prochain tour. Ceux-ci sont tous rassemblés en parens et édités -joinavec +. Par exemple, avec une entrée 111222333à ce stade, nous aurions 9+8+7+12+10+8+9+6+-3. Il est acheminé vers iex(abréviation de Invoke-Expressionet similaire à eval) avant d'être stocké dans $b. Nous prenons ensuite cela %11et effectuons un booléen-pas!(...)à ce sujet (c'est-à-dire que si elle est divisible par 11, cette partie l'est $true). C'est couplé avec -and$bpour s'assurer que ce $bn'est pas zéro. Ce résultat booléen est laissé sur le pipeline et la sortie est implicite.

Exemples

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 octets

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

Impossible de faire en sorte que la CLI répète simplement le vrai ou le faux. J'ai dû faire comme ça. Des idées?

128 octets: mis "vrai" et "faux" à 1 et 0.

C #, 120 115 octets

Cela boucle à travers le char[]qu'il reçoit en entrée et retourne vrai ou faux:

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

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

Je suis sûr que je peux gratter quelques octets, surtout dans le désordre return. Toutes les idées sont les bienvenues!

Edit: sauvé 5 octets grâce à Kevin. Je ne savais pas que je pouvais utiliser à la &place &&!

PHP, 86 85 84 83 82 79 octets

Remarque: utilise PHP 7.1 pour les indices de chaîne négatifs.

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

Courez comme ceci:

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

Version pour PHP <7.1 (+10 octets)

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

Explication

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

• Manière plus courte de faire la distinction entre une chaîne vide et "0"un octet enregistré
• Puisque 10000000n'est pas valide, pas besoin de comparer avec greater than or equals, greater thansuffit, enregistrer un octet
• Manière plus courte de soustraire le chiffre le moins significatif
• Negate char au lieu de XOR, en enregistrant un octet
• Enregistré 3 octets en utilisant -Rpour rendre $argndisponible

Java 8, 115 98 octets

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

Je suis surpris que personne n'ait encore posté de réponse Java, alors en voici une.

Explication:

Essayez-le ici.

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 octets

Eh bien, c'est quelque chose, -soustrait le reste des arguments du premier afin de gérer le cas spécial du poids -1. Cette fonction renvoie nildes entrées de longueur non valide, mais sur les ifclauses, elles fonctionnent de la même manière que false. (#{8 9}(count v))renvoie nilsi la longueur de vn'est pas 8 ou 9.

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

Cas de test:

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

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

Essayez-le en ligne!

Stax , 23 octets

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

Exécutez et déboguez en ligne!

Explication

Utilise la version décompressée pour expliquer.

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.