Ejercicios de Python resueltos

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 sys registros = []          # (id, nombre) en el orden del fichero (sin ordenar)busquedas = []for linea in sys.stdin.read().splitlines():    p = linea.split()    if not p:        continue    if p[0] == "buscar":        busquedas.append(int(p[1]))    else:        registros.append((int(p[0]), p[1])) indice = sorted((r[0], pos) for pos, r in enumerate(registros))    # (id, posición en el fichero) def plural(n, palabra, varias):    return f"{n} {palabra if n == 1 else varias}" total_sec = total_ind = 0for x in busquedas:    # Secuencial: se leen registros desde el principio hasta encontrarlo    pos = next((i for i, r in enumerate(registros) if r[0] == x), None)    lecturas = pos + 1 if pos is not None else len(registros)    # Índice: búsqueda binaria sobre la lista ordenada    lo, hi, comparaciones, encontrado = 0, len(indice) - 1, 0, None    while lo <= hi:        mid = (lo + hi) // 2        comparaciones += 1        if indice[mid][0] == x:            encontrado = indice[mid][1]            break        if indice[mid][0] < x:            lo = mid + 1        else:            hi = mid - 1    total_sec += lecturas    total_ind += comparaciones + (1 if encontrado is not None else 0)    sec = f"secuencial {plural(lecturas, 'lectura', 'lecturas')}"    ind = f"índice {plural(comparaciones, 'comparación', 'comparaciones')}"    if encontrado is not None:        print(f"buscar {x}: encontrado ({registros[encontrado][1]}) · {sec} · {ind} + 1 lectura")    else:        print(f"buscar {x}: no existe · {sec} · {ind}")print(f"Total secuencial: {total_sec} lecturas · índice: {total_ind} accesos · ahorro {round(100 - 100 * total_ind / total_sec)} %")

import sys columnas, filas, fragmentos, consultas = [], [], [], []for linea in sys.stdin.read().splitlines():    p = linea.split(" ", 1)    if p[0] == "tabla":        columnas = p[1].split(" ")[1].split(",")    elif p[0] == "fila":        valores = p[1].split(",")        filas.append(dict(zip(columnas, valores)))    elif p[0] == "fragmento":                    # fragmento F1 sede=Madrid provincia=Madrid,Toledo        nombre, sede, cond = p[1].split(" ")        campo, valores = cond.split("=")        fragmentos.append((nombre, sede.split("=")[1], campo, valores.split(",")))    elif p[0] == "consulta":        consultas.append(p[1]) def filas_texto(n):    return f"{n} fila" if n == 1 else f"{n} filas" contenido = {f[0]: [r for r in filas if r[f[2]] in f[3]] for f in fragmentos}for nombre, sede, _, _ in fragmentos:    print(f"{nombre} ({sede}): {filas_texto(len(contenido[nombre]))}") # Completitud: cada fila debe estar en algún fragmentocampo0 = fragmentos[0][2]perdidas = [r for r in filas if not any(r in contenido[f[0]] for f in fragmentos)]if perdidas:    print("Completitud: NO, sin fragmento: " + ", ".join(f"id {r['id']} ({r[campo0]})" for r in perdidas))else:    print("Completitud: sí") # Disjunción: ninguna fila en dos fragmentosrepetidas = []for r in filas:    donde = [f[0] for f in fragmentos if r in contenido[f[0]]]    if len(donde) > 1:        repetidas.append(f"id {r['id']} en " + ", ".join(donde[:-1]) + " y " + donde[-1])print("Disjunción: " + ("NO, " + "; ".join(repetidas) if repetidas else "sí")) def cumple(r, campo, op, valor):    if op == "=":        return r[campo] == valor    return float(r[campo]) > float(valor) if op == ">" else float(r[campo]) < float(valor) for c in consultas:    if c == "todos":        campo = op = valor = None    else:        op = next(o for o in "=<>" if o in c)        campo, valor = c.split(op)    elegidos = [f for f in fragmentos                if not (op == "=" and campo == f[2]) or valor in f[3]]   # poda solo en igualdades del campo    sedes = list(dict.fromkeys(f[1] for f in elegidos))            # sin repetir, en orden    ids = sorted((r["id"] for f in elegidos for r in contenido[f[0]] if campo is None or cumple(r, campo, op, valor)), key=int)    texto = f"consulta {c} → sedes {', '.join(sedes) or 'ninguna'} · {filas_texto(len(ids))}"    print(texto + (": " + ", ".join(ids) if ids else ""))

import sysfrom collections import Counter, defaultdict lineas = [l for l in sys.stdin.read().splitlines() if l.strip()]k_objetivo = int(lineas[0].split()[1])cabecera = lineas[1].split(";")                 # nombre;dni;edad;cp;sexo;diagnosticofilas = [dict(zip(cabecera, l.split(";"))) for l in lineas[2:]] print("Identificadores eliminados: nombre, dni")anonimas = []for f in filas:    decada = int(f["edad"]) // 10 * 10    anonimas.append({"edad": f"{decada}-{decada + 9}", "cp": f["cp"][:3] + "**",                     "sexo": f["sexo"], "diagnostico": f["diagnostico"]}) clave = lambda f: (f["edad"], f["cp"], f["sexo"])          # cuasi-identificadorestamanos = Counter(clave(f) for f in anonimas)print(f"k antes de suprimir: {min(tamanos.values())}") publicables = [f for f in anonimas if tamanos[clave(f)] >= k_objetivo]if not publicables:    print("No queda ningún dato publicable")    sys.exit() print("edad;cp;sexo;diagnostico")for f in publicables:    print(f"{f['edad']};{f['cp']};{f['sexo']};{f['diagnostico']}")diagnosticos = defaultdict(set)for f in publicables:    diagnosticos[clave(f)].add(f["diagnostico"])k = min(tamanos[g] for g in diagnosticos)l_div = min(len(d) for d in diagnosticos.values())print(f"Grupos: {len(diagnosticos)} · k = {k} (objetivo {k_objetivo}) · filas suprimidas: {len(anonimas) - len(publicables)} · l-diversidad: {l_div}")if l_div == 1:    print("Atención: en algún grupo todos tienen el mismo diagnóstico, que se puede deducir")

import sys instancias = {}        # entidad → lista de ocurrenciasrelacion = None        # (nombre, entidad1, (min1, max1), entidad2, (min2, max2))pares = []for linea in sys.stdin.read().splitlines():    p = linea.split()    if not p:        continue    if p[0] == "entidad":        instancias[p[1]] = p[2:]    elif p[0] == "relacion":                 # relacion cursa Alumno(1,n) Modulo(0,2)        lados = []        for t in p[2:4]:            nombre, card = t[:-1].split("(")            mn, mx = card.split(",")            lados.append((nombre, (int(mn), None if mx == "n" else int(mx))))        relacion = (p[1], lados[0][0], lados[0][1], lados[1][0], lados[1][1])    else:        pares.append((p[1], p[2]))           # cursa A1 BD nombre, e1, card1, e2, card2 = relacionincumplimientos = 0validos = []for a, b in pares:    if a not in instancias[e1] or b not in instancias[e2]:        print(f"Ocurrencia desconocida: {a} {b}")        incumplimientos += 1    elif (a, b) in validos:        print(f"Par repetido: {a} {b}")        incumplimientos += 1    else:        validos.append((a, b))print(f"Ocurrencias válidas de {nombre}: {len(validos)}") for entidad, (minimo, maximo), lado in ((e1, card1, 0), (e2, card2, 1)):    for i in instancias[entidad]:        k = sum(1 for par in validos if par[lado] == i)        # en cuántas ocurrencias participa        if k < minimo:            print(f"{entidad} {i} participa {k} veces en {nombre} (mínimo {minimo})")            incumplimientos += 1        elif maximo is not None and k > maximo:            print(f"{entidad} {i} participa {k} veces en {nombre} (máximo {maximo})")            incumplimientos += 1 if incumplimientos:    print(f"Restricciones: {incumplimientos} {'incumplimiento' if incumplimientos == 1 else 'incumplimientos'}")else:    print("Restricciones: correctas")

import sys entidades = {}         # nombre → (claves, atributos) en ordenrelaciones = []        # (nombre, e1, card1, e2, card2, atributos)for linea in sys.stdin.read().splitlines():    p = linea.split()    if not p:        continue    if p[0] == "entidad":                    # entidad Cliente *dni nombre email        claves = [a[1:] for a in p[2:] if a.startswith("*")]        attrs = [a.lstrip("*") for a in p[2:]]        entidades[p[1]] = (claves, attrs)    elif p[0] == "relacion":                 # relacion realiza Cliente 1 Pedido N [atributos…]        relaciones.append((p[1], p[2], p[3], p[4], p[5], p[6:])) # Cada tabla: nombre → lista de columnas (nombre, es_clave, tabla_referenciada, única)tablas = {e: [(a, a in claves, None, False) for a in attrs] for e, (claves, attrs) in entidades.items()}nm = 0 def clave_ajena(tabla, clave, relacion, origen, destino):    """Nombre de la columna que recibe la clave de origen en la tabla destino."""    if origen == destino:        return f"{clave}_{relacion}"                     # relación reflexiva    if any(col[0] == clave for col in tablas[tabla]):        return f"{clave}_{origen.lower()}"               # el nombre ya está ocupado    return clave for nombre, e1, c1, e2, c2, attrs in relaciones:    if c1 == "1" and c2 == "1":                          # 1:1 → clave ajena única en la segunda        for k in entidades[e1][0]:            tablas[e2].append((clave_ajena(e2, k, nombre, e1, e2), False, e1, True))        tablas[e2] += [(a, False, None, False) for a in attrs]    elif c1 == "1" or c2 == "1":                         # 1:N → la clave del lado 1 pasa al lado N        uno, muchos = (e1, e2) if c1 == "1" else (e2, e1)        for k in entidades[uno][0]:            tablas[muchos].append((clave_ajena(muchos, k, nombre, uno, muchos), False, uno, False))        tablas[muchos] += [(a, False, None, False) for a in attrs]    else:                                                # N:M → tabla nueva        nm += 1        tablas[nombre] = []        for e in (e1, e2):            for k in entidades[e][0]:                col = f"{k}_{nombre}" if e1 == e2 and e is e2 else clave_ajena(nombre, k, nombre, e, nombre)                tablas[nombre].append((col, True, e, False))        tablas[nombre] += [(a, False, None, False) for a in attrs] for t, cols in tablas.items():    textos = [("*" if pk else "") + col + (f"→{ref}" if ref else "") + (" único" if unico else "")              for col, pk, ref, unico in cols]    print(f"{t}({', '.join(textos)})")print(f"Tablas: {len(tablas)} ({nm} por relaciones N:M)")

