Grado en Ingeniería Informática · UAX · Redes de Computadores · Convocatoria extraordinaria

Guía interactiva «te llevo de la mano»

Exámenes extraordinarios 1, 2 y 3, ejercicio a ejercicio y bloque a bloque: te digo qué te pide, qué método aplicar, por qué y cómo plantearlo. Tú haces el cálculo (subredes, fragmentación, trama, tabla de rutas) y luego revelas la solución para comprobar.

Cómo usar esta guía

Cada ejercicio (o bloque de preguntas del mismo tipo) sigue el mismo recorrido, pensado para que aprendas el método, no la respuesta:

🔍 Cómo lo reconozco (qué señales del enunciado te dicen el tipo) → 📐 Método y fórmulas → 💡 Por qué → ✍️ Hazlo tú (los datos concretos para calcular) → 💊 Píldora de examen (el atajo que siempre cae) → y por último el botón ✅ Ver solución para comprobar.

Haz primero el cálculo tapando la solución. Solo la revelas para corregirte. Todos los resultados están verificados con Python (módulo ipaddress para subredes/VLSM, división módulo-2 para CRC, y cálculo directo de fragmentación, Nyquist/Shannon, tiempos y TCP).

🎯 Las 7 familias que SIEMPRE caen (identifícalas y tienes medio examen): (1) Nivel físico: elección de medio por distancia (cobre ≤100 m, apantallado con EMI, monomodo para km) y tiempos (ttx=bits/BW, tprop=d/v). (2) Capacidad: Nyquist C=2·B·log2(M) y Shannon C=B·log2(1+S/N) con S/N=10dB/10. (3) Trama Ethernet y CRC: payload mín 46 B, trama mín 64 B, umbral 1536 (Longitud vs EtherType), FCS = CRC-32 que solo detecta. (4) Subnetting/VLSM: método del bloque (bloque=2bits host, red, broadcast=red+bloque−1, hosts=bloque−2) y VLSM de mayor a menor. (5) El viaje del paquete: IP destino = destino final (no cambia), MAC destino = siguiente salto; ARP Request = 1 por tramo; longest prefix match en la tabla de rutas; next hop = IP vecina. (6) Fragmentación IPv4: payload=⌊(MTU−20)/8⌋×8, nº=⌈datos/payload⌉, offset en unidades de 8, MF=1 salvo el último. (7) Transporte y RIP: MSS=MTU−40, Ack=siguiente byte esperado, BDP=BW·RTT, RTO=SRTT+4·RTTVAR; RIP hop count, infinito=16, split horizon.
PrefijoMáscaraBloqueHosts útiles
/24255.255.255.0256254
/25255.255.255.128128126
/26255.255.255.1926462
/27255.255.255.2243230
/28255.255.255.2401614
/29255.255.255.24886
/30255.255.255.25242

Potencias de 2: 21..10 = 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024. log2 de esas mismas = 1…10.

✅ Nota de honestidad: he recalculado con Python las 45+45 respuestas de los dos test y los 10 problemas abiertos. Todas las claves oficiales de Redes salen correctas. El único detalle es un comentario mal redactado en el solucionario del Examen 3 (P23) sobre un distractor; la respuesta correcta (.223) es la buena y está marcada. Lo dejo señalado en su tarjeta.

Examen 1 · 10 ejercicios abiertos

Problemas de desarrollo (2 h, 10 puntos). Aquí aprendes el método completo con justificación; es la base que reutilizas en los dos test.

Nivel físico1. Elección de medio y tiempos (transmisión vs propagación)

a) Medio cableado para: (i) backbone vertical 130 m; (ii) horizontal 90 m junto a maquinaria con alta EMI; (iii) enlace entre sedes a 3 km. b) Fichero de 4 MB, enlace 200 Mb/s, 60 km, v=2·108 m/s: calcula ttx, tprop y total en ms. c) ¿domina la transmisión o la propagación?

🔍 Cómo lo reconozcoVes distancias y pide medio → regla del alcance. Ves tamaño + ancho de banda + distancia → tiempos. La palabra clave es «último bit» = ttx + tprop.
📐 Método y fórmulasMedio por distancia: ≤100 m → cobre (par trenzado; apantallado si hay EMI); cientos de m → fibra multimodo; km → fibra monomodo.
ttx = tamaño(bits) / ancho de banda.
tprop = distancia / velocidad.
Total = ttx + tprop.
💡 Por quéLa transmisión depende de cuántos bits metes por el cable y a qué velocidad; la propagación, de lo lejos que está el receptor. Un fichero grande por un enlace corto → manda la transmisión.
✍️ Hazlo tú (datos para calcular)Pasa 4 MB a bits (×8, y 1 M=106). ttx=bits/200e6. tprop=60000/2e8. Todo a ms (×1000). Compara qué sumando es mayor.
💊 Píldora de examenEl par trenzado muere a 100 m (mémelo). Con ruido industrial, cobre apantallado (F/UTP, S/FTP). ttx usa BITS (no bytes); un fallo típico es olvidar el ×8.
Solución comprobada(a) (i) fibra multimodo (130 m > 100 m del cobre); (ii) Cat 6A apantallado (90 m cabe en cobre pero la EMI obliga a blindaje); (iii) fibra monomodo (3 km).
(b) bits = 4·106·8 = 32·106. ttx = 32e6/200e6 = 0,16 s = 160 ms. tprop = 60000/2e8 = 0,30 ms. Total = 160,3 ms.
(c) Domina la transmisión (160 ms ≫ 0,3 ms). La propagación solo mandaría en enlaces larguisimos (satélite).

Nivel físico2. Capacidad del canal: Nyquist y Shannon

B = 4000 Hz. a) Sin ruido, M=8 niveles: capacidad por Nyquist. b) Con ruido, SNR=25 dB: capacidad por Shannon (pasa dB a lineal). c) ¿quién marca el límite real? ¿subir a M=16 supera a Shannon?

