Ejercicios resueltos de Sistemas Informáticos

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

#!/bin/bashread -r nombre if [ -z "$nombre" ]; then    echo "Error: nombre vacío"    exit 0fiecho "Hola, $nombre"echo "Tu nombre tiene ${#nombre} letras"

#!/bin/bashread -r n if [[ ! $n =~ ^[0-9]+$ ]] || (( 10#$n == 0 )); then    echo "Error: número no válido"    exit 0fifor i in {1..10}; do    echo "$n x $i = $(( 10#$n * i ))"done

#!/bin/bashread -r nombresaludo="Hola, $nombre"echo "$saludo"

#!/bin/bashlog=$(cat) awk '$3 == "ERROR" { errores++; porIp[$4]++ }$3 == "WARN"  { avisos++ }END {    for (ip in porIp)        if (porIp[ip] > max || (porIp[ip] == max && ip < mejor)) { max = porIp[ip]; mejor = ip }    print "Errores: " errores + 0    print "Avisos: " avisos + 0    print "IP con más errores: " mejor " (" max + 0 ")"}' <<< "$log"

#!/bin/bash# La entrada estándar es el contenido de /etc/passwd usuarios=$(awk -F: '$3 >= 1000 && $3 != 65534 { printf "%d\t%s (%s) -> %s [%s]\n", $3, $1, $3, $6, $7 }' | sort -n | cut -f2-)[ -n "$usuarios" ] && echo "$usuarios"echo "Total: $(grep -c . <<< "$usuarios")"

#!/bin/bashdir=$(mktemp -d)cd "$dir" || exit 1 while read -r f || [ -n "$f" ]; do    [ -z "$f" ] && continue    touch -- "$f"    case $f in        *.sh)  chmod 750 -- "$f" ;;     # rwxr-x---: el dueño lo ejecuta, el grupo lo lee y ejecuta        *.key) chmod 600 -- "$f" ;;     # rw-------: una clave solo la lee su dueño        *)     chmod 644 -- "$f" ;;     # rw-r--r--: lo normal para un fichero de datos    esacdoneLC_ALL=C stat -c '%a %n' -- * | LC_ALL=C sort -k2

#!/bin/bashread -r usoif [ "$uso" -gt 80 ]; then  echo "ALERTA: disco al $uso %"else  echo "OK"fi

#!/bin/bashread -r a bif (( a > b )); then  echo "El mayor es $a"else  echo "El mayor es $b"fi

#!/bin/bashread -r nombreif [ "$nombre" = "Ana López" ]; then  echo "Bienvenida, Ana"else  echo "No te conozco"fi

#!/bin/bashread -r umbral alertas=$(awk -v u="$umbral" 'NR > 1 {    uso = $5    sub(/%/, "", uso)    if (uso + 0 >= u) print "ALERTA: " $NF " al " uso "%"}')if [ -n "$alertas" ]; then echo "$alertas"; else echo "Todo correcto"; fi

#!/bin/bash# Lee el log por la entrada estándarlog=$(cat) fallos=$(grep 'Failed password for' <<< "$log")if [ -n "$fallos" ]; then    awk '{ for (i = 1; i <= NF; i++) if ($i == "from") print $(i + 1) }' <<< "$fallos" |        LC_ALL=C sort | uniq -c | LC_ALL=C sort -b -k1,1nr -k2,2 |        while read -r n ip; do            if (( n >= 5 )); then echo "$ip: $n intentos → BLOQUEAR"; else echo "$ip: $n intentos"; fi        donefiecho "Usuarios inexistentes probados: $(grep -o 'invalid user [^ ]*' <<< "$fallos" | sort -u | grep -c .)"

#!/bin/bashtotal=0while read -r n || [ -n "$n" ]; do  total=$((total + n))doneecho "Total: $total"

#!/bin/bashread -r horah=${hora%%:*}m=${hora##*:}echo $(( 10#$h * 60 + 10#$m ))