import sysfrom itertools import combinations lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()]atributos = lineas[0][lineas[0].index("(") + 1:-1].split(",")     # R(A,B,C,D)dependencias = []for l in lineas[1:]:    izq, der = l.split("->")    dependencias.append(([a.strip() for a in izq.split(",")], [a.strip() for a in der.split(",")])) def ordenar(conjunto):    return [a for a in atributos if a in conjunto] def cierre(x):    resultado = set(x)    cambia = True    while cambia:                                   # hasta que no se pueda deducir nada nuevo        cambia = False        for izq, der in dependencias:            if set(izq) <= resultado and not set(der) <= resultado:                resultado |= set(der)                cambia = True    return resultado todos = set(atributos)claves = []for tam in range(1, len(atributos) + 1):    for combo in combinations(atributos, tam):        if cierre(combo) == todos and not any(set(k) <= set(combo) for k in claves):   # mínimas            claves.append(combo)primos = ordenar(set().union(*map(set, claves)))print("Claves candidatas: " + ", ".join("{" + ",".join(k) + "}" for k in claves))print("Atributos primos: " + (", ".join(primos) or "ninguno")) fallos = set()for izq, der in dependencias:    texto = f"{','.join(izq)} -> {','.join(der)}"    x = ",".join(izq)    if set(der) <= set(izq):        print(f"{texto}: trivial")    elif cierre(izq) == todos:        print(f"{texto}: correcta ({x} es superclave)")    elif set(der) - set(izq) <= set(primos):        print(f"{texto}: incumple FNBC ({x} no es superclave)")        fallos.add("FNBC")    else:        parcial = next((k for k in claves if set(izq) < set(k)), None)        if parcial:            print(f"{texto}: incumple 2FN (dependencia parcial de la clave {{{','.join(parcial)}}})")            fallos.add("2FN")        else:            print(f"{texto}: incumple 3FN (dependencia transitiva)")            fallos.add("3FN") if "2FN" in fallos:    forma = "1FN"elif "3FN" in fallos:    forma = "2FN"elif "FNBC" in fallos:    forma = "3FN"else:    forma = "FNBC"print(f"Forma normal: {forma}")

import sysfrom itertools import combinations lineas = [l for l in sys.stdin.read().splitlines() if l.strip()]columnas = lineas[0].split(",")filas = [[v if v != "" else None for v in l.split(",")] for l in lineas[1:]] n = len(filas)for i, col in enumerate(columnas):    distintos = {f[i] for f in filas if f[i] is not None}    print(f"{col}: {len(distintos)} valores distintos de {n}") con_nulos = [col for i, col in enumerate(columnas) if any(f[i] is None for f in filas)]print("Columnas con nulos: " + (", ".join(con_nulos) or "ninguna")) candidatas = [i for i, col in enumerate(columnas) if col not in con_nulos]   # una clave no admite nulosclaves = []for tam in range(1, 4):    for combo in combinations(candidatas, tam):        if any(set(k) <= set(combo) for k in claves):            continue                                   # no es mínima        valores = {tuple(f[i] for i in combo) for f in filas}        if len(valores) == n:                          # ninguna combinación de valores se repite            claves.append(combo)if claves:    print("Claves candidatas según los datos: " + ", ".join("{" + ",".join(columnas[i] for i in k) + "}" for k in claves))else:    print("Claves candidatas según los datos: ninguna con hasta 3 columnas")print("Aviso: los datos solo descartan claves; que hoy no haya repetidos no garantiza que no los haya mañana")

import sysimport copy tablas = {}            # nombre → (columnas, {id: fila como dict})claves_ajenas = []     # (tabla, columna, tabla_ref, regla)ordenes = []for linea in sys.stdin.read().splitlines():    p = linea.split()    if not p:        continue    if p[0] == "tabla":        tablas[p[1]] = (p[2:], {})    elif p[0] == "fk":                       # fk pedido.cliente_id -> cliente.id ON DELETE CASCADE        t, c = p[1].split(".")        claves_ajenas.append((t, c, p[3].split(".")[0], " ".join(p[6:])))    elif p[0] == "fila":        cols, filas = tablas[p[1]]        fila = dict(zip(cols, [None if v == "NULL" else v for v in p[2:]]))        filas[fila["id"]] = fila    else:        ordenes.append(p) class Rechazo(Exception):    pass def borrar(datos, tabla, ident, borradas, anuladas):    """Borra la fila y aplica las reglas ON DELETE de quienes la referencian (recursivamente)."""    del datos[tabla][1][ident]    borradas.append(f"{tabla}#{ident}")    for hija, columna, ref, regla in claves_ajenas:        if ref != tabla:            continue        usan = [f for f in datos[hija][1].values() if f[columna] == ident]        if not usan:            continue        if regla == "RESTRICT":            n = len(usan)            raise Rechazo(f"no se puede borrar {tabla} {ident}: lo usan {n} {'fila' if n == 1 else 'filas'} de {hija}")        for f in usan:            if regla == "CASCADE":                if f["id"] in datos[hija][1]:                    borrar(datos, hija, f["id"], borradas, anuladas)            else:                                     # SET NULL                f[columna] = None                anuladas.append(f"{hija}#{f['id']}.{columna}") for orden in ordenes:    if orden[0] == "borrar":        tabla, ident = orden[1], orden[2]        prefijo = f"borrar {tabla} {ident} →"        if ident not in tablas[tabla][1]:            print(f"{prefijo} ERROR: no existe {tabla} {ident}")            continue        copia = copy.deepcopy(tablas)                  # transacción: se trabaja sobre una copia        borradas, anuladas = [], []        try:            borrar(copia, tabla, ident, borradas, anuladas)        except Rechazo as e:            print(f"{prefijo} ERROR: {e}")             # rollback: la copia se descarta            continue        tablas = copia                                 # commit        print(f"{prefijo} borradas: {', '.join(borradas)}" + (f"; a NULL: {', '.join(anuladas)}" if anuladas else ""))    elif orden[0] == "insertar":        tabla = orden[1]        cols, filas = tablas[tabla]        fila = dict(zip(cols, [None if v == "NULL" else v for v in orden[2:]]))        prefijo = f"insertar {tabla} {fila['id']} →"        if fila["id"] in filas:            print(f"{prefijo} ERROR: ya existe {tabla} {fila['id']}")            continue        falta = next(((ref, fila[col]) for t, col, ref, _ in claves_ajenas                      if t == tabla and fila[col] is not None and fila[col] not in tablas[ref][1]), None)        if falta:            print(f"{prefijo} ERROR: no existe {falta[0]} {falta[1]}")            continue        filas[fila["id"]] = fila        print(f"{prefijo} correcto")    elif orden[0] == "mostrar":        for nombre, (cols, filas) in tablas.items():            texto = " | ".join(" ".join("NULL" if f[c] is None else f[c] for c in cols) for f in filas.values())            print(f"{nombre}: {texto or '(vacía)'}")

import sys relaciones = {}        # nombre → (columnas, lista de tuplas) class ErrorAlgebra(Exception):    pass def obtener(nombre):    if nombre not in relaciones:        raise ErrorAlgebra(f"no existe {nombre}")    return relaciones[nombre] def columna(nombre, cols, c):    if c not in cols:        raise ErrorAlgebra(f"no existe la columna {c} en {nombre}")    return cols.index(c) def sin_repetidos(tuplas):    return list(dict.fromkeys(tuplas))              # conserva la primera aparición def compara(a, op, b):    try:        a, b = float(a), float(b)                   # como números si los dos lo son    except ValueError:        pass    return {"=": a == b, "<>": a != b, ">": a > b, "<": a < b}[op] def operar(op, args):    if op == "seleccion":        cols, filas = obtener(args[0])        for o in ("<>", "=", ">", "<"):            if o in args[1]:                c, valor = args[1].split(o, 1)                break        i = columna(args[0], cols, c)        return cols, [t for t in filas if compara(t[i], o, valor)]    if op == "proyeccion":        cols, filas = obtener(args[0])        indices = [columna(args[0], cols, c) for c in args[1].split(",")]        return [cols[i] for i in indices], sin_repetidos(tuple(t[i] for i in indices) for t in filas)    if op == "join":        c1, f1 = obtener(args[0])        c2, f2 = obtener(args[1])        a, b = args[2].split("=")        i, j = columna(args[0], c1, a), columna(args[1], c2, b)        cols = c1 + [c if c not in c1 else f"{args[1]}.{c}" for c in c2]        return cols, [t1 + t2 for t1 in f1 for t2 in f2 if t1[i] == t2[j]]    if op in ("union", "diferencia", "interseccion"):        c1, f1 = obtener(args[0])        c2, f2 = obtener(args[1])        if c1 != c2:            raise ErrorAlgebra(f"esquemas incompatibles ({','.join(c1)}) y ({','.join(c2)})")        if op == "union":            return c1, sin_repetidos(f1 + f2)        if op == "diferencia":            return c1, sin_repetidos(t for t in f1 if t not in f2)        return c1, sin_repetidos(t for t in f1 if t in f2)    if op == "renombrar":        cols, filas = obtener(args[0])        viejo, nuevo = args[1].split("=")        i = columna(args[0], cols, viejo)        return cols[:i] + [nuevo] + cols[i + 1:], list(filas)    raise ErrorAlgebra(f"operación desconocida {op}") lineas = sys.stdin.read().splitlines()i = 0while i < len(lineas):    l = lineas[i].strip()    if l.startswith("tabla "):                 # tabla nombre col1,col2 … filas … fin        nombre, cols = l.split()[1], l.split()[2].split(",")        filas = []        i += 1        while lineas[i].strip() != "fin":            filas.append(tuple(lineas[i].strip().split(",")))            i += 1        relaciones[nombre] = (cols, filas)    elif l.startswith("mostrar "):        nombre = l.split()[1]        if nombre not in relaciones:            print(f"ERROR: no existe {nombre}")        else:            cols, filas = relaciones[nombre]            print(f"{nombre}({', '.join(cols)})")            for t in filas:                print("  " + " | ".join(t))            print(f"  {len(filas)} {'tupla' if len(filas) == 1 else 'tuplas'}")    elif l:        destino, expresion = [x.strip() for x in l.split("=", 1)]        op, *args = expresion.split()        try:            relaciones[destino] = operar(op, args)        except ErrorAlgebra as e:            print(f"ERROR en {destino}: {e}")    i += 1

import sys DECIMAL = {"B": 1, "KB": 10**3, "MB": 10**6, "GB": 10**9, "TB": 10**12}BINARIO = {"KiB": 2**10, "MiB": 2**20, "GiB": 2**30, "TiB": 2**40}UNIDADES = {**DECIMAL, **BINARIO} for linea in sys.stdin.read().splitlines():    if not linea.strip():        continue    cantidad, unidad = linea.split()    if unidad not in UNIDADES:        print(f"{linea.strip()}: unidad desconocida")        continue    bytes_ = round(float(cantidad) * UNIDADES[unidad])    print(f"{cantidad} {unidad} = {bytes_} bytes = {bytes_ / 10**9:.2f} GB = {bytes_ / 2**30:.2f} GiB")

