Saltar al contenido principal

Banco de ejercicios de direccionamiento · R0-17

Banco de 60 ejercicios progresivos. Resuelve primero sin automatización y usa la comprobación solo después. Las soluciones fueron generadas y validadas con python3 e ipaddress; la herramienta no sustituye el razonamiento manual.

Distribución: 12 conversiones, 10 máscaras/CIDR, 14 red/broadcast/hosts, 12 FLSM, 8 detecciones de errores y 4 retos integradores. No contiene VLSM.

A · Conversiones (12)​

A01 · Decimal, binario y hexadecimal​

  • Objetivo: Convertir un octeto por valor posicional.
  • Dificultad: inicial
  • Enunciado: Convierte 13 a binario de ocho bits y a hexadecimal.
  • Datos: Valor decimal 13.
  • Resultado esperado: 00001101₂ y 0D₁₆.
  • Solución paso a paso: Activa los pesos 8 + 4 + 1 = 13; queda 00001101. Agrupa 0000 1101: cada grupo produce 0 y D.
  • Método empleado: Suma de potencias de dos y grupos de cuatro bits.
  • Comprobación independiente: int('00001101', 2) == 13 e int('0D', 16) == 13.
  • Error frecuente: Invertir los pesos o perder ceros iniciales.

A02 · Decimal, binario y hexadecimal​

  • Objetivo: Convertir un octeto por valor posicional.
  • Dificultad: inicial
  • Enunciado: Convierte 42 a binario de ocho bits y a hexadecimal.
  • Datos: Valor decimal 42.
  • Resultado esperado: 00101010₂ y 2A₁₆.
  • Solución paso a paso: Activa los pesos 32 + 8 + 2 = 42; queda 00101010. Agrupa 0010 1010: cada grupo produce 2 y A.
  • Método empleado: Suma de potencias de dos y grupos de cuatro bits.
  • Comprobación independiente: int('00101010', 2) == 42 e int('2A', 16) == 42.
  • Error frecuente: Invertir los pesos o perder ceros iniciales.

A03 · Decimal, binario y hexadecimal​

  • Objetivo: Convertir un octeto por valor posicional.
  • Dificultad: inicial
  • Enunciado: Convierte 85 a binario de ocho bits y a hexadecimal.
  • Datos: Valor decimal 85.
  • Resultado esperado: 01010101₂ y 55₁₆.
  • Solución paso a paso: Activa los pesos 64 + 16 + 4 + 1 = 85; queda 01010101. Agrupa 0101 0101: cada grupo produce 5 y 5.
  • Método empleado: Suma de potencias de dos y grupos de cuatro bits.
  • Comprobación independiente: int('01010101', 2) == 85 e int('55', 16) == 85.
  • Error frecuente: Invertir los pesos o perder ceros iniciales.

A04 · Decimal, binario y hexadecimal​

  • Objetivo: Convertir un octeto por valor posicional.
  • Dificultad: inicial
  • Enunciado: Convierte 128 a binario de ocho bits y a hexadecimal.
  • Datos: Valor decimal 128.
  • Resultado esperado: 10000000₂ y 80₁₆.
  • Solución paso a paso: Activa los pesos 128 = 128; queda 10000000. Agrupa 1000 0000: cada grupo produce 8 y 0.
  • Método empleado: Suma de potencias de dos y grupos de cuatro bits.
  • Comprobación independiente: int('10000000', 2) == 128 e int('80', 16) == 128.
  • Error frecuente: Invertir los pesos o perder ceros iniciales.

A05 · Decimal, binario y hexadecimal​

  • Objetivo: Convertir un octeto por valor posicional.
  • Dificultad: media
  • Enunciado: Convierte 172 a binario de ocho bits y a hexadecimal.
  • Datos: Valor decimal 172.
  • Resultado esperado: 10101100₂ y AC₁₆.
  • Solución paso a paso: Activa los pesos 128 + 32 + 8 + 4 = 172; queda 10101100. Agrupa 1010 1100: cada grupo produce A y C.
  • Método empleado: Suma de potencias de dos y grupos de cuatro bits.
  • Comprobación independiente: int('10101100', 2) == 172 e int('AC', 16) == 172.
  • Error frecuente: Invertir los pesos o perder ceros iniciales.

A06 · Decimal, binario y hexadecimal​

  • Objetivo: Convertir un octeto por valor posicional.
  • Dificultad: media
  • Enunciado: Convierte 192 a binario de ocho bits y a hexadecimal.
  • Datos: Valor decimal 192.
  • Resultado esperado: 11000000₂ y C0₁₆.
  • Solución paso a paso: Activa los pesos 128 + 64 = 192; queda 11000000. Agrupa 1100 0000: cada grupo produce C y 0.
  • Método empleado: Suma de potencias de dos y grupos de cuatro bits.
  • Comprobación independiente: int('11000000', 2) == 192 e int('C0', 16) == 192.
  • Error frecuente: Invertir los pesos o perder ceros iniciales.

A07 · Decimal, binario y hexadecimal​

  • Objetivo: Convertir un octeto por valor posicional.
  • Dificultad: media
  • Enunciado: Convierte 224 a binario de ocho bits y a hexadecimal.
  • Datos: Valor decimal 224.
  • Resultado esperado: 11100000₂ y E0₁₆.
  • Solución paso a paso: Activa los pesos 128 + 64 + 32 = 224; queda 11100000. Agrupa 1110 0000: cada grupo produce E y 0.
  • Método empleado: Suma de potencias de dos y grupos de cuatro bits.
  • Comprobación independiente: int('11100000', 2) == 224 e int('E0', 16) == 224.
  • Error frecuente: Invertir los pesos o perder ceros iniciales.

