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
13a binario de ocho bits y a hexadecimal. - Datos: Valor decimal
13. - Resultado esperado:
00001101₂y0D₁₆. - Solución paso a paso: Activa los pesos 8 + 4 + 1 = 13; queda
00001101. Agrupa0000 1101: cada grupo produce0yD. - Método empleado: Suma de potencias de dos y grupos de cuatro bits.
- Comprobación independiente:
int('00001101', 2) == 13eint('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
42a binario de ocho bits y a hexadecimal. - Datos: Valor decimal
42. - Resultado esperado:
00101010₂y2A₁₆. - Solución paso a paso: Activa los pesos 32 + 8 + 2 = 42; queda
00101010. Agrupa0010 1010: cada grupo produce2yA. - Método empleado: Suma de potencias de dos y grupos de cuatro bits.
- Comprobación independiente:
int('00101010', 2) == 42eint('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
85a binario de ocho bits y a hexadecimal. - Datos: Valor decimal
85. - Resultado esperado:
01010101₂y55₁₆. - Solución paso a paso: Activa los pesos 64 + 16 + 4 + 1 = 85; queda
01010101. Agrupa0101 0101: cada grupo produce5y5. - Método empleado: Suma de potencias de dos y grupos de cuatro bits.
- Comprobación independiente:
int('01010101', 2) == 85eint('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
128a binario de ocho bits y a hexadecimal. - Datos: Valor decimal
128. - Resultado esperado:
10000000₂y80₁₆. - Solución paso a paso: Activa los pesos 128 = 128; queda
10000000. Agrupa1000 0000: cada grupo produce8y0. - Método empleado: Suma de potencias de dos y grupos de cuatro bits.
- Comprobación independiente:
int('10000000', 2) == 128eint('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
172a binario de ocho bits y a hexadecimal. - Datos: Valor decimal
172. - Resultado esperado:
10101100₂yAC₁₆. - Solución paso a paso: Activa los pesos 128 + 32 + 8 + 4 = 172; queda
10101100. Agrupa1010 1100: cada grupo produceAyC. - Método empleado: Suma de potencias de dos y grupos de cuatro bits.
- Comprobación independiente:
int('10101100', 2) == 172eint('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
192a binario de ocho bits y a hexadecimal. - Datos: Valor decimal
192. - Resultado esperado:
11000000₂yC0₁₆. - Solución paso a paso: Activa los pesos 128 + 64 = 192; queda
11000000. Agrupa1100 0000: cada grupo produceCy0. - Método empleado: Suma de potencias de dos y grupos de cuatro bits.
- Comprobación independiente:
int('11000000', 2) == 192eint('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
224a binario de ocho bits y a hexadecimal. - Datos: Valor decimal
224. - Resultado esperado:
11100000₂yE0₁₆. - Solución paso a paso: Activa los pesos 128 + 64 + 32 = 224; queda
11100000. Agrupa1110 0000: cada grupo produceEy0. - Método empleado: Suma de potencias de dos y grupos de cuatro bits.
- Comprobación independiente:
int('11100000', 2) == 224eint('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
240a binario de ocho bits y a hexadecimal. - Datos: Valor decimal
240. - Resultado esperado:
11110000₂yF0₁₆. - Solución paso a paso: Activa los pesos 128 + 64 + 32 + 16 = 240; queda
11110000. Agrupa1111 0000: cada grupo produceFy0. - Método empleado: Suma de potencias de dos y grupos de cuatro bits.
- Comprobación independiente:
int('11110000', 2) == 240eint('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
254a binario de ocho bits y a hexadecimal. - Datos: Valor decimal
254. - Resultado esperado:
11111110₂yFE₁₆. - Solución paso a paso: Activa los pesos 128 + 64 + 32 + 16 + 8 + 4 + 2 = 254; queda
11111110. Agrupa1111 1110: cada grupo produceFyE. - Método empleado: Suma de potencias de dos y grupos de cuatro bits.
- Comprobación independiente:
int('11111110', 2) == 254eint('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
255a binario de ocho bits y a hexadecimal. - Datos: Valor decimal
255. - Resultado esperado:
11111111₂yFF₁₆. - Solución paso a paso: Activa los pesos 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255; queda
11111111. Agrupa1111 1111: cada grupo produceFyF. - Método empleado: Suma de potencias de dos y grupos de cuatro bits.
- Comprobación independiente:
int('11111111', 2) == 255eint('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₁₀yB6₁₆. - 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₁₀yD6₁₆. - 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
/8en 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.0y 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.0en 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.0y 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
/16en 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.0y 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.0en 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.0y 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
/20en 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.0y 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.0en 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.0y 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
/24en 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.0y 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.192en 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.192y 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
/28en 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.240y 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.252en 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.252y 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, broadcast192.168.1.127, rango192.168.1.65–192.168.1.126, 62 hosts convencionales. - Solución paso a paso:
/26deja 6 bits de host: 64 direcciones. AND sitúa 192.168.1.70 en192.168.1.64; poner host a uno da192.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/.255o aplicar2^h-2a/31y/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, broadcast198.51.100.255, rango198.51.100.129–198.51.100.254, 126 hosts convencionales. - Solución paso a paso:
/25deja 7 bits de host: 128 direcciones. AND sitúa 198.51.100.140 en198.51.100.128; poner host a uno da198.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/.255o aplicar2^h-2a/31y/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, broadcast203.0.113.95, rango203.0.113.81–203.0.113.94, 14 hosts convencionales. - Solución paso a paso:
/28deja 4 bits de host: 16 direcciones. AND sitúa 203.0.113.94 en203.0.113.80; poner host a uno da203.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/.255o aplicar2^h-2a/31y/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, broadcast192.0.2.11, rango192.0.2.9–192.0.2.10, 2 hosts convencionales. - Solución paso a paso:
/30deja 2 bits de host: 4 direcciones. AND sitúa 192.0.2.9 en192.0.2.8; poner host a uno da192.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/.255o aplicar2^h-2a/31y/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, broadcast10.0.7.255, rango10.0.4.1–10.0.7.254, 1022 hosts convencionales. - Solución paso a paso:
/22deja 10 bits de host: 1024 direcciones. AND sitúa 10.0.5.10 en10.0.4.0; poner host a uno da10.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/.255o aplicar2^h-2a/31y/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, broadcast172.20.31.255, rango172.20.16.1–172.20.31.254, 4094 hosts convencionales. - Solución paso a paso:
/20deja 12 bits de host: 4096 direcciones. AND sitúa 172.20.31.200 en172.20.16.0; poner host a uno da172.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/.255o aplicar2^h-2a/31y/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, broadcast10.20.255.255, rango10.20.192.1–10.20.255.254, 16382 hosts convencionales. - Solución paso a paso:
/18deja 14 bits de host: 16384 direcciones. AND sitúa 10.20.200.1 en10.20.192.0; poner host a uno da10.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/.255o aplicar2^h-2a/31y/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, broadcast192.168.4.31, rango192.168.4.1–192.168.4.30, 30 hosts convencionales. - Solución paso a paso:
/27deja 5 bits de host: 32 direcciones. AND sitúa 192.168.4.31 en192.168.4.0; poner host a uno da192.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/.255o aplicar2^h-2a/31y/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, broadcast192.168.4.63, rango192.168.4.33–192.168.4.62, 30 hosts convencionales. - Solución paso a paso:
/27deja 5 bits de host: 32 direcciones. AND sitúa 192.168.4.32 en192.168.4.32; poner host a uno da192.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/.255o aplicar2^h-2a/31y/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, broadcast198.51.101.255, rango198.51.100.1–198.51.101.254, 510 hosts convencionales. - Solución paso a paso:
/23deja 9 bits de host: 512 direcciones. AND sitúa 198.51.100.255 en198.51.100.0; poner host a uno da198.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/.255o aplicar2^h-2a/31y/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, broadcast203.0.113.63, rango203.0.113.1–203.0.113.62, 62 hosts convencionales. - Solución paso a paso:
/26deja 6 bits de host: 64 direcciones. AND sitúa 203.0.113.0 en203.0.113.0; poner host a uno da203.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/.255o aplicar2^h-2a/31y/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, broadcast10.1.255.255, rango10.1.0.1–10.1.255.254, 65534 hosts convencionales. - Solución paso a paso:
/16deja 16 bits de host: 65536 direcciones. AND sitúa 10.1.255.4 en10.1.0.0; poner host a uno da10.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/.255o aplicar2^h-2a/31y/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, extremos192.0.2.8y192.0.2.9para 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/.255o aplicar2^h-2a/31y/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;
/32representa 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/.255o aplicar2^h-2a/31y/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/24para 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 → /26y2^2=4bloques. Cada bloque tiene 64 direcciones y 62 hosts convencionales. Primero192.168.10.0/26(broadcast192.168.10.63); último192.168.10.192/26(broadcast192.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/24para 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 → /27y2^3=8bloques. Cada bloque tiene 32 direcciones y 30 hosts convencionales. Primero192.168.10.0/27(broadcast192.168.10.31); último192.168.10.224/27(broadcast192.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/24para 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 → /25y2^1=2bloques. Cada bloque tiene 128 direcciones y 126 hosts convencionales. Primero192.0.2.0/25(broadcast192.0.2.127); último192.0.2.128/25(broadcast192.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/24para 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 → /27y2^3=8bloques. Cada bloque tiene 32 direcciones y 30 hosts convencionales. Primero198.51.100.0/27(broadcast198.51.100.31); último198.51.100.224/27(broadcast198.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/24para 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 → /28y2^4=16bloques. Cada bloque tiene 16 direcciones y 14 hosts convencionales. Primero203.0.113.0/28(broadcast203.0.113.15); último203.0.113.240/28(broadcast203.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/16para 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 → /19y2^3=8bloques. Cada bloque tiene 8192 direcciones y 8190 hosts convencionales. Primero10.20.0.0/19(broadcast10.20.31.255); último10.20.224.0/19(broadcast10.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/16para 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 → /20y2^4=16bloques. Cada bloque tiene 4096 direcciones y 4094 hosts convencionales. Primero172.20.0.0/20(broadcast172.20.15.255); último172.20.240.0/20(broadcast172.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/20para 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 → /22y2^2=4bloques. Cada bloque tiene 1024 direcciones y 1022 hosts convencionales. Primero10.0.0.0/22(broadcast10.0.3.255); último10.0.12.0/22(broadcast10.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/24para 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 → /26y2^2=4bloques. Cada bloque tiene 64 direcciones y 62 hosts convencionales. Primero192.168.50.0/26(broadcast192.168.50.63); último192.168.50.192/26(broadcast192.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/24para 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 → /28y2^4=16bloques. Cada bloque tiene 16 direcciones y 14 hosts convencionales. Primero198.51.100.0/28(broadcast198.51.100.15); último198.51.100.240/28(broadcast198.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/23para 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 → /25y2^2=4bloques. Cada bloque tiene 128 direcciones y 126 hosts convencionales. Primero10.10.0.0/25(broadcast10.10.0.127); último10.10.1.128/25(broadcast10.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/22para 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 → /24y2^2=4bloques. Cada bloque tiene 256 direcciones y 254 hosts convencionales. Primero172.31.0.0/24(broadcast172.31.0.255); último172.31.3.0/24(broadcast172.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:
/27avanza 32: 48 pertenece a192.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
ipaddresscuando 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
ipaddresscuando 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/23es una dirección utilizable dentro de192.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
ipaddresscuando 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/23pertenece al bloque198.51.100.0/23, cuyo broadcast es198.51.101.255. - Método empleado: Contraejemplo, cálculo de bloque o regla de representación.
- Comprobación independiente: Revisión con
ipaddresscuando 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
ipaddresscuando 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:
/26crea 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
ipaddresscuando 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
/25cubre .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
ipaddresscuando 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
ipaddresscuando 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/24debe 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á en10.0.8.0/22y 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, clasificafe80::1y 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::1es 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.