import sys CATALOGO = [450, 550, 650, 750, 850, 1000, 1200]EFICIENCIA = {"bronze": 0.85, "gold": 0.90, "platinum": 0.92} lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()] consumo = 0config = {}for linea in lineas:    if "=" in linea:        clave, valor = linea.split("=")        config[clave] = valor    else:        _, vatios = linea.rsplit(" ", 1)     # el nombre puede tener espacios: los vatios son lo último        consumo += float(vatios) margen = consumo * 1.3fuente = next((f for f in CATALOGO if f >= margen), None)pared = consumo * float(config["uso"]) / 100 / EFICIENCIA[config["certificacion"]]kwh = pared * float(config["horas"]) * 365 / 1000 print(f"Consumo de los componentes: {consumo:g} W")print(f"Con un margen del 30 %: {margen:.0f} W")print(f"Fuente recomendada: {f'{fuente} W' if fuente else 'ninguna del catálogo es suficiente'}")print(f"Consumo real de la pared: {pared:.1f} W")print(f"Coste anual: {kwh * float(config['precio']):.2f} € ({kwh:.1f} kWh)")

import sys PCIE_GBS_POR_LINEA = {"3": 0.985, "4": 1.969, "5": 3.938} for linea in sys.stdin.read().splitlines():    p = linea.split()    if not p:        continue    if p[0] == "ram":        mts = int(p[1].split("-")[1])        canales = int(p[2])        gbs = mts * 8 * canales / 1000        print(f"Memoria {p[1]} en {canales} {'canal' if canales == 1 else 'canales'}: {gbs:.1f} GB/s")    elif p[0] == "ssd":        ssd = int(p[1])        gen = p[2].replace("pcie", "")        lineas = int(p[3].replace("x", ""))        enlace_gbs = PCIE_GBS_POR_LINEA[gen] * lineas        enlace_mbs = round(enlace_gbs * 1000)        texto = f"SSD de {ssd} MB/s en PCIe {gen}.0 x{lineas} ({enlace_gbs:.1f} GB/s)"        if enlace_mbs < ssd:            print(f"{texto}: limitado a {enlace_mbs} MB/s ({ssd - enlace_mbs} MB/s desaprovechados)")        else:            print(f"{texto}: sin cuello de botella")

import sys lineas = [l.split() for l in sys.stdin.read().splitlines() if l.strip()]algoritmo = lineas[0][0]procesos = [(nombre, int(llegada), int(rafaga)) for nombre, llegada, rafaga in lineas[1:]] t = 0gantt = []inicio, fin = {}, {}pendientes = list(procesos)while pendientes:    llegados = [p for p in pendientes if p[1] <= t]    if not llegados:                                   # CPU libre hasta la siguiente llegada        siguiente = min(p[1] for p in pendientes)        gantt.append(f"ocioso {t}-{siguiente}")        t = siguiente        continue    if algoritmo == "FCFS":        p = min(llegados, key=lambda p: p[1])          # el que llegó antes (empate: orden de entrada)    else:        p = min(llegados, key=lambda p: (p[2], p[1], p[0]))   # ráfaga, llegada y nombre    pendientes.remove(p)    inicio[p[0]] = t    t += p[2]                                          # no expropiativo: hasta el final    fin[p[0]] = t    gantt.append(f"{p[0]} {inicio[p[0]]}-{t}") print(" | ".join(gantt))esperas, retornos = [], []for nombre, llegada, _ in procesos:    esperas.append(inicio[nombre] - llegada)    retornos.append(fin[nombre] - llegada)    print(f"{nombre}: espera {esperas[-1]}, retorno {retornos[-1]}")print(f"Espera media: {sum(esperas) / len(esperas):.2f}")print(f"Retorno medio: {sum(retornos) / len(retornos):.2f}")

import sysfrom collections import deque lineas = [l.split() for l in sys.stdin.read().splitlines() if l.strip()]quantum = int(lineas[0][1])procesos = [(nombre, int(llegada), int(rafaga)) for nombre, llegada, rafaga in lineas[1:]] llegadas = sorted(procesos, key=lambda p: p[1])   # sorted es estable: empates en orden de entradaresto = {nombre: rafaga for nombre, _, rafaga in procesos}fin = {}cola = deque()tramos = []t = i = 0 def admitir():    """Mete en la cola a los procesos que ya han llegado en el instante t."""    global i    while i < len(llegadas) and llegadas[i][1] <= t:        cola.append(llegadas[i][0])        i += 1 while i < len(llegadas) or cola:    admitir()    if not cola:                                   # CPU ociosa hasta la siguiente llegada        tramos.append(("ocioso", t, llegadas[i][1]))        t = llegadas[i][1]        continue    nombre = cola.popleft()    duracion = min(quantum, resto[nombre])    tramos.append((nombre, t, t + duracion))    t += duracion    resto[nombre] -= duracion    admitir()                                      # los que llegan durante el tramo van antes…    if resto[nombre] > 0:        cola.append(nombre)                        # …que el proceso expulsado    else:        fin[nombre] = t print(" | ".join(f"{n} {a}-{b}" for n, a, b in tramos))esperas, retornos = [], []for nombre, llegada, rafaga in procesos:    retornos.append(fin[nombre] - llegada)    esperas.append(retornos[-1] - rafaga)    print(f"{nombre}: espera {esperas[-1]}, retorno {retornos[-1]}")print(f"Espera media: {sum(esperas) / len(esperas):.2f}")print(f"Retorno medio: {sum(retornos) / len(retornos):.2f}")print(f"Cambios de contexto: {sum(1 for a, b in zip(tramos, tramos[1:]) if a[0] != b[0])}")

import sysfrom collections import deque lineas = [l.split() for l in sys.stdin.read().splitlines() if l.strip()]marcos = int(lineas[0][1])referencias = [int(x) for x in lineas[1]] def fifo(refs):    memoria, fallos = deque(), 0    for p in refs:        if p not in memoria:            fallos += 1            if len(memoria) == marcos:                memoria.popleft()                 # sale la que lleva más tiempo cargada            memoria.append(p)    return fallos def lru(refs):    memoria, fallos = [], 0                       # de la menos a la más recientemente usada    for p in refs:        if p in memoria:            memoria.remove(p)        else:            fallos += 1            if len(memoria) == marcos:                memoria.pop(0)                    # sale la que hace más tiempo que no se usa        memoria.append(p)    return fallos def optimo(refs):    memoria, fallos = [], 0                       # en orden de carga    for i, p in enumerate(refs):        if p in memoria:            continue        fallos += 1        if len(memoria) == marcos:            def proximo_uso(q):                futuro = refs[i + 1:]                return futuro.index(q) if q in futuro else float("inf")            # la que tardará más en usarse; en empate (no vuelven), la cargada antes: max devuelve la primera            memoria.remove(max(memoria, key=proximo_uso))        memoria.append(p)    return fallos total = len(referencias)for nombre, algoritmo in (("FIFO", fifo), ("LRU", lru), ("Óptimo", optimo)):    f = algoritmo(referencias)    print(f"{nombre}: {f} fallos ({f / total * 100:.1f} %)")

import sys lineas = [l.split() for l in sys.stdin.read().splitlines() if l.strip()]disco_mib = int(lineas[0][1].replace("GiB", "")) * 1024ultimo = disco_mib - 1                       # el último MiB es para la copia de la tabla GPT def mib(tamano):    if tamano.endswith("GiB"):        return round(float(tamano[:-3]) * 1024)    return int(tamano[:-3])                  # «…MiB» pos = 1                                      # el primer MiB es para la tabla y la alineaciónfor nombre, tamano in lineas[1:]:    tam = ultimo - pos if tamano == "resto" else mib(tamano)    if pos + tam > ultimo:        print(f"ERROR: no cabe {nombre} (faltan {pos + tam - ultimo} MiB)")        break    print(f"{nombre}: inicio {pos} MiB, fin {pos + tam} MiB, tamaño {tam / 1024:.2f} GiB")    pos += tamelse:    print(f"Sin asignar: {(ultimo - pos) / 1024:.2f} GiB")

import sys lineas = [l.split() for l in sys.stdin.read().splitlines() if l.strip()]config = {l[0]: l[1] for l in lineas[:3]}          # firmware, tabla, discoparticiones = lineas[3:]                            # nombre clase sistema tamaño_GiB punto_de_montaje def num(x):    return f"{x:g}"                                 # 109.0 → «109», 120.5 → «120.5» uefi = config["firmware"] == "uefi"mbr = config["tabla"] == "mbr"disco = float(config["disco"])clases = [p[1] for p in particiones]problemas = [] if uefi and config["tabla"] != "gpt":    problemas.append("UEFI necesita una tabla GPT (o activar el modo CSM)")if mbr:    if disco > 2048:        problemas.append(f"MBR solo puede usar 2048 GiB de los {num(disco)} GiB del disco")    if clases.count("primaria") + clases.count("extendida") > 4:        problemas.append("MBR admite como máximo 4 particiones primarias o extendidas")    if clases.count("extendida") > 1:        problemas.append("Solo puede haber una partición extendida")    if "logica" in clases and "extendida" not in clases:        problemas.append("Las particiones lógicas necesitan una partición extendida")elif "extendida" in clases or "logica" in clases:    problemas.append("GPT no tiene particiones extendidas ni lógicas")if uefi and not any(p[2] == "fat32" and p[4] == "/boot/efi" for p in particiones):    problemas.append("Falta la partición EFI (FAT32 montada en /boot/efi)")if not any(p[4] == "/" for p in particiones):    problemas.append("Falta la partición raíz (/)")ocupado = sum(float(p[3]) for p in particiones if p[1] != "extendida")   # la extendida contiene a las lógicasif ocupado > disco:    problemas.append(f"Las particiones ocupan {num(ocupado)} GiB y el disco tiene {num(disco)} GiB") print("\n".join(problemas) if problemas else "Esquema válido")

import sys datos = bytes.fromhex("".join(sys.stdin.read().split()))   # las 4 entradas (64 bytes) y la firma (2 bytes)TIPOS = {0x07: "NTFS/exFAT", 0x0B: "FAT32", 0x0C: "FAT32 LBA", 0x83: "Linux", 0x82: "Linux swap",         0x05: "Extendida", 0x0F: "Extendida LBA", 0xEE: "GPT de protección", 0xEF: "Sistema EFI"} for n in range(4):    entrada = datos[n * 16:(n + 1) * 16]    tipo = entrada[4]    if tipo == 0:        continue                                            # entrada vacía    activa = "activa, " if entrada[0] == 0x80 else ""    inicio = int.from_bytes(entrada[8:12], "little")    sectores = int.from_bytes(entrada[12:16], "little")    gib = sectores * 512 / 2**30    print(f"Partición {n + 1}: {activa}tipo {tipo:02X} ({TIPOS.get(tipo, 'desconocido')}), "          f"sector inicial {inicio}, {sectores} sectores ({gib:.2f} GiB)")    if tipo == 0xEE:        print("El disco usa GPT: esta entrada solo protege el disco de herramientas antiguas") firma = datos[64:66]print("Firma: correcta (55 AA)" if firma == b"\x55\xaa" else f"Firma: incorrecta ({firma[0]:02X} {firma[1]:02X})")