A08 · Decimal, binario y hexadecimal​

  • Objetivo: Convertir un octeto por valor posicional.
  • Dificultad: media
  • Enunciado: Convierte 240 a binario de ocho bits y a hexadecimal.
  • Datos: Valor decimal 240.
  • Resultado esperado: 11110000₂ y F0₁₆.
  • Solución paso a paso: Activa los pesos 128 + 64 + 32 + 16 = 240; queda 11110000. Agrupa 1111 0000: cada grupo produce F y 0.
  • Método empleado: Suma de potencias de dos y grupos de cuatro bits.
  • Comprobación independiente: int('11110000', 2) == 240 e int('F0', 16) == 240.
  • Error frecuente: Invertir los pesos o perder ceros iniciales.

A09 · Decimal, binario y hexadecimal​

  • Objetivo: Convertir un octeto por valor posicional.
  • Dificultad: media
  • Enunciado: Convierte 254 a binario de ocho bits y a hexadecimal.
  • Datos: Valor decimal 254.
  • Resultado esperado: 11111110₂ y FE₁₆.
  • Solución paso a paso: Activa los pesos 128 + 64 + 32 + 16 + 8 + 4 + 2 = 254; queda 11111110. Agrupa 1111 1110: cada grupo produce F y E.
  • Método empleado: Suma de potencias de dos y grupos de cuatro bits.
  • Comprobación independiente: int('11111110', 2) == 254 e int('FE', 16) == 254.
  • Error frecuente: Invertir los pesos o perder ceros iniciales.

A10 · Decimal, binario y hexadecimal​

  • Objetivo: Convertir un octeto por valor posicional.
  • Dificultad: media
  • Enunciado: Convierte 255 a binario de ocho bits y a hexadecimal.
  • Datos: Valor decimal 255.
  • Resultado esperado: 11111111₂ y FF₁₆.
  • Solución paso a paso: Activa los pesos 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255; queda 11111111. Agrupa 1111 1111: cada grupo produce F y F.
  • Método empleado: Suma de potencias de dos y grupos de cuatro bits.
  • Comprobación independiente: int('11111111', 2) == 255 e int('FF', 16) == 255.
  • Error frecuente: Invertir los pesos o perder ceros iniciales.

A11 · Binario a dos destinos​

  • Objetivo: Leer bits mediante pesos y comprobar con hexadecimal.
  • Dificultad: media
  • Enunciado: Convierte el binario a decimal y hexadecimal.
  • Datos: Octeto 10110110₂.
  • Resultado esperado: 182₁₀ y B6₁₆.
  • Solución paso a paso: Suma 128 + 32 + 16 + 4 + 2 = 182. Grupos 1011 0110 → B6.
  • Método empleado: Suma posicional y agrupación binaria.
  • Comprobación independiente: int('10110110', 2) == int('B6', 16) == 182.
  • Error frecuente: Leer la cadena binaria como si fuera decimal.

A12 · Binario a dos destinos​

  • Objetivo: Leer bits mediante pesos y comprobar con hexadecimal.
  • Dificultad: media
  • Enunciado: Convierte el binario a decimal y hexadecimal.
  • Datos: Octeto 11010110₂.
  • Resultado esperado: 214₁₀ y D6₁₆.
  • Solución paso a paso: Suma 128 + 64 + 16 + 4 + 2 = 214. Grupos 1101 0110 → D6.
  • Método empleado: Suma posicional y agrupación binaria.
  • Comprobación independiente: int('11010110', 2) == int('D6', 16) == 214.
  • Error frecuente: Leer la cadena binaria como si fuera decimal.

B · Máscaras y CIDR (10)​

B01 · Prefijo y máscara​

  • Objetivo: Relacionar CIDR, máscara contigua y bits de host.
  • Dificultad: inicial
  • Enunciado: Convierte /8 en máscara decimal y bits de host.
  • Datos: Prefijo /8.
  • Resultado esperado: /8 ↔ 255.0.0.0; 24 bits de host.
  • Solución paso a paso: Hay 8 unos contiguos y 24 ceros. Al agrupar los bits por octetos, la máscara es 255.0.0.0 y el prefijo /8.
  • Método empleado: Contar unos contiguos por octetos.
  • Comprobación independiente: str(IPv4Network('0.0.0.0/8').netmask) == '255.0.0.0'.
  • Error frecuente: Sumar valores decimales de la máscara en lugar de contar bits.

B02 · Prefijo y máscara​

  • Objetivo: Relacionar CIDR, máscara contigua y bits de host.
  • Dificultad: inicial
  • Enunciado: Convierte 255.240.0.0 en prefijo y calcula bits de host.
  • Datos: Máscara 255.240.0.0.
  • Resultado esperado: /12 ↔ 255.240.0.0; 20 bits de host.
  • Solución paso a paso: Hay 12 unos contiguos y 20 ceros. Al agrupar los bits por octetos, la máscara es 255.240.0.0 y el prefijo /12.
  • Método empleado: Contar unos contiguos por octetos.
  • Comprobación independiente: str(IPv4Network('0.0.0.0/12').netmask) == '255.240.0.0'.
  • Error frecuente: Sumar valores decimales de la máscara en lugar de contar bits.

