Introducción:

Un BSN holandés (BurgerServiceNummer) es válido cuando cumple con las siguientes reglas:

• Solo contiene dígitos.
• La longitud debe ser de 8 o 9 de longitud.
• Cuando los dígitos se indexan como a Através I, el resultado de la siguiente suma: 9xA + 8xB + 7xC + 6xD + 5xE + 4xF + 3xG + 2xH + -1xI(¡NOTA el -1 en lugar de 1!) Debe ser divisible por 11, y no debe ser 0.

Reto:

Entrada: una cadena o matriz de caracteres que representa el BSN.

Salida: Un resultado verdadero o falso si la entrada es un BSN válido.

Reglas de desafío:

• El formato de entrada debe ser una cadena o una matriz de caracteres. No está permitido utilizar una matriz de dígitos int o un número (posiblemente octal). (Sin embargo, usted mismo puede convertirlo en una matriz de dígitos int, pero no directamente como argumento).
• A pesar de la restricción en la entrada anterior, puede asumir que todos los casos de prueba contendrán uno o más dígitos ( [0-9]+)
• Con respecto al BSN con longitud 8 en lugar de 9, la Wikipedia holandesa establece lo siguiente: " Para las once pruebas y para otros usos prácticos, se agrega un cero inicial para hacer el número de longitud 9. " ( fuente )

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

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

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

05AB1E , 23 21 bytes

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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

Entrada como un conjunto de caracteres. reduceRight¡salvar el dia!

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

Prueba

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 bytes

Editar: ¡Gracias a Jarko Dubbeldam por sugerir el producto dot!

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

Lee la entrada de stdin y la almacena como una matriz / vector de caracteres. Posteriormente convierta a numérico, multiplique con el vector 9...2,-1y verifique todas las condiciones.

JavaScript (ES6), 61 60 59 58 bytes

Toma una matriz de caracteres como entrada. Devoluciones false/ true.

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

Casos de prueba

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 bytes

¡Gracias a @MartinEnder por guardar 5 3 bytes mientras arreglaba mi código !

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

Devuelve 0 si no es válido, 1 si es válido. Pruébalo en línea!

R, 95 79 93 bytes

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

Función sin nombre que toma una cadena como argumento. Al principio, sobrepasé el requisito de tener una cadena como entrada en lugar de un número, pero eso es bueno, porque ahorra algunos bytes en la conversión.

No estoy seguro de cómo interpretar la matriz de caracteres, pero si eso significa que puede usar un vector de dígitos de cadena "1" "2" "3" "4" etccomo entrada, se vuelve un poco más corto incluso:

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

Divide x en un vector numérico, luego agrega un 0 si la longitud es 8, luego calcula el producto de punto del vector y y c(9,8,7,6,5,4,3,2,-1). Comprueba si el resultado es distinto de cero y divisible por 11.

Ahorró 16 bytes gracias a la lógica de @Enigma, agregando implícitamente el 0 en la creación del vector c(length(x):2,-1).

Olvidé agregar un cheque para la longitud 8/9, entonces +14 bytes :(

Perl, 58 bytes (52 + 6)

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

Corre con

perl -F// -lapE

Entrada transmitida a través de STDIN:

Uso

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

Salidas 1para el valor de verdad, 0o nada para los valores de falsey.

C ++ 14, 107106 bytes

-1 byte for en intlugar de autoin for loop.

Como lambda sin nombre que regresa a través del parámetro de referencia. Requiere entrada para ser std::stringo un contenedor de char, como 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;}

Sin golf y uso:

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

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

Pruébalo en línea!

Explicación

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

No es el programa MATL más largo que he escrito , pero me gusta cómo las declaraciones if/ elsese alargan muy rápidamente en los idiomas de golf. Siento que esta solución puede no ser óptima en MATL, pero hasta ahora no puedo optimizarla más. Estoy pensando en usar el doble 0 en algún lugar, y tal vez reducir el t's en todas partes.

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

Pruébalo en línea! Explicación:

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 bytes

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

El resultado es un vector de columna no vacío, lo cual es cierto si todas sus entradas son distintas de cero .

Pruébalo en línea!

O verifique todos los casos de prueba con cada resultado en una línea diferente.

Explicación

Esto prueba las tres condiciones en el siguiente orden:

1. La suma ponderada es distinta de cero;
2. La suma ponderada es divisible por 11;
3. La longitud es de 8 o 9.

Considere la entrada '8925'para la explicación. ;es el separador de fila para 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 bytes

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

gcuenta la suma utilizada en el once-proef de h, mientras que ftambién comprueba la longitud correcta y que el once-proef no es 0. Especialmente las comprobaciones de ftomar muchos bytes.