import sys MINIMO = {"RAID0": 2, "RAID1": 2, "RAID5": 3, "RAID6": 4, "RAID10": 4} for linea in sys.stdin.read().splitlines():    if not linea.strip():        continue    nivel, n, tam = linea.split()    n, tam = int(n), int(tam)    if nivel not in MINIMO:        print(f"{nivel}: nivel desconocido")        continue    if n < MINIMO[nivel] or (nivel == "RAID10" and n % 2):        par = " y un número par" if nivel == "RAID10" else ""        print(f"{nivel} con {n} discos: no válido (necesita al menos {MINIMO[nivel]} discos{par})")        continue    util = {"RAID0": n, "RAID1": 1, "RAID5": n - 1, "RAID6": n - 2, "RAID10": n // 2}[nivel] * tam    if nivel == "RAID10":        tolera = f"1 fallo por pareja (hasta {n // 2})"    else:        f = {"RAID0": 0, "RAID1": n - 1, "RAID5": 1, "RAID6": 2}[nivel]        tolera = f"{f} {'fallo' if f == 1 else 'fallos'}"    print(f"{nivel} con {n} × {tam} GB: {util} GB útiles ({util / (n * tam) * 100:.0f} %), tolera {tolera}")

import sys lineas = [l.split() for l in sys.stdin.read().splitlines() if l.strip()]datos = float(lineas[0][1])cambio = float(lineas[1][1])plan = lineas[2][1:]          # C = completa, I = incremental, D = diferencial, un día cada una total = 0ultima_completa = Nonevalidas = []                  # (día, tipo) de las copias que se han hechofor dia, tipo in enumerate(plan, 1):    if tipo != "C" and ultima_completa is None:        print(f"Día {dia}: ERROR, una copia {tipo} necesita una completa anterior")        continue    if tipo == "C":        tam = datos        ultima_completa = dia    elif tipo == "I":        tam = datos * cambio / 100                                   # solo lo de un día    else:        tam = min(datos, datos * cambio / 100 * (dia - ultima_completa))   # todo desde la completa    total += tam    validas.append((dia, tipo))    print(f"Día {dia} ({tipo}): {tam:.1f} GB")print(f"Total ocupado: {total:.1f} GB") # Restaurar: última completa, última diferencial posterior y las incrementales que vengan detrásc = max(d for d, t in validas if t == "C")difs = [d for d, t in validas if t == "D" and d > c]desde = difs[-1] if difs else cnecesarias = [c] + difs[-1:] + [d for d, t in validas if t == "I" and d > desde]print("Para restaurar el último día: " + ", ".join(f"día {d}" for d in necesarias))

import sys texto = sys.stdin.read().split("---")original = [l.split() for l in texto[0].splitlines() if l.strip()]   # ruta tamaño hashcopia = [l.split() for l in texto[1].splitlines() if l.strip()] orig = {ruta: (int(tam), h) for ruta, tam, h in original}cop = {ruta: (int(tam), h) for ruta, tam, h in copia} movidos, faltan, distintos = [], [], []sobran = [r for r in cop if r not in orig]for ruta, (tam, h) in orig.items():    if ruta in cop:        if cop[ruta][1] != h:            distintos.append(f"DISTINTO {ruta} ({tam} bytes en el original, {cop[ruta][0]} en la copia)")        continue    nueva = next((r for r in sobran if cop[r][1] == h), None)   # ¿está en otra ruta con el mismo hash?    if nueva:        movidos.append(f"MOVIDO {ruta} -> {nueva}")        sobran.remove(nueva)    else:        faltan.append(f"FALTA {ruta}") for grupo in (movidos, faltan, distintos, [f"SOBRA {r}" for r in sobran]):    for linea in sorted(grupo):        print(linea)correctos = sum(1 for r, (_, h) in orig.items() if r in cop and cop[r][1] == h)mib = sum(t for t, _ in orig.values()) / 2**20print(f"Correctos: {correctos} de {len(orig)} · Datos del original: {mib:.2f} MiB")print("Copia VÁLIDA" if not faltan and not distintos else "Copia NO VÁLIDA")

import sys # Distancia máxima en metros de cada medio para cada velocidad (Gbit/s)MAXIMO = {    "cat5e": {1: 100},    "cat6": {1: 100, 10: 55},    "cat6a": {1: 100, 10: 100},    "cat8": {10: 30, 25: 30, 40: 30},    "om3": {1: 550, 10: 300, 40: 100},    "om4": {1: 550, 10: 400, 40: 150},    "os2": {1: 10000, 10: 10000, 40: 10000},} for linea in sys.stdin.read().splitlines():    if not linea.strip():        continue    medio, metros, velocidad = linea.split()    if medio not in MAXIMO:        print(f"{medio}: medio desconocido")        continue    metros, v = int(metros), int(velocidad.rstrip("G"))    tramo = f"{medio}, {metros} m a {v}G"    if v not in MAXIMO[medio]:        inferiores = ", ".join(f"{x}G" for x in sorted(MAXIMO[medio]) if x < v) or "ninguna"        print(f"{tramo}: NO (no admite {v}G; velocidades inferiores válidas: {inferiores})")    elif metros <= MAXIMO[medio][v]:        print(f"{tramo}: SÍ (máximo {MAXIMO[medio][v]} m)")    else:        sirven = ", ".join(sorted(m for m, d in MAXIMO.items() if d.get(v, 0) >= metros)) or "ninguno"        print(f"{tramo}: NO (máximo {MAXIMO[medio][v]} m; sirve {sirven})")

import sys lineas = [l.split() for l in sys.stdin.read().splitlines() if l.strip()]puertos = int(lineas[0][1])BROADCAST = "FF:FF:FF:FF:FF:FF" tabla = {}                                  # MAC → puertofor puerto, origen, destino in lineas[1:]:    p = int(puerto)    if tabla.get(origen) != p:              # nueva, o el equipo se ha movido de puerto        tabla[origen] = p        print(f"Aprende {origen} en el puerto {p}")    otros = ", ".join(str(x) for x in range(1, puertos + 1) if x != p)    if destino == BROADCAST:        print(f"  Difusión: inunda por {otros}")    elif destino not in tabla:        print(f"  {destino} desconocido: inunda por {otros}")    elif tabla[destino] == p:        print(f"  {destino} está en el mismo puerto: descarta la trama")    else:        print(f"  Reenvía a {destino} por el puerto {tabla[destino]}") print("Tabla MAC:")for mac in sorted(tabla):    print(f"  {mac} → puerto {tabla[mac]}")

import sys lineas = [l.split() for l in sys.stdin.read().splitlines() if l.strip()]raiz = lineas[0][1]                       # equipo desde el que se sale a Internetenlaces = [(a, b) for _, a, b in lineas[1:]] vecinos = {}for a, b in enlaces:    vecinos.setdefault(a, set()).add(b)    vecinos.setdefault(b, set()).add(a) def alcanzables(sin):    """Equipos a los que se llega desde la raíz sin pasar por el equipo «sin»."""    vistos, pila = {raiz}, [raiz]    while pila:        x = pila.pop()        for v in vecinos[x]:            if v != sin and v not in vistos:                vistos.add(v)                pila.append(v)    return vistos puntos = 0for equipo in sorted(vecinos):    if equipo == raiz or len(vecinos[equipo]) < 2:        continue    aislados = sorted(set(vecinos) - alcanzables(equipo) - {equipo})    if aislados:        puntos += 1        print(f"Si falla {equipo}: sin red {', '.join(aislados)}")    else:        print(f"Si falla {equipo}: nadie pierde la red (hay caminos alternativos)")print(f"Puntos únicos de fallo: {puntos}")

import sys def a_entero(ip):    a, b, c, d = (int(x) for x in ip.split("."))    return (a << 24) | (b << 16) | (c << 8) | d def a_texto(n):    return ".".join(str((n >> s) & 255) for s in (24, 16, 8, 0)) for linea in sys.stdin.read().splitlines():    if not linea.strip():        continue    primero, segundo = linea.split()    ip, prefijo = primero.split("/")    prefijo = int(prefijo)    mascara = (0xFFFFFFFF << (32 - prefijo)) & 0xFFFFFFFF   # prefijo unos seguidos de ceros    red1 = a_entero(ip) & mascara    red2 = a_entero(segundo) & mascara    if red1 == red2:        print(f"{ip} y {segundo}: misma red {a_texto(red1)}/{prefijo}, comunicación directa")    else:        print(f"{ip} y {segundo}: redes distintas ({a_texto(red1)} y {a_texto(red2)}), hace falta un router")

import sys for linea in sys.stdin.read().splitlines():    d = linea.strip()    if not d:        continue    if "::" in d or len(d.split(":")) != 8:        # Expandir: los grupos que faltan son los que representa «::»        izq, _, der = d.partition("::")        gi = [g for g in izq.split(":") if g]        gd = [g for g in der.split(":") if g]        grupos = gi + ["0"] * (8 - len(gi) - len(gd)) + gd        resultado = ":".join(g.lower().zfill(4) for g in grupos)    else:        # Abreviar: sin ceros a la izquierda y «::» en la serie de ceros más larga        grupos = [format(int(g, 16), "x") for g in d.split(":")]        mejor, largo, i = -1, 0, 0        while i < 8:            if grupos[i] == "0":                j = i                while j < 8 and grupos[j] == "0":                    j += 1                if j - i > largo:                  # con «>», en empate gana la primera                    mejor, largo = i, j - i                i = j            else:                i += 1        if largo >= 2:            resultado = ":".join(grupos[:mejor]) + "::" + ":".join(grupos[mejor + largo:])        else:            resultado = ":".join(grupos)    print(f"{d} → {resultado}")

import sys def a_entero(ip):    a, b, c, d = (int(x) for x in ip.split("."))    return (a << 24) | (b << 16) | (c << 8) | d def a_texto(n):    return ".".join(str((n >> s) & 255) for s in (24, 16, 8, 0)) lineas = [l.split() for l in sys.stdin.read().splitlines() if l.strip()]base_ip, base_prefijo = lineas[0][1].split("/")departamentos = [(nombre, int(hosts)) for nombre, hosts in lineas[1:]] inicio = a_entero(base_ip)fin_red = inicio + 2 ** (32 - int(base_prefijo))pos = iniciofor nombre, hosts in sorted(departamentos, key=lambda d: (-d[1], d[0])):    bits = 2    while 2 ** bits - 2 < hosts:             # la subred más pequeña que alcanza        bits += 1    tam = 2 ** bits    if pos + tam > fin_red:        print(f"{nombre}: no hay espacio para {hosts} hosts")        continue    print(f"{nombre} ({hosts}): {a_texto(pos)}/{32 - bits}, hosts {a_texto(pos + 1)} - {a_texto(pos + tam - 2)}, "          f"difusión {a_texto(pos + tam - 1)}, sobran {tam - 2 - hosts}")    pos += tamlibre = fin_red - posprint(f"Libre: {libre} direcciones desde {a_texto(pos)}" if libre else "Libre: 0 direcciones")

import sys NIVELES = ["ninguno", "lectura", "modificar", "control"] lineas = [l.split() for l in sys.stdin.read().splitlines() if l.strip()] compartido, ntfs, denegados, usuarios = {}, {}, set(), []for l in lineas:    if l[0] in ("compartido", "ntfs"):        capa = compartido if l[0] == "compartido" else ntfs        capa[l[1]] = max(capa.get(l[1], 0), NIVELES.index(l[2]))    elif l[0] == "denegar":        denegados.add(l[1])    elif l[0] == "usuario":        usuarios.append((l[1], l[2].split(","))) for nombre, grupos in usuarios:    c = max((compartido.get(g, 0) for g in grupos), default=0)       # dentro de una capa, se suman    if any(g in denegados for g in grupos):        n = 0                                                        # la denegación gana a todo    else:        n = max((ntfs.get(g, 0) for g in grupos), default=0)    efectivo = min(c, n)                                             # entre capas, la más restrictiva    print(f"{nombre}: compartido {NIVELES[c]}, NTFS {NIVELES[n]} → efectivo {NIVELES[efectivo]}")

import sys def a_entero(ip):    a, b, c, d = (int(x) for x in ip.split("."))    return (a << 24) | (b << 16) | (c << 8) | d texto = sys.stdin.read().split("---")reglas = [l.split() for l in texto[0].splitlines() if l.strip()]      # la primera línea es «politica allow|deny»paquetes = [l.split() for l in texto[1].splitlines() if l.strip()] politica = reglas[0][1] def en_red(ip, red):    if red == "any":        return True    base, _, prefijo = red.partition("/")    prefijo = int(prefijo) if prefijo else 32                          # una IP sola es un /32    mascara = (0xFFFFFFFF << (32 - prefijo)) & 0xFFFFFFFF    return a_entero(ip) & mascara == a_entero(base) & mascara def coincide(regla, proto, ip, puerto):    _, r_proto, r_puerto, _, r_red = regla    return (r_proto in ("any", proto)            and (r_puerto == "any" or int(r_puerto) == int(puerto))            and en_red(ip, r_red)) for proto, ip, puerto in paquetes:    for n, regla in enumerate(reglas[1:], 1):        if coincide(regla, proto, ip, puerto):            print(f"{proto} {ip} → {puerto}: {regla[0].upper()} (regla {n})")            break    else:        print(f"{proto} {ip} → {puerto}: {politica.upper()} (política por defecto)")

import sysimport math DICCIONARIO = {"password", "123456", "qwerty", "admin", "iloveyou", "dragon", "monkey", "letmein",               "futbol", "barcelona", "madrid", "contraseña", "hola", "princesa", "superman"} UNIDADES = [("años", 365 * 86400), ("días", 86400), ("horas", 3600), ("minutos", 60)] def tiempo(segundos):    if segundos < 1:        return "instantáneo"    for nombre, s in UNIDADES:        valor = segundos / s        if valor >= 1:            if valor >= 1_000_000:                return f"más de un millón de {nombre}"            if valor < 100:                return f"{valor:.1f} {nombre}"            return f"{round(valor):,} {nombre}".replace(",", ".")   # punto de miles    return "menos de 1 minuto" for clave in sys.stdin.read().splitlines():    if not clave:        continue    base = clave.lower()    if base in DICCIONARIO or base.rstrip("0123456789.!") in DICCIONARIO:        print(f"{clave}: muy débil (está en los diccionarios de contraseñas)")        continue    juego = (26 * any(c.islower() for c in clave) + 26 * any(c.isupper() for c in clave)             + 10 * any(c.isdigit() for c in clave) + 33 * any(not c.isalnum() for c in clave))    bits = len(clave) * math.log2(juego)    if len(set(clave)) <= len(clave) / 3:          # muchos caracteres repetidos        bits /= 2    nivel = "débil" if bits < 40 else "media" if bits < 60 else "fuerte" if bits < 80 else "muy fuerte"    segundos = 2 ** bits / 2 / 1e10    print(f"{clave}: {nivel} ({bits:.1f} bits, {tiempo(segundos)} por fuerza bruta)")

import sysimport csvfrom datetime import date lineas = sys.stdin.read().splitlines()hoy = date.fromisoformat(lineas[0].split("=")[1])filas = list(csv.DictReader(lineas[1:], delimiter=";"))   # codigo;tipo;aula;precio;fin_garantia aulas = {}for f in filas:    aulas.setdefault(f["aula"], []).append(f) total_equipos, total_valor, total_vencidos = 0, 0.0, 0for aula in sorted(aulas):    equipos = aulas[aula]    valor = sum(float(e["precio"]) for e in equipos)    vencidos = sorted(e["codigo"] for e in equipos if date.fromisoformat(e["fin_garantia"]) < hoy)    linea = f"{aula}: {len(equipos)} {'equipo' if len(equipos) == 1 else 'equipos'}, {valor:.2f} €"    if vencidos:        linea += ", sin garantía: " + ", ".join(vencidos)    print(linea)    total_equipos += len(equipos)    total_valor += valor    total_vencidos += len(vencidos) porcentaje = total_vencidos / total_equipos * 100print(f"TOTAL: {total_equipos} equipos, {total_valor:.2f} €, {total_vencidos} sin garantía ({porcentaje:.0f} %)")

import sysimport reimport unicodedata lineas = sys.stdin.read().splitlines() def ancla(titulo):    s = unicodedata.normalize("NFD", titulo.lower())    s = "".join(c for c in s if unicodedata.category(c) != "Mn")   # quita las tildes    s = re.sub(r"[^a-z0-9 -]", "", s)    return s.replace(" ", "-") usadas = {}en_codigo = Falsen2 = n3 = 0for linea in lineas:    if linea.startswith("```"):        en_codigo = not en_codigo        continue    if en_codigo:        continue    m = re.match(r"^(#{2,3})\s+(.*)
quot;, linea)    if not m:        continue    titulo = m.group(2).strip()    a = ancla(titulo)    if a in usadas:        usadas[a] += 1        a = f"{a}-{usadas[a]}"                    # la segunda vez -1, la tercera -2…    else:        usadas[a] = 0    if len(m.group(1)) == 2:        n2 += 1        n3 = 0        print(f"{n2}. [{titulo}](#{a})")    else:        n3 += 1        print(f"   {n2}.{n3}. [{titulo}](#{a})")