B03 · Prefijo y máscara​

  • Objetivo: Relacionar CIDR, máscara contigua y bits de host.
  • Dificultad: inicial
  • Enunciado: Convierte /16 en máscara decimal y bits de host.
  • Datos: Prefijo /16.
  • Resultado esperado: /16 ↔ 255.255.0.0; 16 bits de host.
  • Solución paso a paso: Hay 16 unos contiguos y 16 ceros. Al agrupar los bits por octetos, la máscara es 255.255.0.0 y el prefijo /16.
  • Método empleado: Contar unos contiguos por octetos.
  • Comprobación independiente: str(IPv4Network('0.0.0.0/16').netmask) == '255.255.0.0'.
  • Error frecuente: Sumar valores decimales de la máscara en lugar de contar bits.

B04 · Prefijo y máscara​

  • Objetivo: Relacionar CIDR, máscara contigua y bits de host.
  • Dificultad: inicial
  • Enunciado: Convierte 255.255.192.0 en prefijo y calcula bits de host.
  • Datos: Máscara 255.255.192.0.
  • Resultado esperado: /18 ↔ 255.255.192.0; 14 bits de host.
  • Solución paso a paso: Hay 18 unos contiguos y 14 ceros. Al agrupar los bits por octetos, la máscara es 255.255.192.0 y el prefijo /18.
  • Método empleado: Contar unos contiguos por octetos.
  • Comprobación independiente: str(IPv4Network('0.0.0.0/18').netmask) == '255.255.192.0'.
  • Error frecuente: Sumar valores decimales de la máscara en lugar de contar bits.

B05 · Prefijo y máscara​

  • Objetivo: Relacionar CIDR, máscara contigua y bits de host.
  • Dificultad: media
  • Enunciado: Convierte /20 en máscara decimal y bits de host.
  • Datos: Prefijo /20.
  • Resultado esperado: /20 ↔ 255.255.240.0; 12 bits de host.
  • Solución paso a paso: Hay 20 unos contiguos y 12 ceros. Al agrupar los bits por octetos, la máscara es 255.255.240.0 y el prefijo /20.
  • Método empleado: Contar unos contiguos por octetos.
  • Comprobación independiente: str(IPv4Network('0.0.0.0/20').netmask) == '255.255.240.0'.
  • Error frecuente: Sumar valores decimales de la máscara en lugar de contar bits.

B06 · Prefijo y máscara​

  • Objetivo: Relacionar CIDR, máscara contigua y bits de host.
  • Dificultad: media
  • Enunciado: Convierte 255.255.252.0 en prefijo y calcula bits de host.
  • Datos: Máscara 255.255.252.0.
  • Resultado esperado: /22 ↔ 255.255.252.0; 10 bits de host.
  • Solución paso a paso: Hay 22 unos contiguos y 10 ceros. Al agrupar los bits por octetos, la máscara es 255.255.252.0 y el prefijo /22.
  • Método empleado: Contar unos contiguos por octetos.
  • Comprobación independiente: str(IPv4Network('0.0.0.0/22').netmask) == '255.255.252.0'.
  • Error frecuente: Sumar valores decimales de la máscara en lugar de contar bits.

B07 · Prefijo y máscara​

  • Objetivo: Relacionar CIDR, máscara contigua y bits de host.
  • Dificultad: media
  • Enunciado: Convierte /24 en máscara decimal y bits de host.
  • Datos: Prefijo /24.
  • Resultado esperado: /24 ↔ 255.255.255.0; 8 bits de host.
  • Solución paso a paso: Hay 24 unos contiguos y 8 ceros. Al agrupar los bits por octetos, la máscara es 255.255.255.0 y el prefijo /24.
  • Método empleado: Contar unos contiguos por octetos.
  • Comprobación independiente: str(IPv4Network('0.0.0.0/24').netmask) == '255.255.255.0'.
  • Error frecuente: Sumar valores decimales de la máscara en lugar de contar bits.

B08 · Prefijo y máscara​

  • Objetivo: Relacionar CIDR, máscara contigua y bits de host.
  • Dificultad: media
  • Enunciado: Convierte 255.255.255.192 en prefijo y calcula bits de host.
  • Datos: Máscara 255.255.255.192.
  • Resultado esperado: /26 ↔ 255.255.255.192; 6 bits de host.
  • Solución paso a paso: Hay 26 unos contiguos y 6 ceros. Al agrupar los bits por octetos, la máscara es 255.255.255.192 y el prefijo /26.
  • Método empleado: Contar unos contiguos por octetos.
  • Comprobación independiente: str(IPv4Network('0.0.0.0/26').netmask) == '255.255.255.192'.
  • Error frecuente: Sumar valores decimales de la máscara en lugar de contar bits.

B09 · Prefijo y máscara​

  • Objetivo: Relacionar CIDR, máscara contigua y bits de host.
  • Dificultad: media
  • Enunciado: Convierte /28 en máscara decimal y bits de host.
  • Datos: Prefijo /28.
  • Resultado esperado: /28 ↔ 255.255.255.240; 4 bits de host.
  • Solución paso a paso: Hay 28 unos contiguos y 4 ceros. Al agrupar los bits por octetos, la máscara es 255.255.255.240 y el prefijo /28.
  • Método empleado: Contar unos contiguos por octetos.
  • Comprobación independiente: str(IPv4Network('0.0.0.0/28').netmask) == '255.255.255.240'.
  • Error frecuente: Sumar valores decimales de la máscara en lugar de contar bits.

