Ejercicios resueltos de Lenguajes de Marcas

import re, sys texto = sys.stdin.read() def linea(pos):    return texto.count("\n", 0, pos) + 1 pila = []            # etiquetas abiertaselementos = 0profundidad = 0raiz = None          # nombre de la raíz cuando ya se ha cerradofor m in re.finditer(r"<[^>]*>", texto):    etiqueta = m.group()    if etiqueta.startswith(("<?", "<!")):        continue     # declaración, comentarios y DOCTYPE no cuentan    l = linea(m.start())    nombre = re.match(r"</?\s*([^\s/>]+)", etiqueta).group(1)    if etiqueta.startswith("</"):                          # cierre        if not pila:            print(f"Error en la línea {l}: </{nombre}> no tiene etiqueta de apertura")            sys.exit()        if pila[-1] != nombre:            print(f"Error en la línea {l}: se esperaba </{pila[-1]}> pero aparece </{nombre}>")            sys.exit()        pila.pop()        if not pila:            raiz = nombre        continue    if raiz is not None and not pila:                      # apertura tras cerrar la raíz        print(f"Error en la línea {l}: <{nombre}> es un segundo elemento raíz")        sys.exit()    elementos += 1    profundidad = max(profundidad, len(pila) + 1)    if etiqueta.endswith("/>"):                            # vacía: se abre y se cierra a la vez        if not pila:            raiz = nombre    else:        pila.append(nombre) if pila:    print(f"Error: falta cerrar <{pila[-1]}>")elif raiz is None:    print("Error: el documento no tiene elemento raíz")else:    print(f"Bien formado: {elementos} elementos, profundidad máxima {profundidad}, raíz <{raiz}>")

import re, sys texto = sys.stdin.read()VALIDA = re.compile(r"&(amp|lt|gt|quot|apos|#[0-9]+|#x[0-9a-fA-F]+);") def linea(pos):    return texto.count("\n", 0, pos) + 1 errores = []atributos = referencias = 0 def revisar_referencias(cadena, l):    """Comprueba cada & de la cadena; l es la línea donde se informa."""    global referencias    for i, c in enumerate(cadena):        if c != "&":            continue        j = i + 1        while j < len(cadena) and not cadena[j].isspace() and cadena[j] not in "&<;":            j += 1        trozo = cadena[i:j + 1] if j < len(cadena) and cadena[j] == ";" else cadena[i:j]        if VALIDA.fullmatch(trozo):            referencias += 1        else:            errores.append(f"Línea {l + cadena.count(chr(10), 0, i)}: referencia no válida «{trozo}»") def revisar_etiqueta(etiqueta, l):    global atributos    nombre = re.match(r"<\s*([^\s/>]+)", etiqueta).group(1)    resto = etiqueta[etiqueta.index(nombre) + len(nombre):].rstrip(">").rstrip("/")    lugar = f"Línea {l}, <{nombre}>"    vistos = set()    i = 0    while True:        while i < len(resto) and resto[i].isspace():            i += 1        if i >= len(resto):            return        j = i        while j < len(resto) and not resto[j].isspace() and resto[j] != "=":            j += 1        atributo = resto[i:j]        if not re.fullmatch(r"[A-Za-z_][\w.:-]*", atributo):            errores.append(f"{lugar}: nombre de atributo no válido «{atributo}»")            return                                        # no se sigue con esta etiqueta        i = j        while i < len(resto) and resto[i].isspace():            i += 1        if i >= len(resto) or resto[i] != "=":            errores.append(f"{lugar}: el atributo «{atributo}» no tiene valor")            continue                                      # se sigue con el siguiente        i += 1        while i < len(resto) and resto[i].isspace():            i += 1        comilla = resto[i] if i < len(resto) else ""        cierre = resto.find(comilla, i + 1) if comilla in ("'", '"') else -1        if cierre < 0:            errores.append(f"{lugar}: el valor de «{atributo}» no está entre comillas")            return        valor = resto[i + 1:cierre]        i = cierre + 1        atributos += 1        if atributo in vistos:            errores.append(f"{lugar}: el atributo «{atributo}» está repetido")        vistos.add(atributo)        if "<" in valor:            errores.append(f"{lugar}: el valor de «{atributo}» contiene «<»")        revisar_referencias(valor, l) fin = 0for m in re.finditer(r"<[^>]*>", texto):    revisar_referencias(texto[fin:m.start()], linea(fin))    fin = m.end()    etiqueta = m.group()    if not etiqueta.startswith(("</", "<?", "<!")):        revisar_etiqueta(etiqueta, linea(m.start()))revisar_referencias(texto[fin:], linea(fin)) if errores:    print("\n".join(errores))    print(f"Errores: {len(errores)}")else:    print(f"Sin errores: {atributos} atributos y {referencias} referencias correctas")

