¿Quién es el gobernante legítimo?

¿Quién gobernará el reino?

Se le entrega un árbol genealógico que contiene: nombre, sexo, fecha de nacimiento, fecha de fallecimiento y una lista de herederos, para cada miembro de la familia. Puede usar cualquier formato de lista conveniente (anidado) para representar el árbol. Los siguientes ejemplos usarán JSON. Determine quién gobernará el reino y en qué orden. Las reglas de sucesión son las siguientes:

1. Cuando un rey muere, el reino va a su hijo varón legítimo más viejo.
2. Si no hay ninguno, pasa a la niña mayor legítima.
3. En caso de que el rey no tuviera herederos, el reino iría al hermano del rey legítimo más antiguo.
4. Si no hay hermanos varones, el reino irá a la hermana del rey legítimo más viejo
5. Si todos los parientes legítimos están muertos, el reino va al bastardo más cercano, aplicando las reglas anteriores
6. Si no hay parientes legítimos ni bastardos vivos, imprima LINE EXTINCT

Definimos un hijo legítimo como aquel que tiene el mismo nombre de "casa" que su padre.

Ejemplos:

Entrada {}

Salida LINE EXTINCT

Entrada

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

Salida 12-48: Maegor, LINE EXTINCT

Entrada

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

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

Entrada

{
        "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" : []
            }

        ]
    }

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

Tenga en cuenta que la salida se puede formatear de la forma que desee, sus únicos requisitos es que contiene el tiempo de reinado y el nombre del rey reinante durante esos años. He usado reyes de ASOIAF como ejemplo demostrativo, sin embargo, el código debe ser válido para todas las entradas.

Puede suponer que no nacerán gemelos.

Este es un desafío de código de golf, por lo que gana el código más corto en bytes

¡¡¡Buena suerte!!!

PHP, 664 bytes

No estoy seguro de si 664 bytes son aptos para golf de código, pero aquí está:

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

Recibe la entrada de cadena JSON como el primer argumento de línea de comando.

El algoritmo sigue los pasos descritos en el desafío (comienza con el rey, luego ordena a los herederos y luego a los hermanos para encontrar el próximo rey).

Manifestación