B10 · Prefijo y máscara​

  • Objetivo: Relacionar CIDR, máscara contigua y bits de host.
  • Dificultad: media
  • Enunciado: Convierte 255.255.255.252 en prefijo y calcula bits de host.
  • Datos: Máscara 255.255.255.252.
  • Resultado esperado: /30 ↔ 255.255.255.252; 2 bits de host.
  • Solución paso a paso: Hay 30 unos contiguos y 2 ceros. Al agrupar los bits por octetos, la máscara es 255.255.255.252 y el prefijo /30.
  • Método empleado: Contar unos contiguos por octetos.
  • Comprobación independiente: str(IPv4Network('0.0.0.0/30').netmask) == '255.255.255.252'.
  • Error frecuente: Sumar valores decimales de la máscara en lugar de contar bits.

C · Red, broadcast y hosts (14)​

C01 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: media
  • Enunciado: Calcula e interpreta 192.168.1.70/26.
  • Datos: IPv4/prefijo 192.168.1.70/26.
  • Resultado esperado: red 192.168.1.64, broadcast 192.168.1.127, rango 192.168.1.65–192.168.1.126, 62 hosts convencionales.
  • Solución paso a paso: /26 deja 6 bits de host: 64 direcciones. AND sitúa 192.168.1.70 en 192.168.1.64; poner host a uno da 192.168.1.127. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('192.168.1.70/26', strict=False)) == '192.168.1.64/26' y contiene 64 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C02 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: media
  • Enunciado: Calcula e interpreta 198.51.100.140/25.
  • Datos: IPv4/prefijo 198.51.100.140/25.
  • Resultado esperado: red 198.51.100.128, broadcast 198.51.100.255, rango 198.51.100.129–198.51.100.254, 126 hosts convencionales.
  • Solución paso a paso: /25 deja 7 bits de host: 128 direcciones. AND sitúa 198.51.100.140 en 198.51.100.128; poner host a uno da 198.51.100.255. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('198.51.100.140/25', strict=False)) == '198.51.100.128/25' y contiene 128 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C03 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: media
  • Enunciado: Calcula e interpreta 203.0.113.94/28.
  • Datos: IPv4/prefijo 203.0.113.94/28.
  • Resultado esperado: red 203.0.113.80, broadcast 203.0.113.95, rango 203.0.113.81–203.0.113.94, 14 hosts convencionales.
  • Solución paso a paso: /28 deja 4 bits de host: 16 direcciones. AND sitúa 203.0.113.94 en 203.0.113.80; poner host a uno da 203.0.113.95. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('203.0.113.94/28', strict=False)) == '203.0.113.80/28' y contiene 16 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C04 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: media
  • Enunciado: Calcula e interpreta 192.0.2.9/30.
  • Datos: IPv4/prefijo 192.0.2.9/30.
  • Resultado esperado: red 192.0.2.8, broadcast 192.0.2.11, rango 192.0.2.9–192.0.2.10, 2 hosts convencionales.
  • Solución paso a paso: /30 deja 2 bits de host: 4 direcciones. AND sitúa 192.0.2.9 en 192.0.2.8; poner host a uno da 192.0.2.11. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('192.0.2.9/30', strict=False)) == '192.0.2.8/30' y contiene 4 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C05 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: media
  • Enunciado: Calcula e interpreta 10.0.5.10/22.
  • Datos: IPv4/prefijo 10.0.5.10/22.
  • Resultado esperado: red 10.0.4.0, broadcast 10.0.7.255, rango 10.0.4.1–10.0.7.254, 1022 hosts convencionales.
  • Solución paso a paso: /22 deja 10 bits de host: 1024 direcciones. AND sitúa 10.0.5.10 en 10.0.4.0; poner host a uno da 10.0.7.255. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('10.0.5.10/22', strict=False)) == '10.0.4.0/22' y contiene 1024 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C06 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: media
  • Enunciado: Calcula e interpreta 172.20.31.200/20.
  • Datos: IPv4/prefijo 172.20.31.200/20.
  • Resultado esperado: red 172.20.16.0, broadcast 172.20.31.255, rango 172.20.16.1–172.20.31.254, 4094 hosts convencionales.
  • Solución paso a paso: /20 deja 12 bits de host: 4096 direcciones. AND sitúa 172.20.31.200 en 172.20.16.0; poner host a uno da 172.20.31.255. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('172.20.31.200/20', strict=False)) == '172.20.16.0/20' y contiene 4096 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C07 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: media
  • Enunciado: Calcula e interpreta 10.20.200.1/18.
  • Datos: IPv4/prefijo 10.20.200.1/18.
  • Resultado esperado: red 10.20.192.0, broadcast 10.20.255.255, rango 10.20.192.1–10.20.255.254, 16382 hosts convencionales.
  • Solución paso a paso: /18 deja 14 bits de host: 16384 direcciones. AND sitúa 10.20.200.1 en 10.20.192.0; poner host a uno da 10.20.255.255. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('10.20.200.1/18', strict=False)) == '10.20.192.0/18' y contiene 16384 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C08 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: media
  • Enunciado: Calcula e interpreta 192.168.4.31/27.
  • Datos: IPv4/prefijo 192.168.4.31/27.
  • Resultado esperado: red 192.168.4.0, broadcast 192.168.4.31, rango 192.168.4.1–192.168.4.30, 30 hosts convencionales.
  • Solución paso a paso: /27 deja 5 bits de host: 32 direcciones. AND sitúa 192.168.4.31 en 192.168.4.0; poner host a uno da 192.168.4.31. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('192.168.4.31/27', strict=False)) == '192.168.4.0/27' y contiene 32 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C09 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: avanzada
  • Enunciado: Calcula e interpreta 192.168.4.32/27.
  • Datos: IPv4/prefijo 192.168.4.32/27.
  • Resultado esperado: red 192.168.4.32, broadcast 192.168.4.63, rango 192.168.4.33–192.168.4.62, 30 hosts convencionales.
  • Solución paso a paso: /27 deja 5 bits de host: 32 direcciones. AND sitúa 192.168.4.32 en 192.168.4.32; poner host a uno da 192.168.4.63. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('192.168.4.32/27', strict=False)) == '192.168.4.32/27' y contiene 32 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C10 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: avanzada
  • Enunciado: Calcula e interpreta 198.51.100.255/23.
  • Datos: IPv4/prefijo 198.51.100.255/23.
  • Resultado esperado: red 198.51.100.0, broadcast 198.51.101.255, rango 198.51.100.1–198.51.101.254, 510 hosts convencionales.
  • Solución paso a paso: /23 deja 9 bits de host: 512 direcciones. AND sitúa 198.51.100.255 en 198.51.100.0; poner host a uno da 198.51.101.255. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('198.51.100.255/23', strict=False)) == '198.51.100.0/23' y contiene 512 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C11 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: avanzada
  • Enunciado: Calcula e interpreta 203.0.113.0/26.
  • Datos: IPv4/prefijo 203.0.113.0/26.
  • Resultado esperado: red 203.0.113.0, broadcast 203.0.113.63, rango 203.0.113.1–203.0.113.62, 62 hosts convencionales.
  • Solución paso a paso: /26 deja 6 bits de host: 64 direcciones. AND sitúa 203.0.113.0 en 203.0.113.0; poner host a uno da 203.0.113.63. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('203.0.113.0/26', strict=False)) == '203.0.113.0/26' y contiene 64 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C12 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: avanzada
  • Enunciado: Calcula e interpreta 10.1.255.4/16.
  • Datos: IPv4/prefijo 10.1.255.4/16.
  • Resultado esperado: red 10.1.0.0, broadcast 10.1.255.255, rango 10.1.0.1–10.1.255.254, 65534 hosts convencionales.
  • Solución paso a paso: /16 deja 16 bits de host: 65536 direcciones. AND sitúa 10.1.255.4 en 10.1.0.0; poner host a uno da 10.1.255.255. Se reservan ambos extremos en el caso convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('10.1.255.4/16', strict=False)) == '10.1.0.0/16' y contiene 65536 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C13 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: avanzada
  • Enunciado: Calcula e interpreta 192.0.2.8/31.
  • Datos: IPv4/prefijo 192.0.2.8/31.
  • Resultado esperado: bloque 192.0.2.8/31, extremos 192.0.2.8 y 192.0.2.9 para punto a punto.
  • Solución paso a paso: Queda un bit y dos direcciones. RFC 3021 permite usar ambas en determinados enlaces punto a punto; no se aplica la resta convencional.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('192.0.2.8/31', strict=False)) == '192.0.2.8/31' y contiene 2 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