import sysimport reimport html lineas = sys.stdin.read().splitlines() def en_linea(texto):    """Formato dentro de una línea; el código se aparta primero para que no se interprete."""    codigos = []    def guardar(m):        codigos.append(m.group(1))        return f"\x00{len(codigos) - 1}\x00"    texto = re.sub(r"`([^`]+)`", guardar, texto)    texto = re.sub(r"\*\*(.+?)\*\*", r"<strong>\1</strong>", texto)    texto = re.sub(r"\*(.+?)\*", r"<em>\1</em>", texto)    texto = re.sub(r"\[([^\]]+)\]\(([^)]+)\)", r'<a href="\2">\1</a>', texto)    return re.sub(r"\x00(\d+)\x00", lambda m: f"<code>{codigos[int(m.group(1))]}</code>", texto) salida, parrafo, codigo = [], [], []lista = None                     # "ul", "ol" o Noneen_codigo = False def cerrar_parrafo():    if parrafo:        salida.append("<p>" + en_linea(" ".join(parrafo)) + "</p>")        parrafo.clear() def cerrar_lista():    global lista    if lista:        salida.append(f"</{lista}>")        lista = None for linea in lineas:    if en_codigo:        if linea.startswith("```"):            salida.append("<pre><code>" + "\n".join(codigo) + "</code></pre>")            en_codigo = False        else:            codigo.append(html.escape(linea, quote=False))        continue    if linea.startswith("```"):        cerrar_parrafo(); cerrar_lista()        en_codigo, codigo = True, []        continue    texto = html.escape(linea, quote=False)    titulo = re.match(r"^(#{1,6})\s+(.*)
quot;, texto)    elemento = re.match(r"^(?:([-*])|\d+\.)\s+(.*)
quot;, texto)    if not texto.strip():        cerrar_parrafo(); cerrar_lista()    elif titulo:        cerrar_parrafo(); cerrar_lista()        n = len(titulo.group(1))        salida.append(f"<h{n}>{en_linea(titulo.group(2))}</h{n}>")    elif elemento:        cerrar_parrafo()        tipo = "ul" if elemento.group(1) else "ol"        if lista != tipo:            cerrar_lista()            salida.append(f"<{tipo}>")            lista = tipo        salida.append(f"<li>{en_linea(elemento.group(2))}</li>")    else:        cerrar_lista()        parrafo.append(texto)cerrar_parrafo(); cerrar_lista()if en_codigo:    salida.append("<pre><code>" + "\n".join(codigo) + "</code></pre>")print("\n".join(salida))

import sys ETAPAS = [("Nuevo", 10), ("Calificado", 30), ("Propuesta", 50), ("Negociación", 75), ("Ganado", 100), ("Perdido", 0)] lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()] cuenta = {etapa: 0 for etapa, _ in ETAPAS}importe = {etapa: 0.0 for etapa, _ in ETAPAS}for linea in lineas:    _, etapa, valor = linea.split(";")    cuenta[etapa] += 1    importe[etapa] += float(valor) prevision = 0.0for etapa, probabilidad in ETAPAS:    print(f"{etapa}: {cuenta[etapa]} oportunidades, {importe[etapa]:.2f} €")    if etapa not in ("Ganado", "Perdido"):           # solo las abiertas        prevision += importe[etapa] * probabilidad / 100print(f"Previsión ponderada: {prevision:.2f} €") cerradas = cuenta["Ganado"] + cuenta["Perdido"]if cerradas:    print(f"Tasa de conversión: {cuenta['Ganado'] / cerradas * 100:.1f} %")else:    print("Tasa de conversión: -")

