Python expl

def dibujar_triangulo_recto(nivel): print(f"Nivel {nivel}")

• Esta línea define una función llamada `dibujar_triangulo_recto` que toma un argumento `nivel`. La función imprime "Nivel X", donde X es el valor del argumento `nivel` que se pasa cuando se llama a la función.

for i in range(1, nivel + 1):

print('*' * i)

• Este bloque de código utiliza un bucle `for` para iterar desde 1 hasta `nivel + 1`. Dentro del bucle, se utiliza `print('*' * i)` para imprimir una cadena de asteriscos (`*`) multiplicada por el valor actual de `i`. Esto crea el patrón de un triángulo recto con la altura especificada por el usuario.

def dibujar_triangulo_isosceles(nivel): print(f"Nivel {nivel}")

• Similar a la función anterior, esta línea define una función llamada `dibujar_triangulo_isosceles` que también toma un argumento `nivel`. La función imprime "Nivel X", donde X es el valor del argumento `nivel` que se pasa cuando se llama a la función.

for i in range(1, nivel + 1):

espacio = ' ' * (nivel - i) asteriscos = '*' * (2 * i - 1) print(espacio + asteriscos)

• En este bloque de código, se utiliza un bucle `for` para iterar desde 1 hasta `nivel + 1`. En cada iteración, se calcula la cantidad de espacios (`espacio`) y asteriscos (`asteriscos`) necesarios para formar una fila del triángulo isósceles.
• `espacio` se calcula como una cadena de espacios en blanco multiplicada por la diferencia entre

`nivel` y `i`. Esto crea el espacio en blanco necesario en la parte izquierda de cada fila.

• `asteriscos` se calcula como una cadena de asteriscos multiplicada por `(2 * i - 1)`. Esto crea la parte central del triángulo isósceles con el número correcto de asteriscos en cada fila.
• Finalmente, se imprime `espacio + asteriscos`, que combina el espacio en blanco y los asteriscos para formar cada fila del triángulo isósceles.

El bucle `while` en el programa principal muestra un menú al usuario, recopila su elección y ejecuta la función correspondiente (rectángulo o triángulo isósceles) según la elección del usuario. También permite al usuario salir del programa si elige la opción '3'.

1. `let numFilas, numColumnas;`: Esto declara dos variables `numFilas` y `numColumnas` utilizando la palabra clave `let`. Estas variables se usarán para almacenar el número de filas y columnas en la matriz del juego.

1. `let matriz = [];`: Aquí, se declara una variable `matriz` e inicializa como un arreglo vacío (`[]`). Esta variable se utilizará para almacenar los valores ocultos en la matriz del juego.

1. `let intentos = 0;`: La variable `intentos` se inicia en 0 utilizando `let`. Esta variable llevará un registro del número de intentos que ha realizado el usuario para adivinar los pares.

1. `const maxIntentos = 10;`: La constante `maxIntentos` se inicializa con el valor 10 utilizando

`const`. Esta constante representa el número máximo de intentos permitidos en el juego y no cambiará durante la ejecución del programa.

1. `let paresEncontrados = 0;`: La variable `paresEncontrados` se inicia en 0 utilizando `let`. Esta variable llevará un registro del número de pares que ha encontrado el usuario en el juego.

En resumen, este bloque de código establece las variables que se utilizarán para llevar un registro de la configuración del juego, los intentos del usuario y el progreso en la búsqueda de pares. Estas variables son esenciales para el funcionamiento del juego y se utilizan en diversas partes del código para controlar el flujo del juego.