C14 · Calcula el bloque​

  • Objetivo: Obtener límites e interpretar el prefijo.
  • Dificultad: avanzada
  • Enunciado: Calcula e interpreta 192.0.2.25/32.
  • Datos: IPv4/prefijo 192.0.2.25/32.
  • Resultado esperado: una sola dirección 192.0.2.25.
  • Solución paso a paso: No quedan bits de host; /32 representa una ruta o dirección individual.
  • Método empleado: AND/tamaño de bloque y tratamiento explícito de límites.
  • Comprobación independiente: str(ip_network('192.0.2.25/32', strict=False)) == '192.0.2.25/32' y contiene 1 direcciones.
  • Error frecuente: Decidir por .0/.255 o aplicar 2^h-2 a /31 y /32.

D · FLSM (12)​

D01 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: media
  • Enunciado: Divide 192.168.10.0/24 para cumplir 4 subredes usando subredes iguales.
  • Datos: Bloque base 192.168.10.0/24, nuevo prefijo /26.
  • Resultado esperado: 4 subredes /26, tamaño 64, capacidad convencional 62.
  • Solución paso a paso: Se prestan 2 bits: /24 → /26 y 2^2=4 bloques. Cada bloque tiene 64 direcciones y 62 hosts convencionales. Primero 192.168.10.0/26 (broadcast 192.168.10.63); último 192.168.10.192/26 (broadcast 192.168.10.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('192.168.10.0/24').subnets(new_prefix=26)) devuelve 4 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D02 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: media
  • Enunciado: Divide 192.168.10.0/24 para cumplir 8 subredes usando subredes iguales.
  • Datos: Bloque base 192.168.10.0/24, nuevo prefijo /27.
  • Resultado esperado: 8 subredes /27, tamaño 32, capacidad convencional 30.
  • Solución paso a paso: Se prestan 3 bits: /24 → /27 y 2^3=8 bloques. Cada bloque tiene 32 direcciones y 30 hosts convencionales. Primero 192.168.10.0/27 (broadcast 192.168.10.31); último 192.168.10.224/27 (broadcast 192.168.10.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('192.168.10.0/24').subnets(new_prefix=27)) devuelve 8 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D03 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: media
  • Enunciado: Divide 192.0.2.0/24 para cumplir 2 subredes usando subredes iguales.
  • Datos: Bloque base 192.0.2.0/24, nuevo prefijo /25.
  • Resultado esperado: 2 subredes /25, tamaño 128, capacidad convencional 126.
  • Solución paso a paso: Se prestan 1 bits: /24 → /25 y 2^1=2 bloques. Cada bloque tiene 128 direcciones y 126 hosts convencionales. Primero 192.0.2.0/25 (broadcast 192.0.2.127); último 192.0.2.128/25 (broadcast 192.0.2.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('192.0.2.0/24').subnets(new_prefix=25)) devuelve 2 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D04 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: media
  • Enunciado: Divide 198.51.100.0/24 para cumplir al menos 6 subredes usando subredes iguales.
  • Datos: Bloque base 198.51.100.0/24, nuevo prefijo /27.
  • Resultado esperado: 8 subredes /27, tamaño 32, capacidad convencional 30.
  • Solución paso a paso: Se prestan 3 bits: /24 → /27 y 2^3=8 bloques. Cada bloque tiene 32 direcciones y 30 hosts convencionales. Primero 198.51.100.0/27 (broadcast 198.51.100.31); último 198.51.100.224/27 (broadcast 198.51.100.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('198.51.100.0/24').subnets(new_prefix=27)) devuelve 8 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D05 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: media
  • Enunciado: Divide 203.0.113.0/24 para cumplir 16 subredes usando subredes iguales.
  • Datos: Bloque base 203.0.113.0/24, nuevo prefijo /28.
  • Resultado esperado: 16 subredes /28, tamaño 16, capacidad convencional 14.
  • Solución paso a paso: Se prestan 4 bits: /24 → /28 y 2^4=16 bloques. Cada bloque tiene 16 direcciones y 14 hosts convencionales. Primero 203.0.113.0/28 (broadcast 203.0.113.15); último 203.0.113.240/28 (broadcast 203.0.113.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('203.0.113.0/24').subnets(new_prefix=28)) devuelve 16 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D06 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: avanzada
  • Enunciado: Divide 10.20.0.0/16 para cumplir 8 subredes usando subredes iguales.
  • Datos: Bloque base 10.20.0.0/16, nuevo prefijo /19.
  • Resultado esperado: 8 subredes /19, tamaño 8192, capacidad convencional 8190.
  • Solución paso a paso: Se prestan 3 bits: /16 → /19 y 2^3=8 bloques. Cada bloque tiene 8192 direcciones y 8190 hosts convencionales. Primero 10.20.0.0/19 (broadcast 10.20.31.255); último 10.20.224.0/19 (broadcast 10.20.255.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('10.20.0.0/16').subnets(new_prefix=19)) devuelve 8 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D07 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: avanzada
  • Enunciado: Divide 172.20.0.0/16 para cumplir 16 subredes usando subredes iguales.
  • Datos: Bloque base 172.20.0.0/16, nuevo prefijo /20.
  • Resultado esperado: 16 subredes /20, tamaño 4096, capacidad convencional 4094.
  • Solución paso a paso: Se prestan 4 bits: /16 → /20 y 2^4=16 bloques. Cada bloque tiene 4096 direcciones y 4094 hosts convencionales. Primero 172.20.0.0/20 (broadcast 172.20.15.255); último 172.20.240.0/20 (broadcast 172.20.255.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('172.20.0.0/16').subnets(new_prefix=20)) devuelve 16 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D08 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: avanzada
  • Enunciado: Divide 10.0.0.0/20 para cumplir 4 subredes usando subredes iguales.
  • Datos: Bloque base 10.0.0.0/20, nuevo prefijo /22.
  • Resultado esperado: 4 subredes /22, tamaño 1024, capacidad convencional 1022.
  • Solución paso a paso: Se prestan 2 bits: /20 → /22 y 2^2=4 bloques. Cada bloque tiene 1024 direcciones y 1022 hosts convencionales. Primero 10.0.0.0/22 (broadcast 10.0.3.255); último 10.0.12.0/22 (broadcast 10.0.15.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('10.0.0.0/20').subnets(new_prefix=22)) devuelve 4 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D09 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: avanzada
  • Enunciado: Divide 192.168.50.0/24 para cumplir al menos 50 hosts por subred usando subredes iguales.
  • Datos: Bloque base 192.168.50.0/24, nuevo prefijo /26.
  • Resultado esperado: 4 subredes /26, tamaño 64, capacidad convencional 62.
  • Solución paso a paso: Se prestan 2 bits: /24 → /26 y 2^2=4 bloques. Cada bloque tiene 64 direcciones y 62 hosts convencionales. Primero 192.168.50.0/26 (broadcast 192.168.50.63); último 192.168.50.192/26 (broadcast 192.168.50.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('192.168.50.0/24').subnets(new_prefix=26)) devuelve 4 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D10 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: avanzada
  • Enunciado: Divide 198.51.100.0/24 para cumplir al menos 12 hosts por subred usando subredes iguales.
  • Datos: Bloque base 198.51.100.0/24, nuevo prefijo /28.
  • Resultado esperado: 16 subredes /28, tamaño 16, capacidad convencional 14.
  • Solución paso a paso: Se prestan 4 bits: /24 → /28 y 2^4=16 bloques. Cada bloque tiene 16 direcciones y 14 hosts convencionales. Primero 198.51.100.0/28 (broadcast 198.51.100.15); último 198.51.100.240/28 (broadcast 198.51.100.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('198.51.100.0/24').subnets(new_prefix=28)) devuelve 16 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D11 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: avanzada
  • Enunciado: Divide 10.10.0.0/23 para cumplir 4 subredes usando subredes iguales.
  • Datos: Bloque base 10.10.0.0/23, nuevo prefijo /25.
  • Resultado esperado: 4 subredes /25, tamaño 128, capacidad convencional 126.
  • Solución paso a paso: Se prestan 2 bits: /23 → /25 y 2^2=4 bloques. Cada bloque tiene 128 direcciones y 126 hosts convencionales. Primero 10.10.0.0/25 (broadcast 10.10.0.127); último 10.10.1.128/25 (broadcast 10.10.1.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('10.10.0.0/23').subnets(new_prefix=25)) devuelve 4 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