🔍 Cómo lo reconozco«Sin ruido + niveles M» → Nyquist. «Con ruido + SNR en dB» → Shannon (primero pasa los dB a lineal).
📐 Método y fórmulasNyquist: C = 2·B·log2(M).
Shannon: C = B·log2(1 + S/N), con S/N = 10(dB/10).
💡 Por quéNyquist te dice cuánto consigues con una codificación de M niveles (sin ruido). Shannon te da la cota absoluta que impone el ruido: por muchos niveles que añadas, no la superas.
✍️ Hazlo tú (datos para calcular)Nyquist: 2·4000·log2(8) (recuerda log2(8)=3). Shannon: S/N=102,5≈316,2, luego 4000·log2(1+316,2).
💊 Píldora de examenlog2 de potencias de 2 de memoria: 2→1, 4→2, 8→3, 16→4, 32→5. Los dB SIEMPRE a lineal antes de Shannon (10dB/10). Shannon es el techo; Nyquist, lo que logras con M niveles.
Solución comprobada(a) C = 2·4000·3 = 24 000 bps.
(b) S/N = 102,5 = 316,23 → C = 4000·log2(317,23) ≈ 33 238 bps (≈33,2 kbps).
(c) El límite real lo pone Shannon (33,2 kbps). Con M=16: Nyquist = 2·4000·4 = 32 000 bps, sigue por debajo de Shannon. No se puede superar Shannon subiendo niveles.

Nivel de enlace3. Trama Ethernet: payload mínimo, umbral y FCS

a) Una app entrega 22 bytes: ¿cuántos bytes de payload y tamaño total (sin preámbulo)? b) El campo de 2 B tras las MAC vale 0x05DC: pásalo a decimal y di si es Ethernet II o 802.3. c) Marca la opción correcta sobre el FCS.

🔍 Cómo lo reconozcoDatos < 46 B → padding hasta 46. Campo de 2 B tras las MAC → regla del umbral 1536. Pregunta conceptual sobre FCS → es CRC-32 de detección.
📐 Método y fórmulasPayload mín = 46 B (con padding si hace falta). Trama mín = 64 B = 14 (cabecera) + 46 (datos) + 4 (FCS).
Umbral: valor ≤ 1500 → es Longitud (IEEE 802.3); ≥ 1536 (0x0600) → es EtherType (Ethernet II).
💡 Por quéLa trama mínima de 64 B viene del slot-time de CSMA/CD (colisiones). El FCS es un CRC-32: el receptor lo recalcula y, si no cuadra, descarta la trama; no la corrige ni la retransmite (eso es cosa de TCP).
✍️ Hazlo tú (datos para calcular)Pasa 0x05DC a decimal: 5·256 + 13·16 + 12. Compáralo con 1500. Para el FCS, descarta las opciones que mezclan capas (checksum TCP, EtherType, retransmisión).
💊 Píldora de examenTrama mínima 64 B y payload mínimo 46 B: memorízalos. Cabeceras clave: IP 20, TCP 20, UDP 8, Ethernet 14+4(FCS). 0x0600 = 1536 es la frontera Longitud/EtherType.
Solución comprobada(a) Payload = 46 B (22 + 24 de padding). Total sin preámbulo = 14 + 46 + 4 = 64 B.
(b) 0x05DC = 5·256+13·16+12 = 1500. Como 1500 ≤ 1500 es una Longitud → IEEE 802.3 (es justo el caso límite, el payload máximo).
(c) Correcta: «Es un CRC-32 que solo detecta errores; la trama corrupta se descarta».

Nivel de enlace4. CRC / FCS: división módulo-2

M = 1101011011, generador G = 10011 (grado 4). a) Calcula el CRC (FCS): cuántos ceros añades y la trama transmitida. b) ¿qué hace el receptor y qué resto debe salir? c) ¿detecta o corrige? ¿qué capa recupera la info?

🔍 Cómo lo reconozco«Proteger con CRC / FCS / polinomio G» → división binaria módulo-2 (XOR).
📐 Método y fórmulasCeros a añadir = grado(G) = (nº bits de G) − 1. Aquí G tiene 5 bits → grado 4 → 4 ceros.
Divide M·24 entre G con XOR; el resto (grado < 4, o sea 4 bits) es el CRC.
Trama transmitida = M seguido del CRC.
💡 Por quéEl XOR va «restando» G cada vez que el bit más a la izquierda del resto parcial es 1. En recepción se divide TODO (datos+CRC) por G: si no hubo error, el resto es 0. Por eso añadir el CRC hace la trama divisible por G.
✍️ Hazlo tú (datos para calcular)Haz la división de 11010110110000 entre 10011 con XOR paso a paso. El resto son 4 bits. Luego divide la trama completa por G y comprueba que da 0000.
💊 Píldora de examenNº de ceros = grado de G = (bits de G) − 1. El resto SIEMPRE tiene grado < grado(G) (menos bits que G). En recepción, resto 0 = trama OK; resto ≠ 0 = descartar.
Solución comprobada(a) Se añaden 4 ceros. División módulo-2 de 11010110110000 / 10011 → CRC = 1110 (verificado con Python). Trama transmitida = 1101011011 1110.
(b) El receptor divide 11010110111110 entre G; debe salir resto 0000 (verificado) → acepta.
(c) El CRC solo detecta; no corrige. Si se descarta la trama, la recupera TCP (capa de transporte) retransmitiendo; con UDP se perdería.

Nivel de red5. Subnetting: método del bloque

Dirección 192.168.40.181/27. a) Tamaño de bloque, red, broadcast, primer/último host y nº de hosts útiles. b) Comprueba la red en binario. c) Si divides 192.168.40.0/24 en /27, ¿cuántas subredes y hosts por subred?

🔍 Cómo lo reconozcoUna IP con prefijo /n y piden red/broadcast/hosts → método del bloque.
📐 Método y fórmulasBits de host = 32 − n. Tamaño de bloque = 2(bits host) = 256 − (octeto de máscara).
Red = mayor múltiplo del bloque ≤ octeto de la IP.
Broadcast = red + bloque − 1. Hosts útiles = 2(bits host) − 2.
Nº subredes al pasar de /a a /b = 2(b−a).
💡 Por quéEl prefijo dice cuántos bits son de red; el resto son de host. Todos los hosts de una subred comparten la parte de red. Restas 2 porque la primera (red) y la última (broadcast) no se asignan a máquinas.
✍️ Hazlo tú (datos para calcular)/27 → 5 bits de host → bloque 32. Múltiplos de 32: 0,32,64,96,128,160,192,224. ¿Entre cuáles cae 181? Esa es la red. Broadcast = red+31. Hosts = 32−2.
💊 Píldora de examenAtajo de la máscara: /27 = 255.255.255.224; bloque = 256−224 = 32. Tabla de bloques por prefijo: /25→128, /26→64, /27→32, /28→16, /29→8, /30→4. Hosts útiles = bloque − 2.
Solución comprobada(a) Bloque = 25 = 32. Red = 192.168.40.160 (181 cae entre 160 y 191). Broadcast = 192.168.40.191. Primer host .161, último .190. Hosts útiles = 30.
(b) 181 = 1011 0101; máscara /27 en el octeto = 1110 0000; AND = 1010 0000 = 160 ✓.
(c) /24→/27 añade 3 bits → 8 subredes de 30 hosts cada una. (Todo verificado con ipaddress.)