import sys lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()] anios = int(lineas[0].split()[1])opciones = []for linea in lineas[1:]:    nombre, licencia, usuarios, implantacion, formacion, hardware, mantenimiento = linea.split(";")    tco = (float(licencia) * int(usuarios) * 12 * anios + float(implantacion) + float(formacion)           + float(hardware) + float(mantenimiento) * anios)    opciones.append((tco, nombre)) opciones.sort()                                   # por TCO y, a igualdad, por nombrefor tco, nombre in opciones:    print(f"{nombre}: {tco:.2f} €")print(f"Recomendada: {opciones[0][1]}")if len(opciones) > 1:    barata, cara = opciones[0][0], opciones[-1][0]    print(f"Ahorro frente a la más cara: {cara - barata:.2f} € ({(cara - barata) / cara * 100:.1f} %)")

import sysimport math CATALOGO = [("S", 2, 4), ("M", 4, 8), ("L", 8, 16), ("XL", 16, 32)] lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()] for linea in lineas:    nombre, concurrentes, nucleos, ram = linea.split(";")    nucleos, ram_mb = int(nucleos), int(ram) * 1024    workers = max(2, math.ceil(int(concurrentes) / 6))    nucleos_necesarios = math.ceil(workers / 2)    memoria_necesaria = (workers + 1) * 250 + 2048 + 1024   # workers + cron, PostgreSQL y sistema     print(f"== {nombre}")    print(f"workers = {workers}")    print("max_cron_threads = 1")    if nucleos >= nucleos_necesarios:        print("CPU: suficiente")    else:        print(f"CPU: insuficiente (faltan {nucleos_necesarios - nucleos} núcleos)")    if ram_mb >= memoria_necesaria:        print("Memoria: suficiente")    else:        print(f"Memoria: insuficiente (faltan {memoria_necesaria - ram_mb} MB)")    if nucleos < nucleos_necesarios or ram_mb < memoria_necesaria:        servidor = next((n for n, c, g in CATALOGO if c >= nucleos_necesarios and g * 1024 >= memoria_necesaria), None)        print(f"Recomendado: {servidor or 'varios servidores'}")

import sys lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()]LETRA = {"leer": "r", "escribir": "w", "crear": "c", "borrar": "d"} accesos = {}      # (grupo, modelo) → letras de permisousuarios = {}     # usuario → gruposseccion = ""for linea in lineas:    if linea.startswith("["):        seccion = linea        continue    p = linea.split()    if seccion == "[accesos]":        grupo, modelo, permisos = p        clave = (grupo, modelo)        accesos[clave] = accesos.get(clave, set()) | set(permisos.replace("-", ""))   # varias filas se suman    elif seccion == "[usuarios]":        usuarios[p[0]] = p[1].split(",")    elif seccion == "[consultas]":        usuario, accion, modelo = p        permisos = set()        for grupo in usuarios.get(usuario, []):          # un usuario desconocido no tiene grupos            permisos |= accesos.get((grupo, modelo), set())        estado = "PERMITIDO" if LETRA[accion] in permisos else "DENEGADO"        print(f"{usuario} {accion} {modelo}: {estado}")

import sysimport re TABLA = "TRWAGMYFPDXBNJZSQVHLCKE" lineas = [l for l in sys.stdin.read().splitlines() if l.strip()] def nif_valido(nif):    m = re.fullmatch(r"([XYZ]\d{7}|\d{8})([A-Z])", nif)    if not m:        return False    numero = int(str("XYZ".index(m.group(1)[0])) + m.group(1)[1:] if m.group(1)[0] in "XYZ" else m.group(1))    return TABLA[numero % 23] == m.group(2) validos = errores = duplicados = 0vistos = {}                                    # NIF → línea donde apareció válidofor n, linea in enumerate(lineas[1:], start=2):    nombre, nif, email, telefono = linea.split(";")    # Normalizar    nombre = " ".join(nombre.split())    nif = nif.upper().replace("-", "").replace(" ", "")    email = email.strip().lower()    telefono = re.sub(r"[ .\-]", "", telefono.strip())    for prefijo in ("+34", "0034"):        if telefono.startswith(prefijo):            telefono = telefono[len(prefijo):]    # Validar    error = None    if not nif_valido(nif):        error = "NIF no válido"    elif not re.fullmatch(r"[^@\s]+@[^@\s]+\.[A-Za-z]{2,}", email):        error = "correo no válido"    elif not re.fullmatch(r"[6789]\d{8}", telefono):        error = "teléfono no válido"    if error:        print(f"ERROR línea {n}: {error}")        errores += 1    elif nif in vistos:        print(f"DUPLICADO línea {n}: {nif} (ya en la línea {vistos[nif]})")        duplicados += 1    else:        vistos[nif] = n        print(f"OK {nif};{nombre};{email};{telefono}")        validos += 1print(f"Válidos: {validos} · Errores: {errores} · Duplicados: {duplicados}")

import sysfrom datetime import date fechas = [date.fromisoformat(l.strip()) for l in sys.stdin.read().split() if l.strip()] copias = sorted(set(fechas), reverse=True)          # sin repetir, de la más reciente a la más antigua diaria = set(copias[:7])semanal, mensual = set(), set()semanas, meses = [], []for f in copias:                                    # la primera de cada periodo es la más reciente    semana = f.isocalendar()[:2]                    # (año ISO, semana ISO)    if semana not in semanas:        semanas.append(semana)        if len(semanas) <= 4:            semanal.add(f)    mes = (f.year, f.month)    if mes not in meses:        meses.append(mes)        if len(meses) <= 12:            mensual.add(f) conservadas = 0for f in copias:    motivos = [m for m, grupo in (("diaria", diaria), ("semanal", semanal), ("mensual", mensual)) if f in grupo]    if motivos:        conservadas += 1        print(f"{f} conservar ({', '.join(motivos)})")    else:        print(f"{f} borrar")print(f"Conservadas: {conservadas} · Borradas: {len(copias) - conservadas}")

cantidad = int(input())if cantidad >= 10:    print("Descuento del 5 %")else:    print("Sin descuento")

clientes = [("Carlos", 558.0), ("Ana", 1079.86), ("Javier", 165.4), ("Lucía", 297.0)]ranking = sorted(clientes, key=lambda c: c[1], reverse=True)for posicion, (nombre, importe) in enumerate(ranking, start=1):    print(f"{posicion}. {nombre}: {importe:.2f} €")

almacenes, productos = 2, 3stock = [[0] * productos for _ in range(almacenes)]stock[0][1] = 5for i, fila in enumerate(stock):    print(f"Almacén {i}: {fila}")

import sysimport astimport json lineas = [l for l in sys.stdin.read().splitlines() if l.strip()]dominio = ast.literal_eval(lineas[0])registros = [json.loads(l) for l in lineas[1:]] def cumple(condicion, registro):    campo, op, valor = condicion    v = registro.get(campo)                         # un campo que falta vale None    if op in ("=", "!="):        igual = (v is None or v is False) if valor is False else v == valor        return igual if op == "=" else not igual    if op == "in":        return v in valor    if op == "not in":        return v not in valor    if v is None:        return False    if op == "ilike":        return str(valor).lower() in str(v).lower()    return {">": v > valor, ">=": v >= valor, "<": v < valor, "<=": v <= valor}[op] def evalua(i, registro):    """Evalúa la expresión que empieza en la posición i; devuelve (resultado, siguiente posición)."""    t = dominio[i]    if t in ("&", "|"):        a, i = evalua(i + 1, registro)        b, i = evalua(i, registro)        return (a and b) if t == "&" else (a or b), i    if t == "!":        a, i = evalua(i + 1, registro)        return not a, i    return cumple(t, registro), i + 1 ids = []for r in registros:    i, resultado = 0, True    while i < len(dominio):                         # los términos del nivel superior se unen con Y        valor, i = evalua(i, r)        resultado = resultado and valor    if resultado:        ids.append(str(r["id"]))print(" ".join(ids) or "ninguno")

lineas = ["Portátil", "Ratón", "Ratón", "Webcam", "Ratón", "Portátil"]ventas = {}for producto in lineas:    ventas[producto] = ventas.get(producto, 0) + 1for producto, unidades in sorted(ventas.items()):    print(producto, unidades)

import sysfrom datetime import date lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()]hoy = date.fromisoformat(lineas[0]) for linea in lineas[1:]:    nombre, compra, vida, precio = linea.split(";")    dias = (hoy - date.fromisoformat(compra)).days    if dias < 0:        print(f"{nombre}: fecha de compra futura")        continue    anios = dias / 365    valor = max(0.0, float(precio) * (1 - anios / float(vida)))   # nunca por debajo de 0    estado = "amortizado" if valor == 0 else "en uso"    print(f"{nombre}: {valor:.2f} € ({estado}, {anios:.1f} años)")

class Pedido:    def __init__(self, cliente, lineas=None):        self.cliente = cliente        self.lineas = [] if lineas is None else lineas     def anadir(self, producto, cantidad):        self.lineas.append((producto, cantidad))  p1 = Pedido("Ana")p1.anadir("Portátil", 1)p2 = Pedido("Luis")p2.anadir("Ratón", 2)print(p1.cliente, len(p1.lineas))print(p2.cliente, len(p2.lineas))

productos = [["Auriculares", 0], ["Webcam", 0], ["Ratón", 120], ["Altavoz", 0], ["Teclado", 45]]productos = [p for p in productos if p[1] != 0]print([p[0] for p in productos])

estado = input().strip()if estado == "confirmado":    print("Pedido confirmado: se genera la factura")else:    print(f"El pedido está en estado {estado}: todavía no se factura")

import sysfrom datetime import date lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()]hoy = date.fromisoformat(lineas[0])TIPOS = ("preventivo", "correctivo") guardados = set()                       # (equipo, fecha) de los registros guardadosfor n, linea in enumerate(lineas[1:], start=1):    equipo, fecha, coste, tipo = linea.split(";")    if float(coste) < 0:        error = "el coste no puede ser negativo"    elif tipo not in TIPOS:        error = f"tipo «{tipo}» no permitido"    elif date.fromisoformat(fecha) > hoy:        error = "la fecha no puede ser futura"    elif (equipo, fecha) in guardados:        error = f"{equipo} ya tiene un mantenimiento el {fecha}"    else:        guardados.add((equipo, fecha))   # solo se guarda si pasa todas las restricciones        continue    print(f"ValidationError en el registro {n}: {error}")print(f"Guardados: {len(guardados)}")

import sysfrom datetime import date lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()]patron = lineas[0].split("=", 1)[1]relleno = int(lineas[1].split("=")[1])reinicio = lineas[2].split("=")[1] contadores = {}                          # periodo → último número usadofor texto in lineas[3:]:    f = date.fromisoformat(texto)    if reinicio == "anual":        periodo = f.year    elif reinicio == "mensual":        periodo = (f.year, f.month)    else:        periodo = None                   # un único contador    contadores[periodo] = contadores.get(periodo, 0) + 1    prefijo = patron % {"year": f"{f.year:04d}", "y": f"{f.year % 100:02d}",                        "month": f"{f.month:02d}", "day": f"{f.day:02d}"}    print(f"{texto} → {prefijo}{str(contadores[periodo]).zfill(relleno)}")