#!/bin/bashwhile read -r p || [ -n "$p" ]; do    [ -z "$p" ] && continue    if [[ $p =~ ^[r-][w-][xsS-][r-][w-][xsS-][r-][w-][xtT-]$ ]]; then        # Simbólico → octal        especial=0; octal=""        for t in 0 1 2; do            trio=${p:t*3:3}; v=0            [ "${trio:0:1}" = r ] && v=$((v + 4))            [ "${trio:1:1}" = w ] && v=$((v + 2))            case ${trio:2:1} in x|s|t) v=$((v + 1)) ;; esac                     # s y t llevan la x            case ${trio:2:1} in s|S|t|T) especial=$((especial + (4 >> t))) ;; esac   # 4, 2 o 1            octal+=$v        done        (( especial )) && octal="$especial$octal"        echo "$p = $octal"    elif [[ $p =~ ^[0-7]{3,4}$ ]]; then        # Octal → simbólico        o=$p        [ ${#p} -eq 3 ] && o="0$p"        esp=${o:0:1}; texto=""        for t in 0 1 2; do            d=${o:t+1:1}; r=-; w=-; x=-            (( d & 4 )) && r=r            (( d & 2 )) && w=w            (( d & 1 )) && x=x            if (( esp & (4 >> t) )); then                if (( t == 2 )); then                    if [ $x = x ]; then x=t; else x=T; fi                else                    if [ $x = x ]; then x=s; else x=S; fi                fi            fi            texto+="$r$w$x"        done        echo "$o = $texto"    else        echo "$p: no válido"    fidone

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

#!/bin/bash# Entrada: un nombre de fichero por línea awk 'NF {    n = split($0, partes, ".")    if (n > 1 && partes[n] != "") ext[tolower(partes[n])]++    else sinext++}END {    for (e in ext) print e ": " ext[e] | "LC_ALL=C sort"    close("LC_ALL=C sort")                  # espera a que sort termine antes de seguir    if (sinext) print "(sin extensión): " sinext}'

#!/bin/bashocteto='(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])'ip_valida="^$octeto\.$octeto\.$octeto\.$octeto\
quot; while read -r ip || [ -n "$ip" ]; do  [ -z "$ip" ] && continue  if [[ $ip =~ $ip_valida ]]; then    echo "IP válida"  else    echo "IP no válida"  fidone

#!/bin/bashread -r entradaip=${entrada%/*}prefijo=${entrada#*/} a_texto() { echo "$(( ($1 >> 24) & 255 )).$(( ($1 >> 16) & 255 )).$(( ($1 >> 8) & 255 )).$(( $1 & 255 ))"; } IFS=. read -r a b c d <<< "$ip"n=$(( (a << 24) | (b << 16) | (c << 8) | d ))mascara=$(( (0xFFFFFFFF << (32 - prefijo)) & 0xFFFFFFFF ))red=$(( n & mascara ))difusion=$(( red | (~mascara & 0xFFFFFFFF) )) echo "Red: $(a_texto $red)"echo "Broadcast: $(a_texto $difusion)"echo "Hosts: $(( (1 << (32 - prefijo)) - 2 ))"

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