Nivel de red6. VLSM y ruta estática (next hop)

Bloque 192.168.10.0/24 para: LAN A 100 hosts, LAN B 50, LAN C 25, WAN R1–R2 2 hosts. a) Asigna por VLSM (mayor a menor): prefijo, red, rango y broadcast de cada una. b) IP de las interfaces WAN. c) Ruta estática en R1 hacia LAN C (destino/máscara y next hop) y por qué.

🔍 Cómo lo reconozcoVarias redes de tamaños distintos a partir de un bloque → VLSM. Piden la ruta hacia una LAN remota → next hop = vecino directo.
📐 Método y fórmulasPrefijo por LAN: el menor /n con 2(32−n) − 2 ≥ hosts pedidos.
Orden: de mayor a menor, empezando en la primera dirección libre; cada subred arranca en (broadcast anterior + 1).
Ruta estática: destino = red/máscara de la LAN remota; next hop = IP del router vecino (directamente alcanzable).
💡 Por quéAsignar primero las LAN grandes evita huecos y solapes. El next hop debe ser una IP que R1 alcance en un salto (está en su red /30); nunca se pone un host de la LAN remota (no es vecino) ni una MAC (las MAC no van en la tabla de rutas).
✍️ Hazlo tú (datos para calcular)Tabla de hosts: /25→126, /26→62, /27→30, /30→2. Asigna A=/25 desde .0, luego B=/26, C=/27, WAN=/30 consecutivos. La ruta en R1: ip route 192.168.10.192 255.255.255.224 <IP WAN de R2>.
💊 Píldora de examen«De mayor a menor» es la regla de oro de VLSM: evita fragmentar el espacio. El next hop siempre es una IP VECINA (misma red que una interfaz del router). Máscara /27 = 255.255.255.224.
Solución comprobada(a) LAN A /25 192.168.10.0 (rango .1–.126, bcast .127, 126 hosts). LAN B /26 192.168.10.128 (.129–.190, bcast .191, 62). LAN C /27 192.168.10.192 (.193–.222, bcast .223, 30). WAN /30 192.168.10.224 (.225–.226, bcast .227, 2).
(b) R1 = 192.168.10.225, R2 = 192.168.10.226.
(c) ip route 192.168.10.192 255.255.255.224 192.168.10.226. El next hop es 192.168.10.226 (interfaz WAN de R2) porque está en la red /30 conectada a R1, así que R1 la alcanza en un salto. (VLSM verificado con Python.)

Nivel de red7. El viaje del paquete: IP, MAC y ARP

PC-1 (192.168.40.30) envía a SRV (10.10.50.200) por PC-1→R1→R2→SRV. a) En la 1ª trama que sale de PC-1: IP destino y MAC destino, justifícalas. b) En R1→R2: IP y MAC destino; ¿cambia la IP? c) Con cachés ARP vacías, ¿cuántos ARP Request en la ida y en qué tramo?

🔍 Cómo lo reconozcoPregunta por IP destino vs MAC destino por tramo, o por número de ARP Request → regla «IP fija, MAC cambia».
📐 Método y fórmulasRegla de oro: la IP destino es siempre la del destino final (no cambia en todo el viaje). La MAC destino es la del siguiente salto (cambia en cada tramo).
ARP Request: uno por cada tramo Ethernet donde hay que resolver la MAC del siguiente salto. Los switches (capa 2) no cuentan.
💡 Por quéIP es direccionamiento extremo a extremo (los routers la necesitan intacta para enrutar). MAC es local: cada enlace se rehace con las MAC de ese tramo. ARP no cruza routers: cada router resuelve la MAC de su propio siguiente salto.
✍️ Hazlo tú (datos para calcular)Cuenta los tramos con enlace de nivel 2: PC-1→R1, R1→R2, R2→SRV. Cada uno genera un ARP Request si la caché está vacía. La MAC destino de la 1ª trama es la del gateway (R1), no la de SRV.
💊 Píldora de examen«IP destino = destino final; MAC destino = siguiente salto». Con 3 tramos y cachés vacías → 3 ARP Request. La 1ª trama NUNCA lleva la MAC del servidor remoto.
Solución comprobada(a) IP destino = 10.10.50.200 (SRV, el destino final). MAC destino = MAC de R1 (el gateway 192.168.40.1), porque SRV está en otra red.
(b) IP destino = 10.10.50.200 (la misma, no cambia). MAC destino = MAC de R2 (interfaz WAN 172.16.0.2).
(c) 3 ARP Request: (1) PC-1 pregunta por 192.168.40.1; (2) R1 por 172.16.0.2; (3) R2 por 10.10.50.200.

Nivel de red8. Fragmentación IPv4

PC-1 envía a SRV un datagrama de Total Length = 3980 B (cabecera IP 20 B, DF=0). En R1–R2 la MTU = 620 B. a) Payload ajustado y nº de fragmentos (con fórmula). b) Tabla: datos, offset (u8), MF y Total Length de cada fragmento. c) ¿quién reensambla y en qué fragmento va la cabecera TCP?

🔍 Cómo lo reconozco«MTU menor que el datagrama, DF=0» → fragmentación IPv4. Piden payload, nº fragmentos u offsets.
📐 Método y fórmulasPayload por fragmento = ⌊(MTU − 20)/8⌋ × 8 (múltiplo de 8 inferior).
Datos a repartir = Total Length − 20.
Nº fragmentos = ⌈datos / payload⌉.
Offset (en unidades de 8 B) = (bytes previos)/8. MF = 1 en todos menos el último. Total Length de cada fragmento = datos + 20.
💡 Por quéCada fragmento es un datagrama IP con su propia cabecera de 20 B, por eso el payload debe caber en (MTU−20). El offset va en unidades de 8 bytes para que quepa en el campo, así que el payload de los fragmentos intermedios ha de ser múltiplo de 8.
✍️ Hazlo tú (datos para calcular)Payload = ⌊(620−20)/8⌋×8 = ⌊600/8⌋×8. Datos = 3980−20 = 3960. Nº = ⌈3960/600⌉. El offset sube de 600/8 = 75 en 75; el último lleva el resto y MF=0.
💊 Píldora de examenEl offset SIEMPRE en unidades de 8 (divide los bytes previos entre 8). El payload de los fragmentos llenos es múltiplo de 8. Reensambla SOLO el host destino. La cabecera TCP viaja en el primer fragmento (offset 0).
Solución comprobada(a) Payload = ⌊600/8⌋×8 = 75×8 = 600 B. Datos = 3960 B. Nº = ⌈3960/600⌉ = ⌈6,6⌉ = 7 fragmentos.
(b) Frags 1–6: 600 B, offsets 0/75/150/225/300/375, MF=1, TL=620. Frag 7: 360 B, offset 450, MF=0, TL=380. (6×600+360 = 3960 ✓.)
(c) Reensambla solo el host destino (SRV): es el único punto por el que pasan todos los fragmentos. La cabecera TCP va en el primer fragmento (offset 0). Todo verificado con Python.