from decimal import Decimal, ROUND_HALF_UP lineas = [("Tornillos", 1.15), ("Arandelas", 1.525), ("Tuercas", 2.675)]for nombre, importe in lineas:    print(nombre, Decimal(str(importe)).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))

import sys lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()] base = iva = 0.0for linea in lineas:    _, cantidad, precio, tipo = linea.split(";")    importe = float(cantidad) * float(precio)    base += importe    iva += importe * float(tipo) / 100        # cada línea con su tipo de IVAprint(f"Base: {base:.2f}")print(f"IVA: {iva:.2f}")print(f"Total: {base + iva:.2f}")

import sys lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()] separador = lineas.index("---")stock = {}for linea in lineas[:separador]:    producto, cantidad = linea.split()    stock[producto] = int(cantidad) for linea in lineas[separador + 1:]:    tipo, producto, cantidad = linea.split()    cantidad = int(cantidad)    if tipo == "entrada":        stock[producto] = stock.get(producto, 0) + cantidad    elif cantidad > stock.get(producto, 0):        print(f"ERROR: stock insuficiente de {producto}")    else:        stock[producto] -= cantidad for producto in sorted(stock):    print(f"{producto}: {stock[producto]}")

import sysimport re lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()]TABLA = "TRWAGMYFPDXBNJZSQVHLCKE" for linea in lineas:    doc = linea.upper()    m = re.fullmatch(r"([XYZ]\d{7}|\d{8})([A-Z])", doc)   # NIE: letra y 7 cifras; NIF: 8 cifras    valido = False    if m:        numero = m.group(1)        if numero[0] in "XYZ":            numero = str("XYZ".index(numero[0])) + numero[1:]   # X=0, Y=1, Z=2        valido = TABLA[int(numero) % 23] == m.group(2)    print(f"{doc} {'válido' if valido else 'no válido'}")

import sysfrom datetime import date lineas = [l.strip() for l in sys.stdin.read().splitlines() if l.strip()] informe = date.fromisoformat(lineas[0])TRAMOS = ["No vencido", "1-30", "31-60", "61-90", "Más de 90"]totales = {t: 0.0 for t in TRAMOS}vencido = {}                                          # cliente → importe vencidofor linea in lineas[1:]:    _, cliente, vencimiento, pendiente = linea.split(";")    dias = (informe - date.fromisoformat(vencimiento)).days    importe = float(pendiente)    if dias <= 0:        tramo = "No vencido"    elif dias <= 30:        tramo = "1-30"    elif dias <= 60:        tramo = "31-60"    elif dias <= 90:        tramo = "61-90"    else:        tramo = "Más de 90"    totales[tramo] += importe    if dias > 0:        vencido[cliente] = vencido.get(cliente, 0) + importe for t in TRAMOS:    print(f"{t}: {totales[t]:.2f}")if vencido:    cliente = max(vencido, key=vencido.get)    print(f"Mayor deudor vencido: {cliente} ({vencido[cliente]:.2f})")else:    print("Mayor deudor vencido: ninguno")

import sys  def formato(numero):    """Dos decimales con coma, como se escriben las notas en España."""    return f"{numero:.2f}".replace(".", ",")  def main():    lineas = sys.stdin.read().split("\n")    clave = lineas[0].split()[1]    n = len(clave)    alumnos = []                  # (nombre, nota) de cada examen válido    fallos = [0] * n              # fallos de cada pregunta    aciertos_pregunta = [0] * n   # aciertos de cada pregunta     for num, linea in enumerate(lineas[1:], start=2):        linea = linea.strip()        if not linea:            continue        if ";" not in linea:            print(f"Aviso: la línea {num} no tiene el formato nombre;respuestas")            continue        nombre, respuestas = (parte.strip() for parte in linea.split(";", 1))        if len(respuestas) != n or any(r not in "ABCD-" for r in respuestas):            print(f"Aviso: las respuestas de {nombre} no son válidas y no se corrigen")            continue        aciertos = mal = 0        for i, (respuesta, correcta) in enumerate(zip(respuestas, clave)):            if respuesta == "-":                continue            if respuesta == correcta:                aciertos += 1                aciertos_pregunta[i] += 1            else:                mal += 1                fallos[i] += 1        # Tres fallos restan un acierto, pero la puntuación nunca baja de 0        puntos = max(0, aciertos - mal / 3)        alumnos.append((nombre, puntos * 10 / n))     if not alumnos:        print("No hay exámenes que corregir.")        return     alumnos.sort(key=lambda a: (-a[1], a[0]))    print(f"Corrección de {n} preguntas")    for pos, (nombre, nota) in enumerate(alumnos, start=1):        print(f"{pos:>2}. {nombre:<22}{formato(nota):>6}")     media = sum(nota for _, nota in alumnos) / len(alumnos)    aprobados = sum(1 for _, nota in alumnos if nota >= 5)    print(f"Media: {formato(media)}")    print(f"Aprobados: {aprobados} de {len(alumnos)}")     # max devuelve el primero de los empatados: la pregunta de número más bajo    peor = max(range(n), key=lambda i: fallos[i])    if fallos[peor] == 0:        print("Pregunta más fallada: ninguna")    else:        print(f"Pregunta más fallada: {peor + 1} ({fallos[peor]} {'fallo' if fallos[peor] == 1 else 'fallos'})")    sin_aciertos = [str(i + 1) for i in range(n) if aciertos_pregunta[i] == 0]    print("Sin aciertos: " + (", ".join(sin_aciertos) if sin_aciertos else "ninguna"))  main()

