Un numéro de naissance norvégien se compose de 11 chiffres, composé comme suit:

DDMMYYiiikk

• DD est le jour (du 01-31)
• MM est le mois (du 01-12)
• YYest l'année (de 00 à 99). Ce n'est pas différencié entre 1900 et 2000
• iii est le "numéro individuel"
• kk sont deux chiffres de contrôle

iii est déterminé par l'année de naissance et le sexe de la manière suivante

• 0000-1900: Ignorance, il y a des incohérences et des cas spéciaux
• 1900-1999: plage = 000-499
• 2000-2039: plage = 500-999
• Féminin: nombres pairs (et 000)
• Homme: nombres impairs

Les numéros de contrôle sont déterminés de la manière suivante:

Appelons les 11 chiffres:

d1 d2 m1 m2 y1 y2 i1 i2 i3 k1 k2

Ensuite, les chiffres de contrôle peuvent être calculés à l'aide des équations:

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

Pour certaines combinaisons, les numéros de contrôle k1ou k2peuvent devenir 10. Si tel est le cas, le numéro sera invalide.

Si le module de somme 11 pour k1ou k2est 11, c'est-à-dire k1 = 11 - (11 mod 11), alors le chiffre de contrôle sera 0, pas 11.

Défi

Prenez une lettre, Mou F(homme ou femme), et un nombre à onze chiffres comme entrée, et vérifiez si le numéro de naissance est valide selon les règles ci-dessus.

• Le format d'entrée et la commande sont facultatifs
• Les 11 chiffres doivent être un seul numéro ou une chaîne consécutive (vous ne pouvez pas prendre l'entrée comme DD, MM, YY, iii, kk).
• Vous pouvez supposer que la date est valide (310699xxxxx ne sera pas donnée en entrée)
• La sortie est une valeur véridique / fausse (1/0, vrai / faux, etc.)
• Programme ou fonction
• Toutes les règles standard s'appliquent

Vous pouvez trouver tous les numéros valides sur cette page (en norvégien) en choisissant une date.

Exemples:

M, 01010099931
True

F, 01029042620
True

M, 0101009841
False

F, 01010051866
True  

F, 08021690849
True

M, 01029040105
True

M, 01029037473
False

Le code le plus court en octets gagne.

Python 3, 227 221 octets

Fonction qui prend deux arguments, le genre «m» et le numéro de naissance «n», tous deux sous forme de chaînes. Il y a peut-être encore du golf à faire, surtout dans la dernière ligne. Je vais continuer à y travailler.

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 octets

Golfé :

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}

Tests :

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

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

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