Nivel de transporte9. TCP: Seq/Ack, MSS, BDP y RTO

PC-1 abre TCP con SRV:80. ISN cliente 8000, servidor 20000. El cliente pide 500 B, el servidor responde 3000 B, y el cliente cierra. a) Ack del SYN-ACK; Ack del servidor a los 500 B; Ack del cliente a los 3000 B; Seq del FIN del cliente. b) MTU=1500: MSS y nº de segmentos para 30 000 B (y el último). c) BDP con 1 Gb/s y RTT 40 ms; y el RTO con SRTT=200, RTTVAR=40, muestra=280.

🔍 Cómo lo reconozco«Seq/Ack tras el handshake» → reglas de numeración. «MSS / segmentos» → MTU−40. «BDP» → BW×RTT. «RTO» → fórmula de Jacobson.
📐 Método y fórmulasSYN y FIN consumen 1; los datos consumen su longitud; Ack = siguiente byte esperado; los ACK puros no consumen.
MSS = MTU − 20 (IP) − 20 (TCP).
Segmentos = ⌈datos / MSS⌉.
BDP = ancho de banda × RTT (pasa a bytes /8).
RTO = SRTT + 4·RTTVAR, con RTTVAR = ¾·RTTVAR + ¼·|SRTT−muestra| y SRTT = ⅞·SRTT + ⅛·muestra (calcula RTTVAR ANTES que SRTT).
💡 Por quéEl Ack indica el próximo byte que se espera: por eso es (Seq recibido + longitud). El SYN inicial «gasta» el ISN, de ahí el +1. El BDP es cuántos bytes caben «en vuelo» por el tubo. El RTO se adapta a la variabilidad del RTT.
✍️ Hazlo tú (datos para calcular)Ack SYN-ACK = ISN cliente +1. Ack a 500 B = 8001+500. Los datos del servidor empiezan en 20001; Ack del cliente = 20001+3000. FIN del cliente = 8000+1(SYN)+500(datos). MSS=1500−40. Segs=⌈30000/1460⌉. BDP=1e9·0,04/8. RTTVAR primero, luego SRTT, luego RTO.
💊 Píldora de examenMSS = MTU − 40 (20 IP + 20 TCP). BDP: pasa bits a bytes dividiendo entre 8. En el RTO calcula RTTVAR ANTES que SRTT (usa el SRTT viejo). SYN/FIN cuentan como 1 byte cada uno.
Solución comprobada(a) Ack del SYN-ACK = 8001. Ack a los 500 B = 8001+500 = 8501. Ack del cliente a los 3000 B = 20001+3000 = 23001. Seq del FIN = 8000+1+500 = 8501.
(b) MSS = 1500−40 = 1460 B. Segmentos = ⌈30000/1460⌉ = 21; el último lleva 30000−20·1460 = 800 B.
(c) BDP = 1e9·0,04/8 = 5 000 000 B (≈5 MB). RTTVAR = ¾·40 + ¼·80 = 50. SRTT = ⅞·200 + ⅛·280 = 210. RTO = 210 + 4·50 = 410 ms. (Verificado con Python.)

Enrutamiento dinámico10. RIP: métrica, count-to-infinity y datos fijos

Cadena R1—R2—R3—R4—R5, con la Red Z directa en R5. a) ¿con qué métrica conoce R1 la Red Z y cómo se propaga? b) Si R5 pierde Z, describe el count-to-infinity y una técnica que lo mitigue. c) Tres datos fijos de RIP.

🔍 Cómo lo reconozcoTopología en cadena + «nº de saltos» → RIP (vector distancia). Palabras «bucle»/«infinito» → count-to-infinity.
📐 Método y fórmulasMétrica RIP = nº de saltos. La red directa vale 1 (o 0 en su router); cada router que reenvía el anuncio suma 1.
Infinito = 16 (máximo útil 15). Actualizaciones cada 30 s. Transporte UDP puerto 520.
💡 Por quéRIP aplica Bellman-Ford: cada router se cree lo que le cuenta el vecino y le suma 1. El count-to-infinity ocurre cuando, al caer una red, dos routers se reanuncian mutuamente una ruta obsoleta y la métrica sube 1 a 1 hasta 16. Split horizon lo evita: no anuncias una ruta por la interfaz por la que la aprendiste.
✍️ Hazlo tú (datos para calcular)R5 anuncia Z con 1; R4 la ve con 2, R3 con 3, R2 con 4, R1 con 5. Para (b) explica el bucle R4↔R5 y nombra split horizon. Para (c): infinito=16, periodo=30 s, UDP/520.
💊 Píldora de examenMétrica = nº de routers atravesados; suma 1 por salto. Infinito=16, límite 15 saltos. Split horizon = no devolver al vecino la ruta que te enseñó. RIP va sobre UDP/520 cada 30 s.
Solución comprobada(a) R1 conoce Z con 5 saltos (R5→1, y cada router suma 1 hasta R1). Se propaga por anuncios periódicos, vector distancia.
(b) Count-to-infinity: R4 aún anuncia «Z a 2 por R5»; R5, sin ruta, se lo cree («Z a 3»); R4 recalcula («Z a 4»)… suben hasta 16 = inalcanzable. Mitigación – split horizon: un router no anuncia a un vecino las rutas aprendidas de ese vecino (también poison reverse, hold-down, triggered updates).
(c) Infinito = 16; actualizaciones cada 30 s; UDP puerto 520.

Examen 2 · Tipo test (45 preguntas)

Formato real del examen de Redes: preguntas con diagramas (topología, trama, tablas de rutas, captura TCP). Agrupadas por bloque y tipo.

Nivel físicoB1. Bloque 1 (P1–P8): medios, Nyquist/Shannon y tiempos

P1 backbone 95 m → medio. P2 80 m con EMI. P3 3 km entre sedes. P4 monomodo vs multimodo. P5 Nyquist B=3100, M=16. P6 Shannon B=3000, S/N=30 dB. P7 ttx de 8 Mbit a 100 Mb/s. P8 tprop por 300 km a 2·108.

