Um número de nascimento norueguês consiste em 11 dígitos, compostos da seguinte maneira:

DDMMYYiiikk

• DD é o dia (de 01 a 31)
• MM é o mês (de 01 a 12)
• YYé o ano (de 00 a 99). Não é diferenciado entre 1900 e 2000
• iii é o "número individual"
• kk são dois dígitos de controle

iii é determinado por ano de nascimento e sexo da seguinte maneira

• 0000-1900: Desconsidere, há alguma inconsistência e casos especiais
• 1900-1999: Intervalo = 000-499
• 2000-2039: Intervalo = 500-999
• Fêmea: números pares (e 000)
• Macho: números ímpares

Os números de controle são determinados da seguinte maneira:

Vamos chamar os 11 dígitos:

d1 d2 m1 m2 y1 y2 i1 i2 i3 k1 k2

Em seguida, os dígitos do controle podem ser calculados usando as equações:

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 algumas combinações, os números de controle k1ou k2podem se tornar 10. Se for esse o caso, o número será inválido.

Se o módulo de soma 11 para k1ou k2for 11, ou seja k1 = 11 - (11 mod 11), o dígito de controle será 0, não 11.

Desafio

Pegue uma letra Mou F(masculino ou feminino) e um número de onze dígitos como entrada e verifique se o Número de Nascimento é válido de acordo com as regras acima.

• O formato e a ordem de entrada são opcionais
• Os 11 números devem ser um número único ou uma sequência consecutiva (você não pode usar a entrada como DD, MM, YY, iii, kk).
• Você pode assumir que a data é válida (310699xxxxx não será fornecida como entrada)
• A saída é um valor verdadeiro / falso (1/0, verdadeiro / falso etc.)
• Programa ou função
• Todas as regras padrão se aplicam

Você pode encontrar todos os números válidos nesta página (em norueguês) escolhendo uma data.

Exemplos:

M, 01010099931
True

F, 01029042620
True

M, 0101009841
False

F, 01010051866
True  

F, 08021690849
True

M, 01029040105
True

M, 01029037473
False

O código mais curto em bytes vence.

Python 3, 227 221 bytes

Função que aceita dois argumentos, o gênero 'm' e o número de nascimento 'n', ambos como cadeias. Pode haver mais golfe a ser feito, especialmente na última linha. Vou continuar trabalhando nisso.

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

Golfe :

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}

Testes :

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

Ungolfed :

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