#!/bin/bash# Orden de texto byte a byte: así sort y [[ < ]] ordenan igual en cualquier máquinaexport LC_ALL=C declare -A por_ip por_ruta rutas_404total=0bytes_total=0invalidas=0c2=0 c3=0 c4=0 c5=0 while read -r ip _ _ _ _ metodo ruta _ codigo bytes _; do  [ -z "$ip" ] && continue  if [ -z "$bytes" ] || ! [[ $codigo =~ ^[0-9]{3}$ ]]; then    invalidas=$((invalidas + 1))    continue  fi  total=$((total + 1))  por_ip[$ip]=$(( ${por_ip[$ip]:-0} + 1 ))  por_ruta[$ruta]=$(( ${por_ruta[$ruta]:-0} + 1 ))  # Una respuesta sin cuerpo trae «-» en lugar del tamaño  [ "$bytes" != "-" ] && bytes_total=$((bytes_total + bytes))  case ${codigo:0:1} in    2) c2=$((c2 + 1)) ;;    3) c3=$((c3 + 1)) ;;    4) c4=$((c4 + 1)) ;;    5) c5=$((c5 + 1)) ;;  esac  [ "$codigo" = "404" ] && rutas_404[$ruta]=1done if [ "$total" -eq 0 ]; then  echo "No hay peticiones válidas."  exit 0fi echo "Peticiones: $total"echo "Visitantes distintos: ${#por_ip[@]}"echo "Respuestas: 2xx $c2 · 3xx $c3 · 4xx $c4 · 5xx $c5"echo "Datos enviados: $((bytes_total / 1024)) KB" echo "IPs con más peticiones:"for ip in "${!por_ip[@]}"; do  echo "${por_ip[$ip]} $ip"done | sort -k1,1nr -k2,2 | head -n 3 | while read -r n ip; do  printf "%3d %s\n" "$n" "$ip"done mejor=""for ruta in "${!por_ruta[@]}"; do  n=${por_ruta[$ruta]}  if [ -z "$mejor" ] || [ "$n" -gt "${por_ruta[$mejor]}" ] || { [ "$n" -eq "${por_ruta[$mejor]}" ] && [[ $ruta < $mejor ]]; }; then    mejor=$ruta  fidoneveces=${por_ruta[$mejor]}[ "$veces" -eq 1 ] && palabra="vez" || palabra="veces"echo "Página más pedida: $mejor ($veces $palabra)" if [ ${#rutas_404[@]} -eq 0 ]; then  echo "Errores 404: ninguno"else  echo "Errores 404:"  printf "%s\n" "${!rutas_404[@]}" | sort | while read -r ruta; do    echo "  $ruta"  donefi [ "$invalidas" -gt 0 ] && echo "Líneas no válidas: $invalidas"exit 0

#!/bin/bash# Genera las órdenes para dar de alta usuarios a partir de un CSV, sin ejecutarlas (modo simulación)export LC_ALL=C # «Lucía Martín Ruiz» → «lmartinr»: sin tildes ni eñes, en minúsculas y solo letrasnormalizar() {  local s=$1 i  local con=(á é í ó ú ü ñ Á É Í Ó Ú Ü Ñ) sin=(a e i o u u n a e i o u u n)  for i in "${!con[@]}"; do    s=${s//${con[$i]}/${sin[$i]}}  done  s=${s,,}  echo "${s//[^a-z]/}"} read -r palabra lista_gruposif [ "$palabra" != "GRUPOS" ] || [ -z "$lista_grupos" ]; then  echo "La primera línea debe ser GRUPOS grupo1,grupo2…"  exit 0fiIFS=',' read -r -a grupos <<< "$lista_grupos" declare -A existe por_gruporead -r palabra lista_existenif [ "$palabra" = "EXISTEN" ]; then  IFS=',' read -r -a cuentas <<< "$lista_existen"  for c in "${cuentas[@]}"; do existe[$c]=1; done  numero=2else  echo "Falta la línea EXISTEN"  exit 0fi altas=0while IFS=';' read -r nombre ape1 ape2 grupo resto; do  numero=$((numero + 1))  [ -z "$nombre$ape1$ape2$grupo" ] && continue  if [ -z "$nombre" ] || [ -z "$ape1" ] || [ -z "$grupo" ] || [ -n "$resto" ]; then    echo "# Línea $numero: faltan o sobran campos"    continue  fi  valido=0  for g in "${grupos[@]}"; do [ "$g" = "$grupo" ] && valido=1; done  if [ $valido -eq 0 ]; then    echo "# Línea $numero: grupo desconocido $grupo"    continue  fi   # Primero se normaliza y después se toma la inicial: con LC_ALL=C, ${s:0:1} es un byte, y la Í ocupa dos  n=$(normalizar "$nombre")  a1=$(normalizar "$ape1")  a2=$(normalizar "$ape2")  base="${n:0:1}$a1${a2:0:1}"  login=$base  n=2  # Si el login ya existe (en el sistema o en este mismo fichero), se le añade un número  while [ -n "${existe[$login]}" ]; do    login="$base$n"    n=$((n + 1))  done  existe[$login]=1  completo="$nombre $ape1${ape2:+ $ape2}"  echo "useradd -m -s /bin/bash -g $grupo -c \"$completo\" $login"  echo "chage -d 0 $login"  por_grupo[$grupo]=$(( ${por_grupo[$grupo]:-0} + 1 ))  altas=$((altas + 1))done resumen=""for g in "${grupos[@]}"; do  resumen+="${resumen:+, }$g ${por_grupo[$g]:-0}"doneecho "# Altas: $altas ($resumen)"