🔍 Cómo lo reconozcoDistancia + medio → regla del alcance. «Sin ruido + M» → Nyquist. «dB» → Shannon. «tamaño/ancho de banda» → ttx. «distancia/velocidad» → tprop.
📐 Método y fórmulas≤100 m → cobre (apantallado si hay EMI); km → monomodo. Monomodo: núcleo estrecho, menos dispersión, más alcance.
Nyquist C=2·B·log2(M). Shannon C=B·log2(1+S/N), S/N=10dB/10. ttx=bits/BW. tprop=d/v.
💡 Por quéEl medio se elige por distancia y entorno (ruido). Los tiempos separan «llenar el cable» (ttx) de «recorrer la distancia» (tprop). Los dB SIEMPRE se pasan a lineal antes de Shannon.
✍️ Hazlo tú (datos para calcular)P5: 2·3100·log2(16). P6: S/N=103=1000, C=3000·log2(1001). P7: 8e6/100e6 en ms. P8: 300000/2e8 en ms.
💊 Píldora de examenlog2(16)=4. 30 dB = factor 1000 (10dB/10). Cuidado con bits vs bytes y ms vs s. Par trenzado muere a 100 m.
Solución comprobadaP1→b UTP Cat 6A (95<100). P2→c Cat 6A FTP/STP apantallado. P3→b fibra monomodo. P4→b monomodo = núcleo estrecho, menor dispersión, mayor alcance. P5→b 2·3100·4 = 24 800 bps. P6→b 3000·log2(1001) ≈ 29 902 ≈ 30 000 bps. P7→b 8e6/100e6 = 0,08 s = 80 ms. P8→a 300000/2e8 = 1,5 ms. (Todos verificados con Python.)

Nivel de enlaceB2. Bloque 2 (P9–P17): trama Ethernet, CRC, hub/switch

P9 campo tras las MAC en Ethernet II. P10 0x0800 (2048) → interpretación. P11 20 B de datos → payload. P12 MAC de broadcast. P13 función del FCS. P14 CRC de M=1101011011, G=10011. P15 comprobación del CRC en recepción. P16 hub vs switch. P17 dominios de colisión/broadcast en la LAN.

🔍 Cómo lo reconozco«Campo tras las MAC» → EtherType/Longitud (umbral 1536). «datos<46» → padding. «CRC/G» → división módulo-2. «hub/switch» → dominios.
📐 Método y fórmulasEtherType (≥1536) identifica el protocolo (0x0800=IPv4). Payload mín = 46 B (padding). MAC broadcast = FF:FF:FF:FF:FF:FF. FCS = CRC-32 que detecta (no corrige). Recepción: divide todo por G, resto 0 = OK.
Hub (capa 1): un solo dominio de colisión. Switch (capa 2): un dominio de colisión por puerto, pero un único dominio de broadcast (lo separa el router).
💡 Por quéEl switch aprende MAC y reenvía solo por el puerto correcto (segmenta colisiones), pero el broadcast llega a toda la LAN; hace falta un router (o VLAN) para separarlo.
✍️ Hazlo tú (datos para calcular)P14: divide 11010110110000 / 10011 con XOR → resto de 4 bits. P10: 2048≥1536 → EtherType. P17: colisión por puerto, broadcast compartido.
💊 Píldora de examen0x0600=1536 es la frontera. Payload mín 46, trama mín 64. FCS solo detecta. Switch = 1 dominio de colisión/puerto; broadcast lo corta el router.
Solución comprobadaP9→c EtherType. P10→b EtherType (2048≥1536) → Ethernet II con IPv4. P11→b 46 B (padding). P12→b FF:FF:FF:FF:FF:FF. P13→a CRC-32 que detecta; trama corrupta se descarta. P14→b CRC = 1110 (verificado). P15→b dividir toda la trama por G; resto 0 = correcta. P16→b hub repite a todos (1 dominio de colisión), switch reenvía por MAC y segmenta. P17→a un dominio de colisión por puerto, un solo dominio de broadcast.

Nivel de redB3a. Bloque 3, subnetting (P18–P23): hosts, red, broadcast, máscara

P18 hosts útiles de /26. P19 red de 172.20.5.66/26. P20 broadcast de esa red. P21 máscara de /28. P22 /24 dividido en /28: subredes y hosts. P23 broadcast de 10.14.200.145/28.

🔍 Cómo lo reconozcoIP con prefijo → método del bloque. «máscara de /n» → tabla. «/a en /b» → 2(b−a) subredes.
📐 Método y fórmulasBits host = 32−n; bloque = 2(32−n). Red = mayor múltiplo del bloque ≤ octeto. Broadcast = red+bloque−1. Hosts útiles = bloque−2. Subredes al pasar de /a a /b = 2(b−a).
💡 Por quéEl prefijo separa red de host; restas 2 (red y broadcast). La máscara sale de poner a 1 los n primeros bits.
✍️ Hazlo tú (datos para calcular)P18: 26−2. P19: bloque 64, múltiplos 0/64/128/192; 66→64. P20: 64+63. P21: /28→11110000=240. P22: 24 subredes, 24−2 hosts. P23: bloque 16; 145→144; bcast 159.
💊 Píldora de examenBloques por prefijo: /25→128, /26→64, /27→32, /28→16, /29→8. Máscaras: /26→.192, /27→.224, /28→.240, /29→.248. Hosts = bloque−2.
Solución comprobadaP18→b 62. P19→c 172.20.5.64. P20→b 172.20.5.127. P21→c 255.255.255.240. P22→b 16 subredes de 14 hosts. P23→b 10.14.200.159 (red .144, bloque 16). Todo verificado con ipaddress.

Nivel de redB3b. Bloque 3, VLSM y rutas (P24–P27): prefijo, red y next hop

P24 VLSM en 172.16.8.0/22, LAN1 300 hosts → prefijo. P25 red de LAN2 (120 hosts, /25) tras LAN1. P26 longest-prefix-match para 172.20.6.10 entre /16, /24 y /0. P27 qué es el next hop de una ruta estática.