D12 · División en bloques iguales​

  • Objetivo: Elegir y enumerar un prefijo FLSM sin solapamiento.
  • Dificultad: avanzada
  • Enunciado: Divide 172.31.0.0/22 para cumplir 4 subredes usando subredes iguales.
  • Datos: Bloque base 172.31.0.0/22, nuevo prefijo /24.
  • Resultado esperado: 4 subredes /24, tamaño 256, capacidad convencional 254.
  • Solución paso a paso: Se prestan 2 bits: /22 → /24 y 2^2=4 bloques. Cada bloque tiene 256 direcciones y 254 hosts convencionales. Primero 172.31.0.0/24 (broadcast 172.31.0.255); último 172.31.3.0/24 (broadcast 172.31.3.255).
  • Método empleado: Bits prestados y tamaño de bloque.
  • Comprobación independiente: list(ip_network('172.31.0.0/22').subnets(new_prefix=24)) devuelve 4 bloques; todos pertenecen al bloque base y cada par consecutivo no se solapa.
  • Error frecuente: Mezclar tamaños, desalinear redes o comprobar subredes sin comprobar capacidad.

E · Detección de errores (8)​

E01 · Localiza y corrige​

  • Objetivo: Detectar un error de alineación.
  • Dificultad: media
  • Enunciado: Evalúa: «192.168.1.48/27 es una red».
  • Datos: Afirmación y convenciones CIDR actuales.
  • Resultado esperado: Veredicto justificado y corrección.
  • Solución paso a paso: /27 avanza 32: 48 pertenece a 192.168.1.32/27; está desalineada.
  • Método empleado: Contraejemplo, cálculo de bloque o regla de representación.
  • Comprobación independiente: Revisión con ipaddress cuando aplica y contraste con el prefijo explícito.
  • Error frecuente: Corregir solo el resultado sin explicar por qué falla la regla usada.

