Chi è il legittimo sovrano?

Chi governerà il regno?

Ti viene dato un albero genealogico che contiene: nome, sesso, data di nascita, data di morte e un elenco di eredi, per ogni membro della famiglia. È possibile utilizzare qualsiasi formato di elenco conveniente (nidificato) per rappresentare l'albero. I seguenti esempi useranno JSON. Determina chi governerà il regno e in quale ordine. Le regole di successione sono le seguenti:

1. Quando un re muore, il regno passa al suo più antico figlio maschio legittimo.
2. Se non ce n'è nessuno, passa alla figlia maggiore legittima.
3. Nel caso in cui il re non avesse eredi, il regno passa al fratello del re legittimo più anziano
4. Se non ci sono fratelli maschi, il regno andrà dalla sorella del re legittimo più anziano
5. Se tutti i parenti legittimi sono morti, il regno passa al bastardo più vicino, applicando le regole di cui sopra
6. Se nessun parente legittimo o bastardo è vivo stampa LINE EXTINCT

Definiamo un figlio legittimo come uno che ha lo stesso nome di "casa" di suo padre.

Esempi:

Ingresso {}

Produzione LINE EXTINCT

Ingresso

{
    "name" : "Maegor",
    "house" : "Targaryen",
    "birth" : 12,
    "death" : 48,
    "sex" : "male",
    "heirs" : []
}

Produzione 12-48: Maegor, LINE EXTINCT

Ingresso

{
    "name" : "Jaehaerys",
    "house" : "Targaryen",
    "birth" : 34,
    "death" : 103,
    "sex" : "male",
    "heirs" : [
        {
        "name" : "Viserys",
        "house" : "Targaryen",
        "birth" : 77,
        "death" : 129,
        "sex" : "male",
        "heirs" : []
        }
    ]
}

Produzione 34-103: Jaehaerys, 103-129: Viserys, LINE EXTINCT

Ingresso

{
        "name" : "Eddard",
        "house" : "Stark",
        "birth" : 263,
        "death" : 299,
        "sex" : "male",
        "heirs" : [
            {
            "name" : "Robb",
            "house" : "Stark",
            "birth" : 283,
            "death" : 300,
            "sex" : "male",
            "heirs" : []
            },
            {
             "name" : "Jon",
             "house" : "Snow",
             "birth" : 284,
             "death" : 384,
             "sex" : "male",
             "heirs" : []
            },
            {
             "name" : "Sansa",
             "house" : "Stark",
             "birth" : 286,
             "death" : 320,
             "sex" : "female",
             "heirs" : []
            },
            {
             "name" : "Arya",
             "house" : "Stark",
             "birth" : 289,
             "death" : 350,
             "sex" : "female",
             "heirs" : []
            },

            {
             "name" : "Brann",
             "house" : "Stark",
             "birth" : 290,
             "death" : 315,
             "sex" : "male",
             "heirs" : []
            },
            {
             "name" : "Rickon",
             "house" : "Stark",
             "birth" : 295,
             "death" : 319,
             "sex" : "male",
             "heirs" : []
            }

        ]
    }

Produzione: 263-299: Eddard, 299-300: Robb, 300-315: Brann, 315-319: Rickon, 319-320: Sansa, 320-350: Arya, 350-384: Jon, LINE EXTINCT

Nota che l'output può essere formattato come desideri, il suo unico requisito è che contenga il tempo del regno e il nome del re regnante durante quegli anni. Ho usato i re di ASOIAF come esempio dimostrativo, tuttavia il codice deve essere valido per tutti gli input.

Puoi presumere che non nasceranno gemelli.

Questa è una sfida del codice golf, quindi vince il codice più breve in byte

In bocca al lupo!!!

PHP, 664 byte

Non sono sicuro che 664 byte si adattino al golf del codice, ma eccolo qui:

$k=json_decode($argv[1]);$s=[];$f='array_shift';$r='heirs';$e='death';$y='year';function s
($k,&$e){uasort($e,function($a,$b)use($k){$c=$a->{$h='house'};$d=$b->$h;$e=$k->$h;if($c==$e
&&$d!=$e)return-1;elseif($c!=$e&&$d==$e)return 1;elseif($a->sex<$b->sex)return 1;elseif($a
->sex>$b->sex)return -1;else return$a->birth-$b->birth;});}function d(&$e,$y){foreach($e 
as$i=>$h)if($h->death<=$y)unset($e[$i]);};($x=(array)$k)&&$k->$y=$k->birth;$l=[];while($x)
{$l[]=$k;$z=$k->$e;s($k,$k->$r);d($k->$r,$k->$e);if($k->$r){$s=$k->$r;$k=$f($s);}else{s($k
,$s);d($s,$k->$e);$k=$f($s);}if(!$k)break;$k->$y=$z;}foreach($l as$k)
echo"{$k->$y}-{$k->$e}: $k->name, ";echo"LINE EXTINCT";

Riceve l'input della stringa JSON come primo argomento della riga di comando.

L'algoritmo segue i passaggi descritti nella sfida (inizia dal re, quindi ordina gli eredi e poi i fratelli per trovare il re successivo).

dimostrazione