#!/bin/bash# Política abuelo-padre-hijo: 7 diarias, domingos de las últimas 4 semanas y el día 1 de los últimos 6 mesesexport LC_ALL=C read -r palabra hoyif [ "$palabra" != "HOY" ] || ! date -d "$hoy" +%F >/dev/null 2>&1 || [ "$(date -d "$hoy" +%F)" != "$hoy" ]; then  echo "La primera línea debe ser HOY AAAA-MM-DD"  exit 0fidia_hoy=$(( $(date -u -d "$hoy" +%s) / 86400 ))mes_hoy=$(( 10#$(date -d "$hoy" +%Y) * 12 + 10#$(date -d "$hoy" +%m) )) declare -A fichero_defechas=()while read -r nombre; do  [ -z "$nombre" ] && continue  if [[ ! $nombre =~ ^backup-([0-9]{4}-[0-9]{2}-[0-9]{2})\.tar\.gz$ ]] || [ "$(date -d "${BASH_REMATCH[1]}" +%F 2>/dev/null)" != "${BASH_REMATCH[1]}" ]; then    echo "Ignorado (nombre no válido): $nombre"    continue  fi  fecha=${BASH_REMATCH[1]}  if [[ $fecha > $hoy ]]; then    echo "Ignorado (fecha futura): $nombre"    continue  fi  fichero_de[$fecha]=$nombre  fechas+=("$fecha")done if [ ${#fechas[@]} -eq 0 ]; then  echo "No hay copias"  exit 0fi # Las fechas en formato AAAA-MM-DD se ordenan bien como texto: de la más reciente a la más antiguamapfile -t ordenadas < <(printf "%s\n" "${fechas[@]}" | sort -ru)conservar=0borrar=0liberado=()for i in "${!ordenadas[@]}"; do  f=${ordenadas[$i]}  motivos=""  [ "$i" -lt 7 ] && motivos="diaria"  dias=$(( dia_hoy - $(date -u -d "$f" +%s) / 86400 ))  if [ "$(date -d "$f" +%u)" -eq 7 ] && [ "$dias" -lt 28 ]; then    motivos+="${motivos:+, }semanal"  fi  meses=$(( mes_hoy - (10#$(date -d "$f" +%Y) * 12 + 10#$(date -d "$f" +%m)) ))  if [ "$(date -d "$f" +%d)" = "01" ] && [ "$meses" -lt 6 ]; then    motivos+="${motivos:+, }mensual"  fi  if [ -n "$motivos" ]; then    echo "CONSERVAR ${fichero_de[$f]} ($motivos)"    conservar=$((conservar + 1))  else    echo "BORRAR    ${fichero_de[$f]}"    borrar=$((borrar + 1))  fidoneecho "Se conservan $conservar y se borran $borrar"