E02 · Localiza y corrige​

  • Objetivo: Detectar un error de rango privado.
  • Dificultad: media
  • Enunciado: Evalúa: «172.40.1.2 es privada porque empieza por 172».
  • Datos: Afirmación y convenciones CIDR actuales.
  • Resultado esperado: Veredicto justificado y corrección.
  • Solución paso a paso: RFC 1918 reserva 172.16.0.0/12, que termina en 172.31.255.255; 172.40 queda fuera.
  • Método empleado: Contraejemplo, cálculo de bloque o regla de representación.
  • Comprobación independiente: Revisión con ipaddress cuando aplica y contraste con el prefijo explícito.
  • Error frecuente: Corregir solo el resultado sin explicar por qué falla la regla usada.

E03 · Localiza y corrige​

  • Objetivo: Detectar un error de prefijo.
  • Dificultad: media
  • Enunciado: Evalúa: «Toda IP acabada en .0 es red».
  • Datos: Afirmación y convenciones CIDR actuales.
  • Resultado esperado: Veredicto justificado y corrección.
  • Solución paso a paso: Depende del prefijo: 192.0.3.0/23 es una dirección utilizable dentro de 192.0.2.0/23; el patrón decimal no decide solo.
  • Método empleado: Contraejemplo, cálculo de bloque o regla de representación.
  • Comprobación independiente: Revisión con ipaddress cuando aplica y contraste con el prefijo explícito.
  • Error frecuente: Corregir solo el resultado sin explicar por qué falla la regla usada.

E04 · Localiza y corrige​

  • Objetivo: Detectar un error de broadcast.
  • Dificultad: media
  • Enunciado: Evalúa: «Toda IP acabada en .255 es broadcast».
  • Datos: Afirmación y convenciones CIDR actuales.
  • Resultado esperado: Veredicto justificado y corrección.
  • Solución paso a paso: Depende del prefijo: 198.51.100.255/23 pertenece al bloque 198.51.100.0/23, cuyo broadcast es 198.51.101.255.
  • Método empleado: Contraejemplo, cálculo de bloque o regla de representación.
  • Comprobación independiente: Revisión con ipaddress cuando aplica y contraste con el prefijo explícito.
  • Error frecuente: Corregir solo el resultado sin explicar por qué falla la regla usada.

E05 · Localiza y corrige​

  • Objetivo: Detectar un error de prefijo especial.
  • Dificultad: avanzada
  • Enunciado: Evalúa: «Un /31 tiene cero hosts porque 2^1-2=0».
  • Datos: Afirmación y convenciones CIDR actuales.
  • Resultado esperado: Veredicto justificado y corrección.
  • Solución paso a paso: RFC 3021 permite sus dos direcciones en enlaces punto a punto; el contexto no es una LAN convencional.
  • Método empleado: Contraejemplo, cálculo de bloque o regla de representación.
  • Comprobación independiente: Revisión con ipaddress cuando aplica y contraste con el prefijo explícito.
  • Error frecuente: Corregir solo el resultado sin explicar por qué falla la regla usada.