🔍 Cómo lo reconozco«300 hosts → prefijo» → el menor /n con 2host−2 ≥ necesarios. «varias rutas coinciden» → longest prefix match. «next hop» → IP vecina.
📐 Método y fórmulasPrefijo: el menor /n con hosts ≥ pedidos (300→/23 da 510). VLSM: mayor a menor, cada subred tras el broadcast de la anterior. Longest prefix match: gana el prefijo más largo (más específico). Next hop: IP del router vecino alcanzable por la red de salida.
💡 Por quéEl prefijo más largo describe la ruta más concreta hacia el destino, por eso se prefiere a la general (/16) y a la por defecto (/0). El next hop nunca es una MAC ni un broadcast.
✍️ Hazlo tú (datos para calcular)P24: 29−2 = 510 ≥ 302 → /23 (/24 solo da 254). P25: LAN1 /23 ocupa 8.0–9.255, LAN2 empieza en 10.0. P26: /24 gana. P27: IP del vecino.
💊 Píldora de examen/23 = 510 hosts, /24 = 254, /25 = 126. En VLSM «de mayor a menor». Longest prefix match: máscara más larga gana. Next hop = IP vecina, nunca MAC.
Solución comprobadaP24→b /23 (510 ≥ 300; /24 se queda en 254). P25→b 172.16.10.0 (LAN1 /23 ocupa .8.0–.9.255). P26→c 172.20.6.0/24 (prefijo más específico). P27→c la IP del router vecino alcanzable por la red de salida. (VLSM verificado con Python.)

Nivel de redB3c. Bloque 3, ARP/IP-MAC y fragmentación (P28–P33)

P28 MAC destino de la 1ª trama de PC-A hacia SRV (otra red). P29 IP destino durante toda la ida. P30 nº de ARP Request con cachés vacías. P31–P33 datagrama TL=3000, hdr 20, MTU 576: nº de fragmentos, payload ajustado y offset del último (u8).

🔍 Cómo lo reconozco«MAC/IP por tramo» → IP fija, MAC del siguiente salto. «MTU < datagrama» → fragmentación.
📐 Método y fórmulasIP destino = destino final (no cambia). MAC destino de la 1ª trama = gateway. ARP Request = 1 por tramo (switches no cuentan).
Payload = ⌊(MTU−20)/8⌋×8. Nº = ⌈(TL−20)/payload⌉. Offset del último (u8) = (bytes previos)/8.
💡 Por quéLa MAC cambia en cada salto; la IP no. Cada fragmento lleva su cabecera de 20 B, por eso el payload cabe en MTU−20 y es múltiplo de 8 (offset en unidades de 8).
✍️ Hazlo tú (datos para calcular)P31/32: payload = ⌊(576−20)/8⌋×8 = ⌊556/8⌋×8 = 69·8 = 552; datos = 2980; nº = ⌈2980/552⌉. P33: 5 fragmentos llenos → offset último = 5·552/8.
💊 Píldora de examen«IP destino = final; MAC = siguiente salto». 3 tramos = 3 ARP. Payload múltiplo de 8; offset en unidades de 8 (divide bytes previos entre 8).
Solución comprobadaP28→b MAC de R1 (gateway). P29→c 172.20.6.10 (SRV, no cambia). P30→c 3 ARP Request. P31→c payload 552, datos 2980, nº = ⌈5,40⌉ = 6. P32→c 552 B. P33→b offset del 6º = 5·552/8 = 2760/8 = 345. (Fragmentación verificada con Python.)

Nivel de transporteB4. Bloque 4 (P34–P41): TCP/UDP, MSS, BDP y SRTT

P34 por qué el SYN-ACK lleva Ack=5001 (ISN cliente 5000). P35 socket del cliente. P36 Ack del cliente tras 2000 B con Seq=9001. P37 UDP vs TCP (DNS). P38 MSS con MTU 1500. P39 segmentos para 40 000 B con MSS 1460. P40 BDP con 100 Mb/s y RTT 20 ms. P41 nuevo SRTT (SRTT 80, muestra 120, α=1/8).

🔍 Cómo lo reconozco«Ack tras SYN o datos» → siguiente byte esperado. «MSS» → MTU−40. «segmentos» → techo. «BDP» → BW×RTT. «SRTT» → suavizado.
📐 Método y fórmulasSYN consume 1 → Ack = ISN+1. Ack de datos = Seq recibido + Len. Socket = IP:puerto. UDP no usa conexión ni Seq/Ack. MSS = MTU−20−20 = 1460. Segmentos = ⌈datos/MSS⌉. BDP = BW·RTT /8. SRTT = (1−α)·SRTT + α·muestra.
💡 Por quéEl Ack siempre anuncia el próximo byte que se espera. UDP es «dispara y olvida» (DNS). El BDP mide los bytes en vuelo. El SRTT suaviza la estimación del RTT.
✍️ Hazlo tú (datos para calcular)P36: 9001+2000. P38: 1500−40. P39: ⌈40000/1460⌉. P40: 100e6·0,02/8. P41: ⅞·80 + ⅛·120.
💊 Píldora de examenMSS = MTU − 40. BDP en bytes: dividir bits entre 8. Ack = siguiente byte esperado. SYN/FIN cuentan 1.
Solución comprobadaP34→a confirma ISN+1 (el SYN consume 1). P35→b 172.20.5.66:49876. P36→c 9001+2000 = 11001. P37→b UDP sin conexión ni Seq/Ack. P38→c 1460 B. P39→b ⌈40000/1460⌉ = ⌈27,4⌉ = 28. P40→a 100e6·0,02/8 = 250 000 B. P41→a ⅞·80 + ⅛·120 = 85 ms. (Verificado con Python.)

EnrutamientoB5. Bloque 5 (P42–P45): RIP, métrica, split horizon e infinito

P42 Red Y directa en R1: métrica con que la conoce R4 (cadena R1–R2–R3–R4). P43 métrica de RIP. P44 regla del split horizon. P45 valor de «infinito» en RIP.

🔍 Cómo lo reconozcoCadena + saltos → RIP. «regla que evita bucles» → split horizon.
📐 Método y fórmulasMétrica RIP = nº de saltos; suma 1 por router. Split horizon: no anuncies una ruta por la interfaz por la que la aprendiste. Infinito = 16 (máx. 15 saltos).
💡 Por quéRed directa en R1 → R2 la ve a 1, R3 a 2, R4 a 3. El límite de 16 acota el count-to-infinity.
✍️ Hazlo tú (datos para calcular)P42: cuenta saltos R1→R4 = 3. P43: hop count. P44: no devolver la ruta al vecino que la enseñó. P45: 16.
💊 Píldora de examenSuma 1 por salto. Infinito = 16, máximo útil 15. Split horizon = no reanunciar al que te enseñó. RIP sobre UDP/520 cada 30 s.
Solución comprobadaP42→c 3 saltos (R2:1, R3:2, R4:3). P43→a número de saltos (hop count). P44→b no anunciar a un vecino una ruta aprendida de ese vecino. P45→b 16.

