Imprimir ficha del alumnado Ver soluciones

Soluciones para docentes

Construye pequeños programas

Recoge cuatro tipos de evidencia: predicción del estado relevante; comportamiento en casos variados, incluidos los límites; explicación apoyada en la traza y el estado; y corrección razonada de una discrepancia. Valora cada aspecto como inicial, con apoyo o autónomo, en papel o mediante el proceso aprobado del centro. Superar un reto demuestra un comportamiento de la máquina, no la autoría ni un dominio completo. Acepta programas correctos equivalentes; las soluciones públicas son modelos, no las únicas respuestas posibles.

Material didáctico público. Las soluciones son ejemplos; otros programas correctos equivalentes pueden superar las comprobaciones.

28. Un pequeño juego de aciertos

Construye un juego de tres rondas con estado guardado y puntuación.

Abrir esta lección →

1. Predecir y trazar

Antes de ejecutar el programa de prueba, predice su salida y traza las tres primeras instrucciones ejecutadas. Sigue los registros, indicadores o memoria relevantes. Después avanza paso a paso para comparar.

STORE 5 200
LOAD [200] R1
LOAD 0 R2
LOOP 3
INPUT
CMP R1
JUMP_IF_ZERO hit
JUMP next
hit: LOAD R2
ADD 1
COPY R0 R2
next: NOP
RETURN
LOAD R2
STORE 201
PRINT
HALT

Añadir entradas a la cola: 5, 2, 5

Inicializar memoria: 200: 5

Solución de la predicción

Salida: 2