import re, sys texto = sys.stdin.read()XML_NS = "http://www.w3.org/XML/1998/namespace"ATRIBUTO = re.compile(r"""([\w.:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')""") def linea(pos):    return texto.count("\n", 0, pos) + 1 def expandir(nombre, ambito, es_elemento, pos):    """{URI}local de un nombre con o sin prefijo; termina si el prefijo no está declarado."""    if ":" in nombre:        prefijo, local = nombre.split(":", 1)        if prefijo not in ambito:            print(f"Error en la línea {linea(pos)}: el prefijo «{prefijo}» no está declarado")            sys.exit()        uri = ambito[prefijo]    else:        local = nombre        uri = ambito[""] if es_elemento else ""          # los atributos sin prefijo no tienen espacio    return uri, local ambitos = [{"xml": XML_NS, "": ""}]     # pila de ámbitos: prefijo → URI ("" es el espacio por defecto)usos = {}                              # URI → número de elementos (en orden de primera aparición)for m in re.finditer(r"<[^>]*>", texto):    etiqueta = m.group()    if etiqueta.startswith(("<?", "<!")):        continue    if etiqueta.startswith("</"):        ambitos.pop()        continue    nombre = re.match(r"<\s*([^\s/>]+)", etiqueta).group(1)    atributos = [(a.group(1), a.group(2) if a.group(2) is not None else a.group(3)) for a in ATRIBUTO.finditer(etiqueta)]    actual = dict(ambitos[-1])         # ámbito de este elemento: el del padre más sus declaraciones    for a, v in atributos:              # primero las declaraciones: valen ya para el propio elemento        if a == "xmlns":            actual[""] = v        elif a.startswith("xmlns:"):            actual[a[6:]] = v    sangria = "  " * (len(ambitos) - 1)    uri, local = expandir(nombre, actual, True, m.start())    print(f"{sangria}{{{uri}}}{local}" if uri else f"{sangria}{local}")    if uri:        usos[uri] = usos.get(uri, 0) + 1    for a, v in atributos:        if a == "xmlns" or a.startswith("xmlns:"):            continue        auri, alocal = expandir(a, actual, False, m.start())        print(f"{sangria}  @{{{auri}}}{alocal} = {v}" if auri else f"{sangria}  @{alocal} = {v}")    if not etiqueta.endswith("/>"):        ambitos.append(actual)print(f"Espacios de nombres usados: {len(usos)}")for uri, n in usos.items():    print(f"  {uri}: {n} elemento{'s' if n != 1 else ''}")

import sysimport xml.etree.ElementTree as ETfrom datetime import datetimefrom email.utils import format_datetime lineas = [l for l in sys.stdin.read().splitlines() if l.strip()]titulo, enlace, descripcion = lineas[0].split("|")noticias = []          # (fecha, titulo, link, descripcion, categoria)for l in lineas[1:]:    fecha, t, link, desc, cat = l.split("|")    noticias.append((datetime.fromisoformat(fecha), t, link, desc, cat)) def hijos(padre, pares):    for etiqueta, valor in pares:        ET.SubElement(padre, etiqueta).text = valor rss = ET.Element("rss", version="2.0")canal = ET.SubElement(rss, "channel")hijos(canal, [("title", titulo), ("link", enlace), ("description", descripcion), ("language", "es-es")])noticias.sort(key=lambda n: n[0], reverse=True)             # de la más reciente a la más antiguaif noticias:    hijos(canal, [("lastBuildDate", format_datetime(noticias[0][0]))])for fecha, t, link, desc, cat in noticias:    item = ET.SubElement(canal, "item")    hijos(item, [("title", t), ("link", link), ("description", desc), ("category", cat),                 ("guid", link), ("pubDate", format_datetime(fecha))]) ET.indent(rss, space="  ")print('<?xml version="1.0" encoding="UTF-8"?>')print(ET.tostring(rss, encoding="unicode"))