Examen 3 · Tipo test (45 preguntas)

Segundo test, distinto al anterior: mismos tipos, números nuevos (y CRC con G de grado 3, Manchester). Ideal para consolidar.

Nivel físicoB1. Bloque 1 (P1–P8): medios, Manchester, Nyquist/Shannon y tiempos

P1 backbone 88 m. P2 92 m con motores (EMI). P3 4 km entre sedes. P4 codificación Manchester. P5 Nyquist B=2400, M=8. P6 Shannon B=4000, S/N=20 dB. P7 ttx de 5 Mbit a 50 Mb/s. P8 tprop por 200 km.

🔍 Cómo lo reconozcoDistancia+medio → alcance. «Manchester» → autosincron./doble ancho de banda. «M» → Nyquist. «dB» → Shannon.
📐 Método y fórmulas≤100 m → cobre (apantallado si EMI); km → monomodo. Manchester: transición en mitad del bit → autosincroniza pero duplica el ancho de banda (1 bit/baudio).
Nyquist C=2·B·log2(M). Shannon C=B·log2(1+S/N), S/N=10dB/10.
💡 Por quéManchester mete una transición por bit (reloj embebido), a costa de más ancho de banda. Nyquist/Shannon: mismo esquema que el examen 1; los dB a lineal.
✍️ Hazlo tú (datos para calcular)P5: 2·2400·log2(8). P6: S/N=102=100, C=4000·log2(101). P7: 5e6/50e6. P8: 200000/2e8.
💊 Píldora de examenlog2(8)=3. 20 dB = factor 100. Manchester = 1 bit/baudio, doble BW. Cobre hasta 100 m.
Solución comprobadaP1→a UTP Cat 6A (88<100). P2→b Cat 6A apantallado. P3→c fibra monomodo. P4→a transición en mitad del bit, autosincroniza y duplica el ancho de banda. P5→b 2·2400·3 = 14 400 bps. P6→b 4000·log2(101) ≈ 26 633 bps. P7→b 5e6/50e6 = 100 ms. P8→b 200000/2e8 = 1 ms. (Verificado con Python.)

Nivel de enlaceB2. Bloque 2 (P9–P17): EtherType/Longitud, CRC (G grado 3), hub/switch

P9 campo tras las MAC en Ethernet II. P10 valor 0x0600 (1536) o más. P11 valor 40 (0x0028). P12 18 B de datos → payload. P13 MAC de broadcast. P14 CRC de M=110101101, G=1001 (grado 3). P15 comprobación del CRC. P16 hub vs switch (colisión). P17 dominios en la LAN.

🔍 Cómo lo reconozco«Campo tras MAC» → umbral 1536. «CRC/G grado 3» → se añaden 3 ceros. «hub/switch» → dominios.
📐 Método y fórmulasValor ≥1536 → EtherType (Ethernet II); <1536 → Longitud (802.3). Payload mín 46 B (padding). MAC broadcast FF×6.
CRC: ceros a añadir = grado(G) = 3 (G tiene 4 bits). Resto de 3 bits.
Hub = 1 dominio de colisión; switch = 1 por puerto; broadcast lo separa el router.
💡 Por quéEl umbral 1536 distingue «longitud» de «tipo» sin ambigüedad porque el payload nunca pasa de 1500. El grado de G fija los ceros y el tamaño del resto.
✍️ Hazlo tú (datos para calcular)P14: divide 110101101000 / 1001 con XOR → resto de 3 bits. P10: 1536≥1536 → EtherType. P11: 40<1536 → Longitud (802.3).
💊 Píldora de examenFrontera 1536: ≥ EtherType, < Longitud. Ceros del CRC = grado de G = bits(G)−1. Switch = 1 dominio de colisión por puerto.
Solución comprobadaP9→b EtherType. P10→b EtherType (≥1536 → Ethernet II). P11→b Longitud (40<1536 → IEEE 802.3). P12→b 46 B (padding). P13→b FF:FF:FF:FF:FF:FF. P14→a CRC = 110 (verificado; el resto de verificación da 000). P15→b dividir toda la trama por G; resto 0 = correcta. P16→b hub repite a todos (1 dominio de colisión), switch reenvía por MAC y crea uno por puerto. P17→a un dominio de colisión por puerto, un solo dominio de broadcast (lo separa R1).

Nivel de redB3a. Bloque 3, subnetting (P18–P23): /25, /27, /29, máscaras

P18 hosts útiles de /25. P19 red de 192.168.60.100/25. P20 broadcast de esa red. P21 máscara de /29. P22 /24 dividido en /27: subredes y hosts. P23 broadcast de 10.55.130.210/27.

🔍 Cómo lo reconozcoIP con prefijo → método del bloque. «máscara de /n» → tabla. «/24 en /27» → 23 subredes.
📐 Método y fórmulasBits host = 32−n; bloque = 2(32−n). Red = múltiplo del bloque ≤ octeto. Broadcast = red+bloque−1. Hosts = bloque−2.
💡 Por quéEl prefijo separa red y host; restas 2. La máscara sale de poner a 1 los n primeros bits.
✍️ Hazlo tú (datos para calcular)P18: 27−2. P19: /25 → bloques 128; 100→0. P20: 0+127. P21: /29→11111000=248. P22: 23 subredes, 25−2 hosts. P23: bloque 32; 210→192; bcast 223.
💊 Píldora de examenBloques: /25→128, /27→32, /29→8. Máscaras: /25→.128, /27→.224, /29→.248. Hosts = bloque−2.
Solución comprobadaP18→b 126. P19→a 192.168.60.0 (100 cae en el bloque 0–127). P20→b 192.168.60.127. P21→d 255.255.255.248. P22→a 8 subredes de 30 hosts. P23→b 10.55.130.223 (red .192, bloque 32). Todo verificado con ipaddress. (Nota menor: en las SOLUCIONES oficiales el comentario del distractor de P23 sale con un texto confuso sobre «.207»; la respuesta correcta es .223 y es la que está marcada.)

Nivel de redB3b. Bloque 3, VLSM y rutas (P24–P27): 500 hosts, /23, longest prefix

P24 VLSM en 10.80.0.0/22, LAN1 500 hosts → prefijo. P25 red de LAN2 (200 hosts, /24) tras LAN1 (/23). P26 longest-prefix-match para 172.31.4.20 entre /16, /24 y /0. P27 qué es el next hop.