function crearMatriz() {

// Obtenemos el valor ingresado en el primer campo de entrada y lo convertimos a un número entero.

const entrada1 = parseInt(document.getElementById("entrada1").value);

// Obtenemos el valor ingresado en el segundo campo de entrada y lo convertimos a un número entero.

const entrada2 = parseInt(document.getElementById("entrada2").value);

// Validamos si alguno de los valores ingresados no es un número o está fuera del rango permitido.

if (isNaN(entrada1) || isNaN(entrada2) || entrada1 > 5 || entrada2 > 5 || entrada1 < 1 || entrada2 < 1) {

// Si la validación no se cumple, mostramos una alerta al usuario. alert("Ingresa dos números enteros entre 1 y 5.");

return; // Salimos de la función y no continuamos con la creación de la matriz.

}

// Asignamos los valores ingresados a las variables globales numFilas y numColumnas. numFilas = entrada1;

numColumnas = entrada2;

// Reiniciamos la matriz como un arreglo vacío y el contador de pares encontrados. matriz = [];

paresEncontrados = 0;

// Inicializamos una variable HTML para construir la tabla que representa la matriz en la página. let html = "<table>";

// Comenzamos a construir la tabla con un bucle que recorre las filas. for (let i = 0; i <= numFilas; i++) {

// Inicializamos un arreglo para representar una fila de la matriz. matriz[i] = [];

// Agregamos una fila a la tabla. html += "<tr>";

// Dentro de esta fila, recorremos las columnas. for (let j = 0; j <= numColumnas; j++) {

// En la primera fila y primera columna, agregamos una celda vacía para las etiquetas de fila y columna.

if (i === 0 && j === 0) { html += "<th></th>";

} else if (i === 0) {

// En la primera fila, agregamos encabezados de columna con letras A, B, C, etc. html += `<th>${String.fromCharCode(64 + j)}</th>`;

} else if (j === 0) {

// En la primera columna, agregamos encabezados de fila con números 1, 2, 3, etc. html += `<th>${i}</th>`;

} else {

// En las celdas restantes, inicializamos la matriz con valores ocultos en 0. matriz[i][j] = 0;

// Creamos celdas de entrada de texto deshabilitadas para representar los valores

ocultos.

html += `<td><input type="text" id="${String.fromCharCode(64 + j)}${i}" value="" readonly></td>`;

}

}

// Cerramos la fila actual. html += "</tr>";

}

// Luego de crear la estructura básica de la tabla, generamos pares aleatorios en la matriz. for (let n = 1; n <= (numFilas * numColumnas) / 2; n++) {

asignarParesAleatorios(n);

}

// Cerramos la tabla y la insertamos en el elemento con el ID "tablaMatriz" en la página. html += "</table>";

document.getElementById("tablaMatriz").innerHTML = html;

// Mostramos la sección de intentos y ocultamos el botón de reinicio. document.getElementById("intentos").style.display = "block"; document.getElementById("btnReiniciar").style.display = "none";

}

[pic 1]

function asignarParesAleatorios(valor) { let paresAsignados = 0;

while (paresAsignados < 2) {

const fila = Math.floor(Math.random() * numFilas) + 1;

const columna = Math.floor(Math.random() * numColumnas) + 1; if (matriz[fila][columna] === 0) {

matriz[fila][columna] = valor; paresAsignados++;

}

}

}

function asignarParesAleatorios(valor) {

// Inicializamos una variable para llevar la cuenta de pares asignados. let paresAsignados = 0;

// Utilizamos un bucle while para asignar dos valores con el mismo 'valor' a la matriz. while (paresAsignados < 2) {

// Generamos números aleatorios para seleccionar una fila y una columna en la matriz. const fila = Math.floor(Math.random() * numFilas) + 1;

const columna = Math.floor(Math.random() * numColumnas) + 1;

// Verificamos si la celda seleccionada en la matriz tiene un valor oculto igual a 0. if (matriz[fila][columna] === 0) {

// Si es 0, asignamos el 'valor' proporcionado a esa celda. matriz[fila][columna] = valor;

// Incrementamos el contador de pares asignados. paresAsignados++;

}

}

}

[pic 2]

function intentar() {

const celda1 = document.getElementById("entradaIntento1").value; const celda2 = document.getElementById("entradaIntento2").value;

if (!esReferenciaCeldaValida(celda1) || !esReferenciaCeldaValida(celda2)) { alert("Ingresa referencias de celdas válidas (por ejemplo, A2).");

return;

}

const fila1 = parseInt(celda1.substring(1)); const columna1 = celda1.charCodeAt(0) - 64; const fila2 = parseInt(celda2.substring(1)); const columna2 = celda2.charCodeAt(0) - 64;[pic 3][pic 4][pic 5]

...