#!/bin/bash# Lee la salida de «df -P» y avisa de los sistemas de ficheros que se llenanexport LC_ALL=C read -r palabra aviso criticoif [ "$palabra" != "UMBRALES" ] || ! [[ $aviso =~ ^[0-9]+$ && $critico =~ ^[0-9]+$ ]] || [ "$aviso" -ge "$critico" ] || [ "$critico" -gt 100 ]; then  echo "La primera línea debe ser UMBRALES aviso crítico (aviso < crítico <= 100)"  exit 0fi # KiB → «12,3 GiB» con un decimal, redondeadogib() {  local decimas=$(( ($1 * 10 + 524288) / 1048576 ))  echo "$((decimas / 10)),$((decimas % 10)) GiB"} filas=()libre_total=0read -r _   # cabecera de dfwhile read -r dispositivo bloques usado libre capacidad montaje; do  [ -z "$dispositivo" ] && continue  # Sistemas de ficheros virtuales: no ocupan disco  case $dispositivo in    tmpfs|devtmpfs|overlay|squashfs|udev|none) continue ;;  esac  [[ $dispositivo == /dev/loop* ]] && continue  porcentaje=${capacidad%\%}  libre_total=$((libre_total + libre))  if [ "$porcentaje" -ge "$critico" ]; then estado="URGENTE"  elif [ "$porcentaje" -ge "$aviso" ]; then estado="AVISO"  else estado="OK"; fi  linea=$(printf "%-8s %3d%%  %-12s usado %s de %s" "$estado" "$porcentaje" "$montaje" "$(gib "$usado")" "$(gib $((usado + libre)))")  if [ "$estado" != "OK" ]; then    # Lo que hay que liberar para bajar del umbral de aviso: usado - aviso% del total, redondeado hacia arriba    sobra=$(( usado * 100 - aviso * (usado + libre) ))    liberar=$(( (sobra + 100 * 1048576 - 1) / (100 * 1048576) ))    linea+=" · libera $liberar GiB para bajar del $aviso %"  fi  filas+=("$porcentaje|$montaje|$linea")done if [ ${#filas[@]} -eq 0 ]; then  echo "No hay sistemas de ficheros que vigilar"  exit 0fi# Del más lleno al más vacío; a igual porcentaje, por punto de montajeprintf "%s\n" "${filas[@]}" | sort -t'|' -k1,1nr -k2,2 | cut -d'|' -f3-echo "Libre en total: $(gib "$libre_total")"