🔍 Cómo lo reconozco«500 hosts → prefijo» → menor /n con 2host−2 ≥ 500. «varias rutas» → longest prefix. «next hop» → IP vecina.
📐 Método y fórmulasPrefijo: 29−2 = 510 ≥ 500 → /23. VLSM mayor a menor: LAN1 /23 ocupa 10.80.0.0–10.80.1.255; LAN2 empieza en la siguiente libre (10.80.2.0). Longest prefix match: gana /24. Next hop = IP del vecino.
💡 Por quéEl /23 da 510 hosts (basta para 500); el /24 solo 254. La siguiente subred arranca justo tras el bloque anterior. El prefijo más largo describe la ruta más concreta.
✍️ Hazlo tú (datos para calcular)P24: 29−2 = 510 ≥ 502. P25: LAN1 /23 = 10.80.0.0–1.255 → LAN2 en 10.80.2.0. P26: /24. P27: IP vecina.
💊 Píldora de examen/23 = 510 hosts, /24 = 254, /25 = 126. VLSM de mayor a menor. Longest prefix match gana el más específico. Next hop = IP vecina, no MAC.
Solución comprobadaP24→b /23 (510 ≥ 500). P25→b 10.80.2.0 (LAN1 /23 ocupa .0.0–.1.255). P26→c 172.31.4.0/24 (más específico). P27→b la IP del router vecino alcanzable por la red de salida. (VLSM verificado con Python.)

Nivel de redB3c. Bloque 3, ARP/IP-MAC y fragmentación (P28–P33)

P28 MAC destino de la 1ª trama de PC-A hacia SRV. P29 IP destino durante la ida. P30 MAC e IP destino en el tramo R1→R2. P31 nº de ARP Request. P32–P33 datagrama TL=4000, hdr 20, MTU 620: nº de fragmentos y offset del último (u8, payload 600).

🔍 Cómo lo reconozco«MAC/IP por tramo» → IP fija, MAC del siguiente salto. «MTU<datagrama» → fragmentación.
📐 Método y fórmulasIP destino = destino final (no cambia). MAC = siguiente salto (gateway en la 1ª trama; R2 en el tramo R1→R2). ARP = 1 por tramo.
Payload = ⌊(MTU−20)/8⌋×8. Nº = ⌈(TL−20)/payload⌉. Offset último (u8) = (bytes previos)/8.
💡 Por quéLa IP viaja intacta extremo a extremo; solo cambian las MAC. Cada fragmento lleva su cabecera de 20 B; el offset va en unidades de 8.
✍️ Hazlo tú (datos para calcular)P32: payload = 620−20 = 600 (múltiplo de 8 ✓); datos = 3980; nº = ⌈3980/600⌉. P33: 6 fragmentos llenos → offset último = 6·600/8.
💊 Píldora de examen«IP destino = final; MAC = siguiente salto». 3 tramos = 3 ARP. Offset en unidades de 8 (bytes previos /8). El último fragmento tiene MF=0.
Solución comprobadaP28→b MAC de R1 (gateway). P29→c 172.31.4.20 (SRV, no cambia). P30→a MAC = R2, IP = 172.31.4.20 (no cambia). P31→c 3 ARP Request. P32→b datos 3980, payload 600, nº = ⌈6,63⌉ = 7. P33→a offset del 7º = 6·600/8 = 3600/8 = 450 (el último lleva 380 B). (Fragmentación verificada con Python.)

Nivel de transporteB4. Bloque 4 (P34–P41): TCP/UDP, MSS, BDP y SRTT

P34 por qué el SYN-ACK lleva Ack=3001 (ISN cliente 3000). P35 socket del cliente. P36 Ack del cliente tras 1500 B con Seq=8001. P37 UDP vs TCP. P38 MSS con MTU 1500. P39 segmentos para 50 000 B con MSS 1460. P40 BDP con 1 Gb/s y RTT 30 ms. P41 nuevo SRTT (SRTT 100, muestra 140, α=1/8).

🔍 Cómo lo reconozco«Ack tras SYN o datos» → siguiente byte esperado. «MSS» → MTU−40. «BDP» → BW×RTT. «SRTT» → suavizado.
📐 Método y fórmulasSYN consume 1 → Ack = ISN+1. Ack de datos = Seq + Len. MSS = MTU−40. Segmentos = ⌈datos/MSS⌉. BDP = BW·RTT /8. SRTT = (1−α)·SRTT + α·muestra.
💡 Por quéEl Ack anuncia el próximo byte esperado. UDP no tiene handshake ni Seq/Ack. El BDP mide los bytes en vuelo. El SRTT suaviza el RTT.
✍️ Hazlo tú (datos para calcular)P36: 8001+1500. P38: 1500−40. P39: ⌈50000/1460⌉. P40: 1e9·0,03/8. P41: ⅞·100 + ⅛·140.
💊 Píldora de examenMSS = MTU−40. BDP en bytes: /8. Ack = siguiente byte esperado. SYN/FIN cuentan 1.
Solución comprobadaP34→a confirma ISN+1 (SYN consume 1). P35→b 192.168.60.100:50210. P36→c 8001+1500 = 9501. P37→b UDP sin conexión ni Seq/Ack. P38→c 1460 B. P39→c ⌈50000/1460⌉ = ⌈34,25⌉ = 35 (último 360 B). P40→a 1e9·0,03/8 = 3 750 000 B. P41→a ⅞·100 + ⅛·140 = 105 ms. (Verificado con Python.)

EnrutamientoB5. Bloque 5 (P42–P45): RIP, métrica, split horizon e infinito

P42 Red Z directa en R1: métrica con que la conoce R4. P43 métrica de RIP. P44 regla del split horizon. P45 valor de «infinito».

🔍 Cómo lo reconozcoCadena + saltos → RIP. «regla anti-bucles» → split horizon.
📐 Método y fórmulasMétrica RIP = nº de saltos; suma 1 por router. Split horizon: no anuncies una ruta por la interfaz por la que la aprendiste. Infinito = 16.
💡 Por quéRed directa en R1 → R2:1, R3:2, R4:3. El límite 16 acota el count-to-infinity.
✍️ Hazlo tú (datos para calcular)P42: R1→R4 = 3 saltos. P43: hop count. P44: no devolver la ruta al que la enseñó. P45: 16.
💊 Píldora de examenSuma 1 por salto. Infinito=16, máx. 15. Split horizon = no reanunciar al vecino origen. RIP sobre UDP/520 cada 30 s.
Solución comprobadaP42→c 3 saltos (R2:1, R3:2, R4:3). P43→a número de saltos. P44→b no anunciar a un vecino una ruta aprendida de ese vecino. P45→b 16.