import sys  def euros(centimos):    """1234.5 € → «1.234,50 €»: puntos de millar y coma decimal."""    texto = f"{centimos / 100:,.2f}"    return texto.replace(",", "X").replace(".", ",").replace("X", ".") + " €"  def leer_venta(linea):    """Devuelve (fecha, producto, categoría, unidades, importe en céntimos) o None si la línea no es válida."""    partes = [p.strip() for p in linea.split(",")]    if len(partes) != 5:        return None    fecha, producto, categoria, unidades, precio = partes    try:        unidades = int(unidades)        precio_cent = round(float(precio) * 100)    except ValueError:        return None    if unidades <= 0 or precio_cent < 0:        return None    return fecha, producto, categoria, unidades, unidades * precio_cent  def main():    lineas = sys.stdin.read().split("\n")    por_categoria, por_producto, por_dia, por_mes = {}, {}, {}, {}    total = 0    descartadas = []    for num, linea in enumerate(lineas[1:], start=2):        if not linea.strip():            continue        venta = leer_venta(linea)        if venta is None:            descartadas.append(num)            continue        fecha, producto, categoria, unidades, importe = venta        total += importe        por_categoria[categoria] = por_categoria.get(categoria, 0) + importe        por_producto[producto] = por_producto.get(producto, 0) + unidades        por_dia[fecha] = por_dia.get(fecha, 0) + importe        mes = fecha[:7]        por_mes[mes] = por_mes.get(mes, 0) + importe     if total == 0 and not por_producto:        print("No hay ventas válidas.")        return     print(f"Ventas totales: {euros(total)}")    print("Por categoría:")    for categoria, importe in sorted(por_categoria.items(), key=lambda c: (-c[1], c[0])):        porcentaje = f"{100 * importe / total:.1f}".replace(".", ",")        print(f"  {categoria:<16}{euros(importe):>12}  {porcentaje:>5} %")     producto, unidades = min(por_producto.items(), key=lambda p: (-p[1], p[0]))    print(f"Producto más vendido: {producto} ({unidades} {'unidad' if unidades == 1 else 'unidades'})")    dia, importe = min(por_dia.items(), key=lambda d: (-d[1], d[0]))    print(f"Mejor día: {dia} ({euros(importe)})")     print("Por mes:")    for mes in sorted(por_mes):        barra = "#" * (por_mes[mes] // 5000)   # una almohadilla por cada 50 €        print(f"  {mes}  {euros(por_mes[mes]):>12} {barra}".rstrip())     lista = f" ({', '.join(map(str, descartadas))})" if descartadas else ""    print(f"Líneas descartadas: {len(descartadas)}{lista}")  main()

import sys NOMBRES = {"FCFS": "FCFS (primero en llegar, primero en ser servido)", "SJF": "SJF (el más corto primero, sin expulsión)",           "SRTF": "SRTF (menor tiempo restante, con expulsión)", "RR": "Round Robin"}  def coma(x):    return f"{x:.2f}".replace(".", ",")  def simular(algoritmo, quantum, procesos):    """Devuelve el diagrama de Gantt como lista de [nombre, inicio, fin] y el instante en que termina cada proceso."""    restante = {p["nombre"]: p["rafaga"] for p in procesos}    orden = {p["nombre"]: i for i, p in enumerate(procesos)}    pendientes = sorted(procesos, key=lambda p: (p["llegada"], orden[p["nombre"]]))    listos, gantt, fin = [], [], {}    t = 0     def admitir(hasta):        """Pasa a la cola de listos los procesos que han llegado hasta el instante «hasta»."""        while pendientes and pendientes[0]["llegada"] <= hasta:            listos.append(pendientes.pop(0))     def ejecutar(p, duracion):        nonlocal t        if gantt and gantt[-1][0] == p["nombre"] and gantt[-1][2] == t:            gantt[-1][2] += duracion          # el mismo proceso sigue: se alarga el tramo        else:            gantt.append([p["nombre"], t, t + duracion])        t += duracion        restante[p["nombre"]] -= duracion     admitir(t)    while listos or pendientes:        if not listos:                        # CPU ociosa hasta la siguiente llegada            gantt.append(["--", t, pendientes[0]["llegada"]])            t = pendientes[0]["llegada"]            admitir(t)            continue        if algoritmo == "FCFS":            p = listos.pop(0)            ejecutar(p, restante[p["nombre"]])        elif algoritmo == "SJF":            p = min(listos, key=lambda q: (q["rafaga"], q["llegada"], orden[q["nombre"]]))            listos.remove(p)            ejecutar(p, restante[p["nombre"]])        elif algoritmo == "SRTF":            p = min(listos, key=lambda q: (restante[q["nombre"]], q["llegada"], orden[q["nombre"]]))            # Se ejecuta hasta que acabe o hasta la próxima llegada, que puede expulsarlo            hasta = t + restante[p["nombre"]]            if pendientes:                hasta = min(hasta, pendientes[0]["llegada"])            ejecutar(p, hasta - t)            if restante[p["nombre"]] > 0:                admitir(t)                continue            listos.remove(p)        else:  # RR            p = listos.pop(0)            ejecutar(p, min(quantum, restante[p["nombre"]]))            admitir(t)                        # los que llegan entran en la cola antes que el expulsado            if restante[p["nombre"]] > 0:                listos.append(p)                continue        fin[p["nombre"]] = t        admitir(t)    return gantt, fin  def main():    lineas = sys.stdin.read().split("\n")    cabecera = lineas[0].split()    algoritmo = cabecera[0].upper() if cabecera else ""    quantum = 0    if algoritmo == "RR":        if len(cabecera) != 2 or not cabecera[1].isdigit() or int(cabecera[1]) == 0:            print("Algoritmo no válido")            return        quantum = int(cabecera[1])    elif algoritmo not in NOMBRES or len(cabecera) != 1:        print("Algoritmo no válido")        return     procesos = []    for num, linea in enumerate(lineas[1:], start=2):        partes = linea.split()        if not partes:            continue        if len(partes) != 3 or not partes[1].isdigit() or not partes[2].isdigit() or int(partes[2]) == 0 \                or any(p["nombre"] == partes[0] for p in procesos):            print(f"Aviso: línea {num} ignorada")            continue        procesos.append({"nombre": partes[0], "llegada": int(partes[1]), "rafaga": int(partes[2])})    if not procesos:        print("No hay procesos")        return     gantt, fin = simular(algoritmo, quantum, procesos)    print("Algoritmo: " + NOMBRES[algoritmo] + (f" con quantum {quantum}" if algoritmo == "RR" else ""))    print("Diagrama: " + " ".join(f"| {n} {a}-{b}" for n, a, b in gantt) + " |")    print(f"{'Proceso':<8}{'Llegada':>8}{'Ráfaga':>8}{'Fin':>6}{'Retorno':>9}{'Espera':>8}")    retornos, esperas = [], []    for p in procesos:        retorno = fin[p["nombre"]] - p["llegada"]        espera = retorno - p["rafaga"]        retornos.append(retorno)        esperas.append(espera)        print(f"{p['nombre']:<8}{p['llegada']:>8}{p['rafaga']:>8}{fin[p['nombre']]:>6}{retorno:>9}{espera:>8}")    print(f"Media de retorno: {coma(sum(retornos) / len(procesos))} · Media de espera: {coma(sum(esperas) / len(procesos))}")    ocupada = sum(b - a for n, a, b in gantt if n != "--")    print(f"Uso de la CPU: {coma(100 * ocupada / gantt[-1][2])} %")  main()

import sys  def a_numero(ip):    """«192.168.10.0» → entero de 32 bits; None si no es una IPv4."""    partes = ip.split(".")    if len(partes) != 4 or not all(p.isdigit() and int(p) <= 255 for p in partes):        return None    n = 0    for p in partes:        n = n * 256 + int(p)    return n  def a_ip(n):    return ".".join(str((n >> desplazamiento) & 255) for desplazamiento in (24, 16, 8, 0))  def mascara(prefijo):    return (0xFFFFFFFF << (32 - prefijo)) & 0xFFFFFFFF  def prefijo_para(hosts):    """El prefijo más largo cuyo bloque tiene sitio para «hosts» (sin contar la red y la difusión), como mucho /30."""    prefijo = 30    while 2 ** (32 - prefijo) - 2 < hosts:        prefijo -= 1    return prefijo  def main():    lineas = sys.stdin.read().split("\n")    texto = lineas[0].strip()    if texto.count("/") != 1 or a_numero(texto.split("/")[0]) is None or not texto.split("/")[1].isdigit() \            or not 8 <= int(texto.split("/")[1]) <= 30:        print(f"Red no válida: {texto}")        return    ip, prefijo = texto.split("/")    prefijo = int(prefijo)    base = a_numero(ip)    if base & mascara(prefijo) != base:        print(f"{ip} no es una dirección de red (sería {a_ip(base & mascara(prefijo))}/{prefijo})")        return    total = 2 ** (32 - prefijo)     subredes = []    for num, linea in enumerate(lineas[1:], start=2):        partes = linea.split()        if not partes:            continue        if len(partes) < 2 or not partes[-1].isdigit() or int(partes[-1]) == 0:            print(f"Aviso: línea {num} ignorada")            continue        subredes.append((" ".join(partes[:-1]), int(partes[-1])))     print(f"Red: {a_ip(base)}/{prefijo} ({total} direcciones)")    # VLSM: de la más grande a la más pequeña, así cada bloque queda alineado con su tamaño    siguiente = base    for nombre, hosts in sorted(subredes, key=lambda s: -s[1]):        p = prefijo_para(hosts)        tamano = 2 ** (32 - p)        if p < prefijo or siguiente + tamano > base + total:            print(f"{nombre} ({hosts} hosts) → no cabe: necesita un /{p} y quedan {base + total - siguiente} direcciones")            continue        print(f"{nombre} ({hosts} hosts) → {a_ip(siguiente)}/{p}")        print(f"  máscara {a_ip(mascara(p))} · hosts útiles {tamano - 2}")        print(f"  primera {a_ip(siguiente + 1)} · última {a_ip(siguiente + tamano - 2)} · difusión {a_ip(siguiente + tamano - 1)}")        siguiente += tamano     libres = base + total - siguiente    if libres:        print(f"Sin asignar: {libres} de {total} direcciones, desde {a_ip(siguiente)}")    else:        print(f"Sin asignar: 0 de {total} direcciones")  main()

import sysfrom decimal import Decimal, ROUND_HALF_UP  def euros(x):    """Decimal → «1.234,56 €» redondeado al céntimo."""    x = x.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)    return f"{x:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".") + " €"  def main():    productos = {}       # código → datos del producto    movimientos = []     # (fecha, orden de la entrada, tipo, código, cantidad, coste)    for num, linea in enumerate(sys.stdin.read().split("\n"), start=1):        linea = linea.strip()        if not linea:            continue        tipo, _, resto = linea.partition(" ")        campos = [c.strip() for c in resto.split(";")]        try:            if tipo == "PRODUCTO" and len(campos) == 4:                codigo, nombre, minimo, maximo = campos[0], campos[1], int(campos[2]), int(campos[3])                if codigo in productos or not 0 <= minimo <= maximo:                    raise ValueError                productos[codigo] = {"nombre": nombre, "minimo": minimo, "maximo": maximo, "lotes": [], "vendido": Decimal(0)}            elif tipo == "ENTRADA" and len(campos) == 4:                cantidad, coste = int(campos[2]), Decimal(campos[3])                if cantidad <= 0 or coste < 0 or campos[1] not in productos:                    raise ValueError                movimientos.append((campos[0], num, tipo, campos[1], cantidad, coste))            elif tipo == "SALIDA" and len(campos) == 3:                cantidad = int(campos[2])                if cantidad <= 0 or campos[1] not in productos:                    raise ValueError                movimientos.append((campos[0], num, tipo, campos[1], cantidad, None))            else:                raise ValueError        except (ValueError, ArithmeticError):            print(f"Aviso: línea {num} ignorada")     # Los movimientos llegan desordenados: se aplican por fecha (y, el mismo día, en el orden de la entrada)    for fecha, _, tipo, codigo, cantidad, coste in sorted(movimientos):        p = productos[codigo]        if tipo == "ENTRADA":            p["lotes"].append([cantidad, coste])            continue        stock = sum(c for c, _ in p["lotes"])        if cantidad > stock:            print(f"Aviso: salida de {cantidad} {codigo} el {fecha} rechazada (stock {stock})")            continue        # FIFO: se gastan primero las unidades de los lotes más antiguos, a su coste        while cantidad:            lote = p["lotes"][0]            usadas = min(cantidad, lote[0])            p["vendido"] += usadas * lote[1]            lote[0] -= usadas            cantidad -= usadas            if lote[0] == 0:                p["lotes"].pop(0)     if not productos:        print("No hay productos")        return    total = Decimal(0)    reponer = []    print("Inventario:")    for codigo, p in productos.items():        stock = sum(c for c, _ in p["lotes"])        valor = sum((c * coste for c, coste in p["lotes"]), Decimal(0))        total += valor        print(f"  {codigo} {p['nombre']}: stock {stock} · valor {euros(valor)} · coste de lo vendido {euros(p['vendido'])}")        if stock < p["minimo"]:            reponer.append(f"  {codigo} {p['nombre']}: pedir {p['maximo'] - stock} (stock {stock}, mínimo {p['minimo']}, máximo {p['maximo']})")    print("Reponer:" if reponer else "Reponer: nada")    for r in reponer:        print(r)    print(f"Valor del almacén: {euros(total)}")  main()

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

import reimport sysfrom datetime import datetime, timedelta FALLO = re.compile(r"Failed password for (invalid user )?(\S+) from (\S+) port")EXITO = re.compile(r"Accepted (password|publickey) for (\S+) from (\S+) port")VENTANA = timedelta(minutes=10)MAX_FALLOS = 5  def main():    fallos_ip = {}            # ip → lista de instantes de fallo    bloqueos = {}             # ip → (instante del bloqueo, primer fallo de la ventana)    inexistentes = set()    fallos_usuario = {}    alertas = []    n_fallos = n_exitos = 0     for linea in sys.stdin.read().split("\n"):        if not linea.strip():            continue        # Las líneas de syslog empiezan con «Oct  3 10:15:01» (sin año)        try:            instante = datetime.strptime(linea[:15], "%b %d %H:%M:%S").replace(year=2026)        except ValueError:            continue        if m := FALLO.search(linea):            n_fallos += 1            invalido, usuario, ip = m.groups()            if invalido:                inexistentes.add(usuario)            fallos_usuario[usuario] = fallos_usuario.get(usuario, 0) + 1            lista = fallos_ip.setdefault(ip, [])            lista.append(instante)            # Ventana deslizante: solo cuentan los fallos de los últimos 10 minutos            recientes = [t for t in lista if instante - t <= VENTANA]            if len(recientes) >= MAX_FALLOS and ip not in bloqueos:                bloqueos[ip] = (instante, recientes[0])        elif m := EXITO.search(linea):            n_exitos += 1            _, usuario, ip = m.groups()            previos = len(fallos_ip.get(ip, []))            if previos:                alertas.append(f"  {usuario} entró desde {ip} a las {instante:%H:%M:%S} tras {previos} {'fallo' if previos == 1 else 'fallos'} desde esa IP")     print(f"Intentos fallidos: {n_fallos} · Accesos correctos: {n_exitos}")    if bloqueos:        print("Bloquear:")        for ip, (cuando, desde) in sorted(bloqueos.items(), key=lambda b: b[1][0]):            print(f"  {ip} a las {cuando:%H:%M:%S} ({MAX_FALLOS} fallos desde las {desde:%H:%M:%S})")    else:        print("Bloquear: ninguna IP")    print("Usuarios inexistentes probados: " + (", ".join(sorted(inexistentes)) if inexistentes else "ninguno"))    if fallos_usuario:        ranking = sorted(fallos_usuario.items(), key=lambda u: (-u[1], u[0]))[:3]        print("Usuarios más atacados: " + ", ".join(f"{u} ({n})" for u, n in ranking))    print("Alertas:" if alertas else "Alertas: ninguna")    for a in alertas:        print(a)  main()