#!/bin/bash# Revisa un fichero de sitios de Nginx (como /etc/nginx/sites-available/web) y avisa de los fallos típicosexport LC_ALL=C n=0 profundidad=0 numero=0declare -a inicio fin puertos nombres raiz retorno proxy cert clave autoindex while IFS= read -r linea || [ -n "$linea" ]; do  numero=$((numero + 1))  linea=${linea%%#*}                                   # quita los comentarios  linea="${linea#"${linea%%[![:space:]]*}"}"           # y los espacios de los extremos  linea="${linea%"${linea##*[![:space:]]}"}"  [ -z "$linea" ] && continue   if [[ $linea =~ ^server[[:space:]]*\{$ ]] && [ "$profundidad" -eq 0 ]; then    n=$((n + 1)); inicio[$n]=$numero; profundidad=1    continue  fi  if [[ $linea == *"{" ]]; then                        # un bloque location o similar    if [ "$profundidad" -eq 0 ]; then echo "Error: bloque fuera de un server en la línea $numero"; exit 0; fi    profundidad=$((profundidad + 1))    continue  fi  if [ "$linea" = "}" ]; then    if [ "$profundidad" -eq 0 ]; then echo "Error: llave de cierre sin abrir en la línea $numero"; exit 0; fi    profundidad=$((profundidad - 1))    [ "$profundidad" -eq 0 ] && fin[$n]=$numero    continue  fi  if [ "$profundidad" -eq 0 ]; then echo "Error: directiva fuera de un server en la línea $numero"; exit 0; fi   linea=${linea%;}  read -r directiva valor <<< "$linea"  case $directiva in    listen)      puerto=${valor%% *}; puerto=${puerto##*:}        # «[::]:443 ssl» → 443      [[ $valor == *" ssl"* ]] && puerto+=" ssl"      [[ " ${puertos[$n]} " == *" $puerto "* ]] || puertos[$n]="${puertos[$n]:+${puertos[$n]} }$puerto" ;;    server_name) nombres[$n]=$valor ;;    root) [ -z "${raiz[$n]}" ] && raiz[$n]=$valor ;;    return) retorno[$n]=${valor#* } ;;    proxy_pass) [ -z "${proxy[$n]}" ] && proxy[$n]=$valor ;;    ssl_certificate) cert[$n]=1 ;;    ssl_certificate_key) clave[$n]=1 ;;    autoindex) [ "$valor" = "on" ] && autoindex[$n]=1 ;;  esacdone if [ "$profundidad" -ne 0 ]; then echo "Error: llaves sin cerrar"; exit 0; fiif [ "$n" -eq 0 ]; then echo "No hay ningún bloque server"; exit 0; fi avisos=()declare -A servidores_de     # «nombre puerto» → número de servidoresdeclare -A redirige          # nombre → 1 si su servidor del 80 redirige a httpsdeclare -A en443for i in $(seq 1 "$n"); do  [ -z "${puertos[$i]}" ] && puertos[$i]="80"  if [ -n "${retorno[$i]}" ]; then hace="redirige a ${retorno[$i]}"  elif [ -n "${proxy[$i]}" ]; then hace="proxy a ${proxy[$i]}"  elif [ -n "${raiz[$i]}" ]; then hace="sirve ${raiz[$i]}"  else hace="no sirve nada"; fi  echo "Servidor $i (líneas ${inicio[$i]}-${fin[$i]}): puerto ${puertos[$i]// / y } · ${nombres[$i]:-(sin nombre)} · $hace" | sed 's/ y ssl/ ssl/g'   if [[ " ${puertos[$i]}" == *" ssl"* ]]; then    faltan=""    [ -z "${cert[$i]}" ] && faltan="ssl_certificate"    [ -z "${clave[$i]}" ] && faltan="${faltan:+$faltan y }ssl_certificate_key"    [ -n "$faltan" ] && avisos+=("Servidor $i: usa ssl pero le falta $faltan")  fi  [ -n "${autoindex[$i]}" ] && avisos+=("Servidor $i: autoindex activado (muestra la lista de ficheros)")  [ "$hace" = "no sirve nada" ] && avisos+=("Servidor $i: no tiene root, return ni proxy_pass")   for nombre in ${nombres[$i]}; do    for p in ${puertos[$i]// ssl/}; do      servidores_de["$nombre $p"]=$(( ${servidores_de["$nombre $p"]:-0} + 1 ))      if [ "$p" = "80" ] && [[ ${retorno[$i]} == https://* ]]; then redirige[$nombre]=1; fi      [ "$p" = "443" ] && en443[$nombre]=1    done  donedone # Avisos por nombre de dominio, en orden alfabéticomapfile -t claves < <(printf "%s\n" "${!servidores_de[@]}" | sort)for k in "${claves[@]}"; do  [ -z "$k" ] && continue  [ "${servidores_de[$k]}" -gt 1 ] && avisos+=("${k% *}: aparece en ${servidores_de[$k]} servidores del puerto ${k#* }")donemapfile -t seguros < <(printf "%s\n" "${!en443[@]}" | sort)for nombre in "${seguros[@]}"; do  [ -z "$nombre" ] && continue  [ -z "${redirige[$nombre]}" ] && avisos+=("$nombre: el puerto 80 no redirige a HTTPS")done if [ ${#avisos[@]} -eq 0 ]; then  echo "Sin avisos"else  echo "Avisos:"  for a in "${avisos[@]}"; do echo "  - $a"; donefi