import sysimport xml.etree.ElementTree as ETfrom datetime import datetime, timezonefrom email.utils import parsedate_to_datetime ATOM = "{http://www.w3.org/2005/Atom}"partes = sys.stdin.read().split("=====")maximo = int(partes[0].split()[1])          # «maximo N»documentos = [ET.fromstring(p.strip()) for p in partes[1:] if p.strip()] entradas = []        # (fecha UTC, canal, título, identificador)for doc in documentos:    if doc.tag == "rss":        canal = doc.find("channel")        nombre = canal.findtext("title")        for item in canal.findall("item"):            fecha = parsedate_to_datetime(item.findtext("pubDate"))            ident = item.findtext("guid") or item.findtext("link")            entradas.append((fecha, nombre, item.findtext("title"), ident))    elif doc.tag == ATOM + "feed":        nombre = doc.findtext(ATOM + "title")        for entry in doc.findall(ATOM + "entry"):            fecha = datetime.fromisoformat(entry.findtext(ATOM + "updated").replace("Z", "+00:00"))            entradas.append((fecha, nombre, entry.findtext(ATOM + "title"), entry.findtext(ATOM + "id"))) unicas, vistos = [], set()for e in entradas:                          # se conserva la primera de cada identificador    if e[3] not in vistos:        vistos.add(e[3])        unicas.append(e)unicas.sort(key=lambda e: (-e[0].timestamp(), e[2])) print(f"Canales: {len(documentos)} · Entradas: {len(unicas)} (duplicadas descartadas: {len(entradas) - len(unicas)})")for fecha, canal, titulo, _ in unicas[:maximo]:    print(f"{fecha.astimezone(timezone.utc):%Y-%m-%d %H:%M} UTC · {canal} · {titulo}")

import re, sys NIF = re.compile(r"[0-9]{8}[A-Z]|[A-Z][0-9]{7}[A-Z0-9]")EMAIL = re.compile(r"[^\s@]+@[^\s@]+\.[^\s@]+") erp = {}            # external_id → {"nif", "nombre", "email", "activo"} (el orden de inserción es el del ERP)filas = []          # filas del fichero a importar: (external_id, nif, nombre, email)seccion = Nonefor linea in sys.stdin.read().splitlines():    linea = linea.strip()    if not linea:        continue    if linea.startswith("["):        seccion = linea        continue    campos = [c.strip() for c in linea.split(";")]    if seccion == "[erp]":        ext, nif, nombre, email, activo = campos        erp[ext] = {"nif": nif, "nombre": nombre, "email": email, "activo": activo == "si"}    else:        filas.append(tuple(campos)) creados = actualizados = sin_cambios = errores = 0en_fichero = set()for n, (ext, nif, nombre, email) in enumerate(filas, start=1):    en_fichero.add(ext)    error = None    if not NIF.fullmatch(nif):        error = f"NIF no válido «{nif}»"    elif not EMAIL.fullmatch(email):        error = f"email no válido «{email}»"    elif not nombre:        error = "falta el nombre"    if error:        print(f"ERROR línea {n} ({ext}): {error}")        errores += 1        continue    otro = next((e for e, r in erp.items() if e != ext and r["nif"] == nif), None)    if otro:        print(f"DUPLICADO línea {n} ({ext}): el NIF {nif} ya es de {otro}")        errores += 1        continue    nuevo = {"nif": nif, "nombre": nombre, "email": email}    if ext in erp:        actual = erp[ext]        cambios = [f"{campo} {actual[campo]} → {nuevo[campo]}" for campo in ("nif", "nombre", "email")                   if actual[campo] != nuevo[campo]]        reactivado = not actual["activo"]        if not cambios and not reactivado:            print(f"SIN CAMBIOS {ext}")            sin_cambios += 1            continue        print(f"ACTUALIZAR {ext}: {', '.join(cambios) or 'sin cambios de datos'}" + (" (reactivado)" if reactivado else ""))        actual.update(nuevo, activo=True)            # se aplica ya: afecta a las filas siguientes        actualizados += 1    else:        erp[ext] = {**nuevo, "activo": True}        print(f"CREAR {ext} ({nombre})")        creados += 1 print(f"Creados: {creados} · Actualizados: {actualizados} · Sin cambios: {sin_cambios} · Errores: {errores}")fuera = [e for e, r in erp.items() if r["activo"] and e not in en_fichero]if fuera:    print(f"No incluidos en el fichero: {', '.join(fuera)}")

