Un número de nacimiento noruego consta de 11 dígitos, compuestos de la siguiente manera:

DDMMYYiiikk

• DD es el día (del 01 al 31)
• MM es el mes (del 01-12)
• YYes el año (de 00-99). No se diferencia entre 1900 y 2000
• iii es el "número individual"
• kk son dos dígitos de control

iii se determina por año de nacimiento y género de la siguiente manera

• 0000-1900: Desprecio, hay algunas inconsistencias y casos especiales
• 1900-1999: Rango = 000-499
• 2000-2039: Rango = 500-999
• Hembra: números pares (y 000)
• Hombre: números impares

Los números de control se determinan de la siguiente manera:

Llamemos a los 11 dígitos:

d1 d2 m1 m2 y1 y2 i1 i2 i3 k1 k2

Luego, los dígitos de control se pueden calcular utilizando las ecuaciones:

k1 = 11 - ((3 * d1 + 7 * d2 + 6 * m1 + 1 * m2 + 8 * y1 + 9 * y2 + 4 * i1 + 5 * i2 + 2 * i3) mod 11)

k2 = 11 - ((5 * d1 + 4 * d2 + 3 * m1 + 2 * m2 + 7 * y1 + 6 * y2 + 5 * i1 + 4 * i2 + 3 * i3 + 2 * k1) mod 11).

Para algunas combinaciones, los números de control k1o k2pueden convertirse 10. Si ese es el caso, el número será inválido.

Si el módulo de suma 11 para k1o k2es 11, es decir k1 = 11 - (11 mod 11), el dígito de control será 0, no 11.

Desafío

Tome una letra, Mo F(hombre o mujer), y un número de once dígitos como entrada, y verifique si el número de nacimiento es válido de acuerdo con las reglas anteriores.

• El formato de entrada y el orden son opcionales
• Los 11 números deben ser un solo número o una cadena consecutiva (no puede tomar la entrada como DD, MM, YY, iii, kk).
• Puede suponer que la fecha es válida (310699xxxxx no se dará como entrada)
• La salida es un valor verdadero / falso (1/0, verdadero / falso, etc.)
• Programa o función
• Se aplican todas las reglas estándar.

Puede encontrar todos los números válidos en esta página (en noruego) eligiendo una fecha.

Ejemplos:

M, 01010099931
True

F, 01029042620
True

M, 0101009841
False

F, 01010051866
True  

F, 08021690849
True

M, 01029040105
True

M, 01029037473
False

El código más corto en bytes gana.

Python 3, 227 221 bytes

Función que toma dos argumentos, el género 'm' y el número de nacimiento 'n', ambos como cadenas. Puede haber más golf por hacer, especialmente en la última línea. Seguiré trabajando en eso.

def a(m,n):
 o=[3,7,6,1,8,9,4,5,2];t=[5,4,3,2,7,6,5,4,3,2];n=list(map(int,n));y=z=b=0;q=11
 for i in n[:9]:z+=o[b]*i;y+=t[b]*i;b+=1
 print((q-z%q)%q==n[9] and (q-(y-z-z)%q)%q==n[-1] and len(n)<12 and ord(m)%2==n[8]%2)

Javascript (ES2016), 275 259 255 254 252 Bytes

Golfizado :

f=(g,I)=>{[,d,m,y,i,k]=/(..)(..)(..)(...)(..)/.exec(I.padEnd(12)),v=g.charCodeAt()%2!=i%2|y<=39&i<500,s=k=>11-([...I].slice(0,-2).map((e,i)=>e*[..."376189452543276543"][i+!k|9]).reduce((a,b)=>a+b)+2*k)%11,[s(0),s(s(0))].map((s,i)=>v&=k[i]!=s);return!v}

Pruebas :

for (let args of [
    ["M", "01010099931"], // true
    ["F", "01029042620"], // true
    ["M", "0101009841"],  // false
    ["F", "01010051866"], // true
    ["F", "08021690849"], // true
    ["M", "01029040105"], // true
    ["M", "01029037473"]  // false
]) {
    console.log(f(...args));
}

Sin golf :

let f = (g, input) => {

    /* Sanitize input, destructure arguments via RegExp */
    let [, d, m, y, i, k] = /(..)(..)(..)(...)(..)/.exec(input.padRight(12));

    /* Validate gender and year */
    let violation = g.charCodeAt() % 2 != i % 2 | y <= 39 & i < 500;

    let n = [..."376189452543276543"];
    /* This function computes k1 if given no arguments, k2 if given one argument */
    let s = k => 11 - ([...input].slice(0, -2).map((e, i) => e * n[i + !k | 9]).reduce((a, b) => a + b) + 2 * k) % 11;

    /* Validate the control numbers k */
    [s(0), s(s(0))].map((s, i) => violation &= k[i] != s);

    return !violation;
}

JS, 343 bytes

x=prompt().replace(/F/,1).replace(/M/,2).match(/\d{1}/g);v=Math.abs((x[0]-x[9])%2);v++;t=x[5]*10+x[6]*1;i=x[7]*1;if(t>39&&i>4){v--}if((11-(3*x[1]+7*x[2]+6*x[3]+1*x[4]+8*x[5]+9*x[6]+4*x[7]+5*x[8]+2*x[9])%11)%11===x[10]*1&&(11-(5*x[1]+4*x[2]+3*x[3]+2*x[4]+7*x[5]+6*x[6]+5*x[7]+4*x[8]+3*x[9]+2*x[10])%11)%11===x[11]*1){v++}alert(Math.floor(v/3))