E06 · Localiza y corrige​

  • Objetivo: Detectar un error de capacidad.
  • Dificultad: avanzada
  • Enunciado: Evalúa: «Cuatro subredes de 70 hosts caben en un /24 con /26».
  • Datos: Afirmación y convenciones CIDR actuales.
  • Resultado esperado: Veredicto justificado y corrección.
  • Solución paso a paso: /26 crea cuatro bloques, pero solo 62 hosts convencionales por bloque; el requisito es imposible con ese bloque base.
  • Método empleado: Contraejemplo, cálculo de bloque o regla de representación.
  • Comprobación independiente: Revisión con ipaddress cuando aplica y contraste con el prefijo explícito.
  • Error frecuente: Corregir solo el resultado sin explicar por qué falla la regla usada.

E07 · Localiza y corrige​

  • Objetivo: Detectar un error de solapamiento.
  • Dificultad: avanzada
  • Enunciado: Evalúa: «192.168.1.0/25 y 192.168.1.64/26 no solapan».
  • Datos: Afirmación y convenciones CIDR actuales.
  • Resultado esperado: Veredicto justificado y corrección.
  • Solución paso a paso: El /25 cubre .0–.127 y contiene por completo el /26 .64–.127; sí solapan.
  • Método empleado: Contraejemplo, cálculo de bloque o regla de representación.
  • Comprobación independiente: Revisión con ipaddress cuando aplica y contraste con el prefijo explícito.
  • Error frecuente: Corregir solo el resultado sin explicar por qué falla la regla usada.

E08 · Localiza y corrige​

  • Objetivo: Detectar un error de IPv6.
  • Dificultad: avanzada
  • Enunciado: Evalúa: «2001::db8::1 es una abreviación IPv6 válida».
  • Datos: Afirmación y convenciones CIDR actuales.
  • Resultado esperado: Veredicto justificado y corrección.
  • Solución paso a paso: :: solo puede aparecer una vez; la expansión sería ambigua.
  • Método empleado: Contraejemplo, cálculo de bloque o regla de representación.
  • Comprobación independiente: Revisión con ipaddress cuando aplica y contraste con el prefijo explícito.
  • Error frecuente: Corregir solo el resultado sin explicar por qué falla la regla usada.

F · Retos integradores (4)​

F01 · Plan de aula​

  • Objetivo: Integrar restricciones, cálculo y explicación.
  • Dificultad: avanzada
  • Enunciado: Un 192.168.40.0/24 debe crear al menos 6 laboratorios de 25 hosts.
  • Datos: Todos los prefijos están explícitos; no uses clases.
  • Resultado esperado: /27: 8 subredes, 32 direcciones y 30 hosts convencionales. Redes .0, .32, .64, .96, .128, .160, .192 y .224.
  • Solución paso a paso: 3 bits satisfacen subredes (2³=8) y dejan 5 bits (2⁵-2=30).
  • Método empleado: Cálculo manual por bits/bloques y análisis del contexto.
  • Comprobación independiente: Casos equivalentes ejecutados con ipaddress; repetir los límites de cada bloque.
  • Error frecuente: Resolver solo una restricción o ignorar la asimetría.

F02 · Audita una configuración​

  • Objetivo: Integrar restricciones, cálculo y explicación.
  • Dificultad: avanzada
  • Enunciado: A=10.0.5.10/22, B=10.0.7.254/22, gateway=10.0.8.1. Decide ámbitos.
  • Datos: Todos los prefijos están explícitos; no uses clases.
  • Resultado esperado: A y B están en 10.0.4.0/22 (.4.0–.7.255); el gateway está en 10.0.8.0/22 y no es local.
  • Solución paso a paso: Máscara 255.255.252.0, salto 4 en tercer octeto.
  • Método empleado: Cálculo manual por bits/bloques y análisis del contexto.
  • Comprobación independiente: Casos equivalentes ejecutados con ipaddress; repetir los límites de cada bloque.
  • Error frecuente: Resolver solo una restricción o ignorar la asimetría.

F03 · Comparación IPv4/IPv6​

  • Objetivo: Integrar restricciones, cálculo y explicación.
  • Dificultad: avanzada
  • Enunciado: Expande 2001:db8:2::25, clasifica fe80::1 y explica por qué no se calcula broadcast IPv6.
  • Datos: Todos los prefijos están explícitos; no uses clases.
  • Resultado esperado: 2001:0db8:0002:0000:0000:0000:0000:0025; fe80::1 es link-local; IPv6 no usa broadcast.
  • Solución paso a paso: Completar ocho hextetos y aplicar prefijos IPv6, sin trasladar reglas IPv4.
  • Método empleado: Cálculo manual por bits/bloques y análisis del contexto.
  • Comprobación independiente: Casos equivalentes ejecutados con ipaddress; repetir los límites de cada bloque.
  • Error frecuente: Resolver solo una restricción o ignorar la asimetría.

F04 · Diagnóstico de prefijos​

  • Objetivo: Integrar restricciones, cálculo y explicación.
  • Dificultad: avanzada
  • Enunciado: A=192.0.2.10/24, B=192.0.2.130/25. Predice la decisión local/remota de cada uno.
  • Datos: Todos los prefijos están explícitos; no uses clases.
  • Resultado esperado: A considera B local en .0/24; B considera A remoto desde .128/25. La configuración es asimétrica.
  • Solución paso a paso: Calcular por separado la red de cada interfaz y comparar el destino.
  • Método empleado: Cálculo manual por bits/bloques y análisis del contexto.
  • Comprobación independiente: Casos equivalentes ejecutados con ipaddress; repetir los límites de cada bloque.
  • Error frecuente: Resolver solo una restricción o ignorar la asimetría.