import sysimport xml.etree.ElementTree as ETfrom decimal import Decimal, InvalidOperation ESTADOS = ("pendiente", "enviado", "entregado", "cancelado")  def leer_pedido(nodo):    """Comprueba un <pedido> y devuelve su id, cliente, estado e importe; lanza ValueError con el motivo."""    for atributo in ("id", "cliente", "estado"):        if not nodo.get(atributo):            raise ValueError(f"falta el atributo {atributo}")    if nodo.get("estado") not in ESTADOS:        raise ValueError(f"estado desconocido {nodo.get('estado')}")    lineas = nodo.findall("linea")    if not lineas:        raise ValueError("no tiene líneas")    importe = Decimal(0)    unidades = {}    for linea in lineas:        ref, cantidad, precio = linea.get("ref"), linea.get("cantidad", ""), linea.get("precio", "")        if not ref or not cantidad.isdigit() or int(cantidad) == 0:            raise ValueError(f"línea {ref or '?'} con una cantidad no válida")        try:            precio = Decimal(precio)        except InvalidOperation:            raise ValueError(f"línea {ref} con un precio no válido")        importe += int(cantidad) * precio        unidades[ref] = unidades.get(ref, 0) + int(cantidad)    return nodo.get("id"), nodo.get("cliente"), nodo.get("estado"), importe, unidades  def main():    try:        raiz = ET.fromstring(sys.stdin.read())    except ET.ParseError as e:        print(f"XML mal formado (línea {e.position[0]})")        return    if raiz.tag != "pedidos":        print("El elemento raíz debe ser <pedidos>")        return     por_cliente = {}      # cliente → [pedidos, importe]    por_estado = {e: 0 for e in ESTADOS}    vendidas = {}    total = Decimal(0)    validos = 0    for nodo in raiz.findall("pedido"):        try:            id_, cliente, estado, importe, unidades = leer_pedido(nodo)        except ValueError as e:            print(f"Aviso: pedido {nodo.get('id', '?')} ignorado: {e}")            continue        validos += 1        por_estado[estado] += 1        if estado == "cancelado":            continue          # se cuenta, pero no suma importe ni unidades        datos = por_cliente.setdefault(cliente, [0, Decimal(0)])        datos[0] += 1        datos[1] += importe        total += importe        for ref, n in unidades.items():            vendidas[ref] = vendidas.get(ref, 0) + n     # El resumen se construye como un árbol y se serializa con sangría    resumen = ET.Element("resumen", fecha=raiz.get("fecha", ""), pedidos=str(validos), importe=f"{total:.2f}")    estados = ET.SubElement(resumen, "estados")    for estado in ESTADOS:        ET.SubElement(estados, "estado", nombre=estado, pedidos=str(por_estado[estado]))    clientes = ET.SubElement(resumen, "clientes")    for cliente, (n, importe) in sorted(por_cliente.items(), key=lambda c: (-c[1][1], c[0])):        ET.SubElement(clientes, "cliente", nombre=cliente, pedidos=str(n), importe=f"{importe:.2f}")    if vendidas:        ref, n = min(vendidas.items(), key=lambda v: (-v[1], v[0]))        ET.SubElement(resumen, "masVendido", ref=ref, unidades=str(n))    ET.indent(resumen, space="  ")    print(ET.tostring(resumen, encoding="unicode"))  main()

/catalogo/libro[@genero = 'novela']/titulo/text()

/catalogo/libro[precio = max(/catalogo/libro/precio)]/titulo/text()

count(/catalogo/libro[@stock = 0])

/catalogo/libro[count(autor) > 1]/titulo/text()

for $g in distinct-values(/catalogo/libro/@genero)let $libros := /catalogo/libro[@genero = $g]order by $greturn concat($g, ' (', count($libros), '): precio medio ', round(avg($libros/precio) * 100) div 100, ' €')

for $l in /catalogo/libro[@stock > 10]let $precio := round($l/precio * 0.8 * 100) div 100order by $precioreturn <oferta codigo="{$l/@codigo}"><titulo>{string($l/titulo)}</titulo><precio>{$precio}</precio></oferta>