Instrucción	PC antes	PC después	Estado relevante	Salida
STORE	0	1	`{"registers":[0,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[200]}`	Ninguno
LOAD	1	2	`{"registers":[0,5,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[200],"memoryWrites":[]}`	Ninguno
LOAD	2	3	`{"registers":[0,5,0,0,0,0,0,0],"flags":{"zero":true,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Ninguno

2. Construir y comprobar

La memoria 200 contiene un byte objetivo. Lee exactamente tres intentos. Cuenta cuántos coinciden, guarda la puntuación en la memoria 201 e imprímela una vez.

Tipos de instrucción requeridos: INPUT, CMP, LOOP, STORE, JUMP_IF_ZERO

Ejemplo de solución del reto

LOAD [200] R1
LOAD 0 R2
LOOP 3
INPUT
CMP R1
JUMP_IF_ZERO hit
JUMP next
hit: LOAD R2
ADD 1
COPY R0 R2
next: NOP
RETURN
LOAD R2
STORE 201
PRINT
HALT

Casos reales del comprobador

Caso 1

Entrada: 5, 2, 5
Memoria inicial: 200: 5
Salida esperada: 2
Memoria final esperada: 200: 5, 201: 2
Lecturas de memoria requeridas: 200

Caso 2

Entrada: 1, 2, 3
Memoria inicial: 200: 9
Salida esperada: 0
Memoria final esperada: 200: 9, 201: 0
Lecturas de memoria requeridas: 200

Caso 3

Entrada: 0, 0, 0
Memoria inicial: 200: 0
Salida esperada: 3
Memoria final esperada: 200: 0, 201: 3
Lecturas de memoria requeridas: 200

Caso 4

Entrada: 17, 1, 2
Memoria inicial: 200: 17
Salida esperada: 1
Memoria final esperada: 200: 17, 201: 1
Lecturas de memoria requeridas: 200

3. Explicar la máquina

¿Qué cambia con un intento correcto y con uno incorrecto?

Razonamiento y nota docente

La puntuación aumenta solo en igualdad; el objetivo permanece como dato de la regla. Tres intentos producen una puntuación numérica.

29. Una utilidad de búfer con pila

Combina entrada, bucles, pila y almacenamiento por índices.

Abrir esta lección →

1. Predecir y trazar

LOAD 3 R3
LOAD 10
PUSH
LOAD 20
PUSH
LOAD 30
PUSH
LOAD 0 R1
LOOP R3
POP
STORE R1
PRINT
LOAD R1
ADD 1
COPY R0 R1
RETURN
HALT

Añadir entradas a la cola: Ninguno

Inicializar memoria: Todos los bytes empiezan en cero

Solución de la predicción

Salida: 30, 20, 10

Instrucción	PC antes	PC después	R0 antes	R0 después	Estado relevante	Salida
LOAD	0	1	0	0	`{"registers":[0,0,0,3,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Ninguno
LOAD	1	2	0	10	`{"registers":[10,0,0,3,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Ninguno
PUSH	2	3	10	10	`{"registers":[10,0,0,3,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[10],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Ninguno

2. Construir y comprobar

Lee N (0–5) y después exactamente N bytes. Usa la pila de datos para invertirlos. Imprime la secuencia invertida y guárdala a partir de la dirección de memoria 0.

Tipos de instrucción requeridos: INPUT, LOOP, PUSH, POP, STORE

Ejemplo de solución del reto

INPUT
COPY R0 R3
LOOP R3
INPUT
PUSH
RETURN
LOAD 0 R1
LOOP R3
POP
STORE R1
PRINT
LOAD R1
ADD 1
COPY R0 R1
RETURN
HALT

Casos reales del comprobador

Caso 1

Entrada: 0
Memoria inicial: Todos los bytes empiezan en cero
Salida esperada: Ninguno
Memoria final esperada: 0: 0

Caso 2

Entrada: 1, 7
Memoria inicial: Todos los bytes empiezan en cero
Salida esperada: 7
Memoria final esperada: 0: 7

Caso 3

Entrada: 4, 1, 2, 3, 4
Memoria inicial: Todos los bytes empiezan en cero
Salida esperada: 4, 3, 2, 1
Memoria final esperada: 0: 4, 1: 3, 2: 2, 3: 1

Caso 4

Entrada: 3, 0, 255, 8
Memoria inicial: Todos los bytes empiezan en cero
Salida esperada: 8, 255, 0
Memoria final esperada: 0: 8, 1: 255, 2: 0

3. Explicar la máquina

¿Por qué usar dos fases y qué debe hacer N = 0?

Razonamiento y nota docente

Primero recoge y apila; después extrae, escribe e imprime al revés. Cero repeticiones no producen salida ni escrituras accidentales.

30. Tu propio minisistema operativo

Despacha trabajos en cola a servicios reutilizables y registra sus resultados.

Abrir esta lección →

1. Predecir y trazar

LOAD 4
CALL double
STORE 64
PRINT
LOAD 3
CALL square
STORE 65
PRINT
HALT
double: MUL 2
RETURN
square: MUL R0
RETURN

Añadir entradas a la cola: Ninguno

Inicializar memoria: Todos los bytes empiezan en cero

Solución de la predicción

Salida: 8, 9

Instrucción	PC antes	PC después	R0 antes	R0 después	Estado relevante	Salida
LOAD	0	1	0	4	`{"registers":[4,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":255,"stack":[],"callStack":[],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Ninguno
CALL	1	9	4	4	`{"registers":[4,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[],"callStack":[2],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Ninguno
MUL	9	10	4	8	`{"registers":[8,0,0,0,0,0,0,0],"flags":{"zero":false,"negative":false,"overflow":false},"sp":254,"stack":[],"callStack":[2],"loopStack":[],"memoryReads":[],"memoryWrites":[]}`	Ninguno

2. Construir y comprobar

Lee N (0–3) y después N pares (operación, valor). La operación 0 duplica, la 1 eleva al cuadrado y la 2 suma uno. Despacha mediante subrutinas CALL. Imprime cada resultado completo y guarda su byte en las direcciones 64, 65, … en el orden de los trabajos.

Tipos de instrucción requeridos: INPUT, LOOP, CALL, CMP, STORE, RETURN

Ejemplo de solución del reto

INPUT
COPY R0 R3
LOAD 64 R2
LOOP R3
INPUT
COPY R0 R4
INPUT
COPY R0 R1
LOAD R4
CMP 0
JUMP_IF_ZERO doubleJob
CMP 1
JUMP_IF_ZERO squareJob
LOAD R1
CALL increment
JUMP finish
doubleJob: LOAD R1
CALL double
JUMP finish
squareJob: LOAD R1
CALL square
finish: STORE R2
PRINT
LOAD R2
ADD 1
COPY R0 R2
RETURN
HALT
double: MUL 2
RETURN
square: MUL R0
RETURN
increment: ADD 1
RETURN

Casos reales del comprobador

Caso 1

Entrada: 3, 0, 4, 1, 3, 2, 9
Memoria inicial: Todos los bytes empiezan en cero
Salida esperada: 8, 9, 10
Memoria final esperada: 64: 8, 65: 9, 66: 10

Caso 2

Entrada: 2, 1, -2, 0, 0
Memoria inicial: Todos los bytes empiezan en cero
Salida esperada: 4, 0
Memoria final esperada: 64: 4, 65: 0

Caso 3

Entrada: 0
Memoria inicial: Todos los bytes empiezan en cero
Salida esperada: Ninguno
Memoria final esperada: 64: 0

Caso 4

Entrada: 3, 2, 255, 0, 130, 1, 16
Memoria inicial: Todos los bytes empiezan en cero
Salida esperada: 256, 260, 256
Memoria final esperada: 64: 0, 65: 4, 66: 0

3. Explicar la máquina

¿Por qué puede una salida 260 coexistir con el byte de historial 4?

Razonamiento y nota docente

R0 conserva el entero seguro completo; STORE guarda su byte menos significativo. Los servicios ocultan detalles de cálculo, no la regla de despacho.