EDITAR: ahorró 10 bytes gracias a Lynn y divredondeando hacia abajo.

Jalea , 21 bytes

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

TryItOnline! o ejecutar todos los casos de prueba

Los valores de retorno de verdad son distintos de cero (y, de hecho, son el múltiplo de 11 sum).

¿Cómo?

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 bytes

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 bytes

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

Toma una cadena como entrada. La función agrega un '0'al frente de la cadena, ya sea que lo necesite o no, y utiliza los índices negativos de Python para agregar elementos, comenzando desde el final de la cadena y trabajando de atrás hacia adelante.

El -1xIse maneja por separado, utilizando una segunda llamada a int(). No pude descubrir cómo evitar esto sin costar más bytes de los que guardé.

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)*ufuncionaría igual de bien, ya que agregaría 1tiempos s[-1]pero luego los restaría dos veces, y también agregaría 0tiempos (algo) que, por supuesto, no afectaría la suma.

Brain-Flak , 345 Bytes

Incluye +3 para -a

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

La verdad es 1, Falsy tiene un 0 en la parte superior de la pila.

Pruébalo en línea!

Estoy bastante seguro de que hay una forma más corta de hacer la multiplicación en un bucle, pero aún no la he encontrado.

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

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

Bien, lo admito, esto parece un completo desastre. Y es un poco. Pero, tengan paciencia conmigo y lo superaremos.

Tomamos entrada $n(como una charmatriz) y establecemos $iigual a 8menos un valor booleano para ver si hay 8 elementos $n. Es decir, si hay 8 elementos, entonces $isería7 .

La siguiente sección combina el cálculo con nuestra salida. Trabajando desde el interior, el ciclo que recorre $ncon $n|%{...}. En cada iteración, utilizamos un pseudoternario para obtener uno de los dos resultados, ya sea -"$_"o (($i+1)*+"$_"). El índice se basa en si $ies 0o no (es decir, hemos tocado el -1xIcaso de la ecuación de desafío), que se reduce posteriormente para la próxima ronda. Todos están reunidos en parejas y editados -joinjunto con +. Por ejemplo, con la entrada 111222333en este punto tendríamos 9+8+7+12+10+8+9+6+-3. Eso se canaliza a iex(abreviatura Invoke-Expressiony similar a eval) antes de almacenarse en$b . Luego tomamos eso %11y realizamos un booleano-no!(...)en eso (es decir, si es divisible por 11, esta porción es $true). Eso se combina con -and$bpara garantizar que $bno sea cero. Ese resultado booleano se deja en la tubería y la salida es implícita.

Ejemplos

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 bytes

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

No se pudo hacer que la CLI solo hiciera eco de lo verdadero de lo falso. Tenía que hacerlo hacerlo de esta manera. ¿Algunas ideas?

128 bytes: convertido "verdadero" y "falso" en 1 y 0.

C #, 120 115 bytes

Esto recorre el char[]que recibe como entrada y devuelve verdadero o falso:

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

Violín: https://dotnetfiddle.net/3Kaxrt

Estoy seguro de que puedo eliminar algunos bytes, especialmente en los desordenados return. Cualquier idea bienvenida!

Editar: Guardado 5 bytes gracias a Kevin. ¡No tenía idea de que podría usar en &lugar de &&!

PHP, 86 85 84 83 82 79 bytes

Nota: usa PHP 7.1 para índices de cadena negativos.

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

Corre así:

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ón para PHP <7.1 (+10 bytes)

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

Explicación

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.

Ajustes

• Forma más corta de distinguir entre cadena vacía y "0" , guardado un byte
• Dado que 10000000no es válido, no hay necesidad de comparar con greater than or equals,greater than basta, guardar un byte
• Forma más corta de restar el dígito menos significativo
• Negate char en lugar de XOR, guardando un byte
• Guardado 3 bytes al usar -Rpara poner a $argndisposición

Java 8, 115 98 bytes

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

Me sorprende que nadie haya publicado una respuesta Java todavía, así que aquí hay una.

Explicación:

Pruébalo aquí.

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 bytes

Bueno, esto es algo, -resta el resto de los argumentos del primero para que maneje el caso especial de peso -1. Esta función devuelve nilentradas de longitud no válida, pero en ifcláusulas funcionan igual que false. (#{8 9}(count v))devuelve nilsi la longitud de vno es 8 o 9.

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

Casos de prueba:

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

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

Pruébalo en línea!

Stax , 23 bytes

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

¡Ejecute y depure en línea!

Explicación

Utiliza la versión desempaquetada para explicar.

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.