<?xml version="1.0" encoding="UTF-8"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">  <xsl:output method="html"/>  <xsl:template match="/catalogo">    <table>      <tr><th>Título</th><th>Autores</th><th>Precio</th></tr>      <xsl:for-each select="libro">        <xsl:sort select="titulo"/>        <tr>          <xsl:if test="@stock = 0">            <xsl:attribute name="class">agotado</xsl:attribute>          </xsl:if>          <td><xsl:value-of select="titulo"/></td>          <td>            <xsl:for-each select="autor">              <xsl:value-of select="."/>              <xsl:if test="position() != last()">, </xsl:if>            </xsl:for-each>          </td>          <td><xsl:value-of select="format-number(precio, '0.00')"/> €</td>        </tr>      </xsl:for-each>    </table>  </xsl:template></xsl:stylesheet>

<?xml version="1.0" encoding="UTF-8"?><xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">  <xs:element name="catalogo">    <xs:complexType>      <xs:sequence>        <xs:element name="libro" type="tipoLibro" maxOccurs="unbounded"/>      </xs:sequence>      <xs:attribute name="editorial" type="xs:string" use="required"/>      <xs:attribute name="actualizado" type="xs:date" use="required"/>    </xs:complexType>  </xs:element>   <xs:complexType name="tipoLibro">    <xs:sequence>      <xs:element name="titulo" type="xs:string"/>      <xs:element name="autor" type="xs:string" maxOccurs="unbounded"/>      <xs:element name="anio">        <xs:simpleType>          <xs:restriction base="xs:integer">            <xs:minInclusive value="1450"/>            <xs:maxInclusive value="2026"/>          </xs:restriction>        </xs:simpleType>      </xs:element>      <xs:element name="precio">        <xs:simpleType>          <xs:restriction base="xs:decimal">            <xs:minInclusive value="0"/>            <xs:fractionDigits value="2"/>          </xs:restriction>        </xs:simpleType>      </xs:element>      <xs:element name="paginas" type="xs:positiveInteger"/>    </xs:sequence>    <xs:attribute name="codigo" use="required">      <xs:simpleType>        <xs:restriction base="xs:string">          <xs:pattern value="L[0-9]{3}"/>        </xs:restriction>      </xs:simpleType>    </xs:attribute>    <xs:attribute name="genero" use="required">      <xs:simpleType>        <xs:restriction base="xs:string">          <xs:enumeration value="novela"/>          <xs:enumeration value="poesia"/>          <xs:enumeration value="ensayo"/>          <xs:enumeration value="infantil"/>        </xs:restriction>      </xs:simpleType>    </xs:attribute>    <xs:attribute name="stock" type="xs:nonNegativeInteger" use="required"/>  </xs:complexType></xs:schema>

/observaciones/estacion[@altitud > 500]/@nombre/string()

max(//tmax)

distinct-values(//dia[lluvia > 10]/@fecha)

for $e in /observaciones/estacionreturn concat($e/@nombre, ': media de máximas ', round(avg($e/dia/tmax) * 10) div 10, ' °C, lluvia total ', sum($e/dia/lluvia), ' mm')

(for $d in //dia let $amplitud := $d/tmax - $d/tmin order by $amplitud descending return concat($d/../@nombre, ' (', $d/@fecha, '): amplitud ', round($amplitud * 10) div 10, ' °C'))[1]

<?xml version="1.0" encoding="UTF-8"?><xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">  <xsl:output method="text"/>  <xsl:template match="/observaciones">    <xsl:text>estacion;fecha;tmax;tmin;lluvia&#10;</xsl:text>    <xsl:for-each select="estacion/dia[lluvia &gt; 0]">      <xsl:sort select="../@nombre"/>      <xsl:sort select="@fecha"/>      <xsl:value-of select="concat(../@nombre, ';', @fecha, ';', tmax, ';', tmin, ';', lluvia)"/>      <xsl:text>&#10;</xsl:text>    </xsl:for-each>  </xsl:template></xsl:stylesheet>

<!ELEMENT observaciones (estacion+)><!ATTLIST observaciones  red     CDATA #REQUIRED  periodo CDATA #REQUIRED><!ELEMENT estacion (dia+)><!ATTLIST estacion  id        ID    #REQUIRED  nombre    CDATA #REQUIRED  provincia CDATA #REQUIRED  altitud   CDATA #REQUIRED><!ELEMENT dia (tmax, tmin, lluvia)><!ATTLIST dia fecha CDATA #REQUIRED><!ELEMENT tmax (#PCDATA)><!ELEMENT tmin (#PCDATA)><!ELEMENT lluvia (#PCDATA)>