14 de febrero de 2022

Ingeniería en Tecnologías de la Información

Inteligencia artificial

Actividad 3: Práctica Desarrollo de Juego 3 en raya (Gato)

Eduardo Valencia Gonzalez

U184062Z0077
Python

# -*- coding: utf-8 -*- //línea de formato para el reconocimiento

correcto de los comandos
import random //importamos la librería random para números aleatorios

def dibujatablero(tablero): //Definimos la clase “dibujatablero” que

imprime en consola el tablero de gato
//"tablero" es una lista de 10 caracteres que representa al tablero
print(' ' + tablero[7] + ' | ' + tablero[8] + ' | ' + tablero[9])
print('-----------')
print(' ' + tablero[4] + ' | ' + tablero[5] + ' | ' + tablero[6])
print('-----------')
print(' ' + tablero[1] + ' | ' + tablero[2] + ' | ' + tablero[3])

def inputPlayerLetter(): //Definimos la clase “inputPlayerLetter” que

permite elegir al jugador que letra desea usar (X o O)
letra = '' //Definimos la variable letra de tipo cadena que
almacena la elección del jugador
while not(letra == 'X' or letra == 'O'): //Mientras la variable
letra no sea X o O se ejecuta:
print('Quieres ser X o O') //Imprimimos en consola una
pregunta para la selección del jugador
letra = input().upper() //Añadimos la entrada de usuario en
mayúsculas a la variable letra
if letra == 'X': //Si letra equivale a X
return ['X', 'O'] //Retornamos X como letra para jugador y O
para computadora
else: //De lo contrario
return ['O', 'X'] //Retornamos O como letra del jugador y X
para computadora

def quienempieza(): //Definimos la clase “quienempieza” que elige al

azar si inicia el jugador o la computadora
if random.randint(0, 1) == 0: //si la elección aleatoria en un
rango de 0 a 1 es igual a 0
 return 'computadora' //Retornamos la cadena computadora
como quien va a iniciar
else: //De lo contrario
return 'jugador' //Retornamos la cadena jugador como quien
debe iniciar

def repitejuego(): //Esta función regresa true si el jugador quiere

jugar de nuevo, de otra forma regresa false
print('Quieres jugar de nuevo? (Si o No)') //se pregunta al
jugador en consola si es que quiere jugar una nueva partida
return input().lower().startswith('s') //regresa valor de
“verdadero” si el jugador ingresa Si

def makeMove(board, letter, move): //Definimos la función makeMove

que realiza los movimientos tanto del usuario como de la computadora y
recibe como parámetros el tablero, la letra a ingresar y la posición
board[move] = letter //Cambia el valor en el tablero con la letra
de quien esta en turno en la posición seleccionada

def isWinner(bo, le): //definimos la función isWinner que verifica si es

que se ha llegado a una posición ganadora (3 en raya)
return ((bo[7] == le and bo[8] == le and bo[9] == le) or
(bo[4] == le and bo[5] == le and bo[6] == le) or
(bo[1] == le and bo[2] == le and bo[3] == le) or
(bo[7] == le and bo[4] == le and bo[1] == le) or
(bo[8] == le and bo[5] == le and bo[2] == le) or
(bo[9] == le and bo[6] == le and bo[3] == le) or
(bo[7] == le and bo[5] == le and bo[3] == le) or
(bo[9] == le and bo[5] == le and bo[1] == le))
//Regresa el valor de verdadero si hay tres letras iguales en
horizontal, vertical o diagonal
def getBoardCopy(board): //Iniciamos la clase getBoardCopy que crea
una copioa del tablero original para realizar las pruebas de la computadora
y determinar el mejor movimiento
dupeBoard = [] //Declaramos el nuevo arreglo que guardara la copia
 for i in board: //Para cada elemento en el tablero original
dupeBoard.append(i) //Lo añadimos a la copia creada
return dupeBoard //Retornamos el arreglo recién creado

def isSpaceFree(board, move): //Función isSpaceFree que regresa

verdadero si el movimiento no está ocupado en el tablero
return board[move] == ' ' //Verifica que el espacio del tablero
este vacío y regresa verdadero

def getPlayerMove(board): //Iniciamos la clase que permite al jugador

decidir su próximo movimiento
move = ' ' //Variable de tipo cadena llamada move que guarda el
movimiento seleccionado
while move not in '1 2 3 4 5 6 7 8 9'.split() or not isSpaceFree(board,
int(move)): //Mientras el movimiento deseado no este entre el 1 y el
9 o no sea un espacio vacio
print('Cual es tu siguiente movimiento? (1-9)') //Pedimos en
consola el siguiente movimiento del jugador
move = input() //Asignamos el valor que ingrese a la
variable move
return int(move) //Regresamos move convertido en entero

def chooseRandomMoveFromList(board, movesList): //Definimos la

función que decide el próximo movimiento de la computadora en base al
tablero actual y recibe al tablero y una lista de movimientos
possibleMoves = [] //Creamos un arreglo que almacena los
movimiento posibles dependiendo a la situación
for i in movesList: //para cada elemento en la lista de elementos
if isSpaceFree(board, i): //Si la posición esta disponible
en el teclado
possibleMoves.append(i) //La añadimos a la lista de
movimientos posibles

if len(possibleMoves) != 0: //Si la lista de posibles movimientos

no está vacia
return random.choice(possibleMoves) //Regresamos una elemento
aleatorio de la lista de posibles movimientos
 else: //De lo contrario
return None //No retornamos ningún valor

def movimientocomputadora(board, computerLetter): //En una copia del

tablero, la computadora verifica los movimientos para regresar el adecuado
y recibe el tablero y la letra del computador
if computerLetter == 'X': //Si la letra del computador es X
playerLetter = 'O' //El jugador tiene la letra O
else: //De lo contrario
playerLetter = 'X' //El jugador tiene la letra X

//Este es el algoritmo de nuestro gato para IA:

//Primero se checa si la computadora puede ganar en el siguiente
movimiento
for i in range(1, 10): //Ciclo for del 1 al 10
copy = getBoardCopy(board) //Generamos una copia del teclado
y la guardamos en un nuevo arreglo
if isSpaceFree(copy, i): //si hay un espacio libre en la
posición “i” de la copia del tablero
makeMove(copy, computerLetter, i) //Colocamos la letra del
computador en dicha posición
if isWinner(copy, computerLetter): //Si con ello la
computadora gana
return i //Regresamos el valor de i

//Verifica si el jugador puede ganar en el siguiente turno y lo bloquea

for i in range(1, 10): //Ciclo for del 1 al 10
copy = getBoardCopy(board) //Copiamos el tablero
if isSpaceFree(copy, i): //Si el espacio “i” esta libre
en la copia
makeMove(copy, playerLetter, i) //Realizamos el movimiento
en dicha posición con la letra del jugador (simulamos sus posibles jugadas)
if isWinner(copy, playerLetter): //si puede ganar con dicho
movimiento
return i //Regresamos el valor de i
 //Toma una de las esquinas en caso de que esten vacias
move = chooseRandomMoveFromList(board, [1, 3, 7, 9]) //La variable
move toma un valor aleatorio de las posiciones de las esquinas
if move != None: //Si movimiento no está vacio
return move //Regresamos el movimiento

//Toma el centro en caso de que este vacio

if isSpaceFree(board, 5): //Si la posición 5 esta vacia
return 5 //Regresamos el valor de 5

//Mueve en uno de los laterales

return chooseRandomMoveFromList(board, [2, 4, 6, 8]) //Elegimos una
posición aleatoria de los laterales

def isBoardFull(board): //Función que verifica si el tablera está

lleno y regresa True, sino regresa False
for i in range(1, 10): //Ciclo for del 1 al 10
if isSpaceFree(board, i): //si el espacio i está vacío
return False //Entonces aún hay espacios vacíos y regresa
un valor de falso
return True //De lo contrario regresa verdadero

print('Bienvenido al juego del Gato!') //Iniciamos el juego con un

mensaje de bienvenida

while True: //mientras sea verdadero

theBoard = [' '] * 10 //Limpiamos/creamos el tablero
playerLetter, computerLetter = inputPlayerLetter(); //solicitamos
las letras mediante la función inputPlayerLetter y las guardamos en
variables que indiquen a quien pertenecen
turn = quienempieza(); //Llamamos la función quien empieza para
seleccionar turno aleatorio
print(turn + ' sale primero.') //Imprimimos quien va a iniciar
 gameIsPlaying = True //Declaramos una variable booleana para saber
si seguimos jugando y la iniciamos con verdadero
while gameIsPlaying: //Mientras sigamos jugando
if turn == 'jugador': //Si el turno es del jugador
//Turno del jugador
dibujatablero(theBoard) //Dibujamos el tablero
move = getPlayerMove(theBoard) //Guardamos el movimiento
ingresado por el jugador en la variable move
makeMove(theBoard, playerLetter, move) //Realizamos el
movimiento en el tablero con la letra del jugador
if isWinner(theBoard, playerLetter): //Si el jugador gano
dibujatablero(theBoard) //Dibujamos el tablero
print('Enhorabuena! Ganaste!') //E indicamos que el
jugador fue el vencedor
gameIsPlaying = False //Finalizamos el juego y salemos
del ciclo While
else: //de lo contrario (el jugador no ha ganado)
if isBoardFull(theBoard): //Si el tablero esta lleno
dibujatablero(theBoard) //Dibujamos el tablero
print('Empate!') //Y declaramos un empate
break //Descanso (evita que sigan las
instrucciones)
else: //De lo contrario (el jugador no ha ganado y el
tablero no esta lleno)
turn = 'computadora' //Pasamos el turno a la
computadora

else: //De lo contrario (el turno es de la computadora)

//Turno de la computadora
move = movimientocomputadora(theBoard, computerLetter)
//El movimiento se define con la función de la IA
makeMove(theBoard, computerLetter, move) //Realizamos
el movimiento que regreso la función con la letra de la computadora
if isWinner(theBoard, computerLetter): //Si la computadora
gano
 dibujatablero(theBoard) //Dibujamos el tablero
print('La computadora ha jugado contigo!, Perdiste.')
//E indicamos al jugador que perdió (y nos burlamos)
gameIsPlaying = False //Termina el juego actual
else: //De lo contrario (la computadora no ha ganado)
if isBoardFull(theBoard): //Si el tablero esta lleno
dibujatablero(theBoard) //Dibujamos el tablero
print('Empate!') //Declaramos el empate
break //Detenemos las instrucciones
else: //De lo contrario (la computadora no ha ganado y
el tablero no esta lleno)
turn = 'jugador' //Pasamos el turno al jugador
if not repitejuego(): //Si el usuario decide no repetir el juego
break //Detenemos el ciclo While que inicio el juego
Ejecución Python

Si ejecutamos este programa desde el IDE de Apache NetBeans vemos de manera

inmediata el mensaje de bienvenida y damos al usuario la opción de decidir la letra que
desea utilizar, después de ello se nos muestra quien tendrá el primer turno, si es la
computadora de inmediato se imprime el tablero con el movimiento de la computadora y la
opción para realizar nuestro movimiento. Si es el jugador entonces nos pide el movimiento
directamente.

En el caso presentado en las capturas podemos ver los primeros pasos aquí descritos, el
mensaje de bienvenida y la selección de una letra.

La computadora inicia primero por lo que la primera impresión del tablero es el movimiento
del ordenador.

Finalmente, en este caso, el usuario pierde debido a la capacidad de la maquina y la ligera

ventaja que se obtiene al tener el primer turno.

Terminada esta ronda se nos da la opción de jugar otra más, si damos si vuelve la pregunta
de que letra deseamos utilizar.
Java

package MinMax; //Paquete de la clase

import java.util.*; //Importa todas las librerias para el programa
public class Gato { //Clase
public void dibujaTablero(ArrayList tablero){ //Función que
imprime en consola el tablero en base a una variable ArrayList
System.out.println(" " + tablero.get(7) + " | " + tablero.get(8)
+ " | " + tablero.get(9));
System.out.println("-----------");
System.out.println(" " + tablero.get(4) + " | " + tablero.get(5)
+ " | " + tablero.get(6));
System.out.println("-----------");
System.out.println(" " + tablero.get(1) + " | " + tablero.get(2)
+ " | " + tablero.get(3));
}
public String[] letraParaJugador(){ //Función “letraParaJugador” que
devuelve un arreglo de tipo cadena para definir las letras de computadora
y jugador
String[] letras = new String[2]; //Arreglo tipo cadena “leras” a
retornar
Scanner sc = new Scanner(System.in); //Clase Scanner para
ingresar valores
String letra = ""; //Variable tipo cadena que almacena la
selección del jugador
while (!letra.equals("X") && !letra.equals("O")){ //Si la
variable letra no es X ni O
System.out.println("Quieres ser X o O?"); //Imprimimos
la pregunta para el usuario
letra = sc.nextLine().toUpperCase(); //Almacenamos su
entrada en la variable letra
}
if (letra.equals("X")) { //Si letra equivale a X
letras[0] = "X"; //Asignamos X en primer lugar del
arreglo
letras[1] = "O"; //Y O en segundo lugar
 }else{ //De lo contrario
letras[0] = "O"; //Asignamos O en primer lugar
letras[1] = "X"; //Y X en el segundo lugar
}
return letras; //Regresamos el arreglo letras
}
public String quienEmpieza(){ //Función que define de manera
aleatoria quien inicia y lo devuelve como cadena
String primero = ""; //Variable tipo cadena que almacena
quien deberá iniciar
Random turno = new Random(); //Clase random para generar
números aleatorios
int t = turno.nextInt((2-0)); //Elegimos un numero aleatorio
que puede ser 0 o 1
if (t == 0) { //Si el numero elegido es 0
primero = "computadora"; //La computadora inicia
}else{ //De lo contrario
primero = "jugador"; //inicia el jugador
}
return primero; //Retornamos la cadena creada
}

public boolean repiteJuego(){ //Función que regresa un valor

booleano
Scanner sc = new Scanner(System.in); //Clase tipo Scanner
System.out.println("Quieres jugar de nuevo? (Si o No)");
//Preguntamos al usuario si quiere una nueva partida
String d = sc.nextLine().toLowerCase(); //Tomamos la entrada
del usuario en minúsculas
return d.startsWith("s"); //Y regresamos verdadero si su entrada
inicia con “s”
}
 public void hacerMovimiento(ArrayList tablero, String letra, int
movimiento){ //Función que realiza los movimientos del usuario y la
cadena y recibe como parámetros el tablero, la letra y el lugar donde se
hará el movimiento
tablero.set(movimiento, letra); //Realizamos el movimiento con
las variables ingresadas
}

public boolean esGanador(ArrayList tablero, String letra){

//Variable que regresa un valor booleano y determina si es que la
letra ingresada ganó la partida (conecto 3 en raya)
return ((tablero.get(7).equals(letra) &&
tablero.get(8).equals(letra) && tablero.get(9).equals(letra)) ||
(tablero.get(4).equals(letra) &&
tablero.get(5).equals(letra) && tablero.get(6).equals(letra)) ||
(tablero.get(1).equals(letra) &&
tablero.get(2).equals(letra) && tablero.get(3).equals(letra)) ||
(tablero.get(7).equals(letra) &&
tablero.get(4).equals(letra) && tablero.get(1).equals(letra)) ||
(tablero.get(8).equals(letra) &&
tablero.get(5).equals(letra) && tablero.get(2).equals(letra)) ||
(tablero.get(9).equals(letra) &&
tablero.get(6).equals(letra) && tablero.get(3).equals(letra)) ||
(tablero.get(7).equals(letra) &&
tablero.get(5).equals(letra) && tablero.get(3).equals(letra)) ||
(tablero.get(9).equals(letra) &&
tablero.get(5).equals(letra) && tablero.get(1).equals(letra))
);
}

public ArrayList copiarTablero(ArrayList tablero){ //Función que

retorna un ArrayList y recibe otro como parámetro (copia el tablero
ingresado)
ArrayList tablero2 = new ArrayList(); //Definimos un nuevo
arreglo que será retornado
tablero2.addAll(tablero); //Añadimos todo lo del tablero
original al nuevo creado
return tablero2; //Regresamos el nuevo tablero
 }

public boolean espacioLibre(ArrayList tablero, int movimiento){

//Función que regresa un valor booleano y determina si la posición
ingresada esta vacia en el tablero ingresado
return tablero.get(movimiento).equals(" "); //Regresamos
verdadero si la posición del movimiento esta vacía sino regresa falso
}

public int movimientoJugador(ArrayList tablero){ //Función que

regresa una cadena indicando el movimiento del jugador en el tablero que
es ingresado
Scanner sc = new Scanner(System.in); //Clase Scanner
String movimiento = "0"; //Definimos movimiento como cadena y
otorgamos un O como valor
while (!"1 2 3 4 5 6 7 8 9".contains(movimiento)){
//Mientras movimiento no se encuentre entre 1 y 9
System.out.println("Cual es tu siguiente movimiento? (1-9)");
//Preguntamos el siguiente movimiento al jugador
movimiento = sc.nextLine(); //Guardamos el valor ingresado
por el usuario
}
return Integer.parseInt(movimiento); //Retornamos la variable
movimiento convertida en cadena
}

public int elegirMovimientoAleatorio(ArrayList tablero, int[]

listaMovimientos){ //Función que elige un movimiento aleatorio de la
maquina en base al tablero y un numero determinado de movimientos posibles
int movimiento = 0; //Iniciamos la variable a retornar
ArrayList posiblesMovimientos = new ArrayList(); //Creamos una
nueva lista que almacenara los posibles movimientos de la maquina
Random mov = new Random(); //Clase Random
for (int i = 0; i < listaMovimientos.length; i++) { //Ciclo
for desde 0 hasta la longitud de los movimientos ingresados en la funcion
if (espacioLibre(tablero, listaMovimientos[i])) { //Si el
espacio de la lista esta libre
 posiblesMovimientos.add(listaMovimientos[i]); //Lo
añadimos a los posibles movimientos
}
}
int m = mov.nextInt((posiblesMovimientos.size()-0 + 1) + 0);
//elegimos un movimiento aleatorio de nuestra lista
if (!posiblesMovimientos.isEmpty()) { //Si la lista no está vacia
movimiento =
Integer.parseInt(posiblesMovimientos.get(m).toString()); //Otorgamos el
valor aleatorio a la variable movimiento
}
return movimiento; //Retornamos la variable movimiento
}
public int movimientoComputadora(ArrayList tablero, String
letraComputadora){ //Función que determina la IA del sistema en base
a un tablero y la letra de la computadora
String letraJugador = ""; //Definimos la variable tipo cadena que
almacena la letra del jugador
int mov = 0; //Definimos la variable que será nuestro movimiento
elegido
if (letraComputadora.equals("X")) { //Si la letra de la
computadora es X
letraJugador = "O"; //La letra del jugador es O
}else{ //De lo contrario
letraJugador = "X"; //La letra del jugador es X
}
//Verifica si la computadora puede ganar en el siguiente movimiento
for (int i = 0; i < 10; i++) { //Ciclo for del 0 al 10
ArrayList copia = copiarTablero(tablero); //Copiamos el
tablero en una nueva lista
if (espacioLibre(copia, i)) { //Buscamos los espacios
libres en el tablero copia y en ellos
hacerMovimiento(copia, letraComputadora, i);
//Realizamos un movimiento con la letra del ordenador
if (esGanador(copia, letraComputadora)) { //Si con dicho
movimiento la computadora gana
 return i; //Retornamos el valor de I
}
}
}
//Verifica si el jugador puede ganar al siguiente movimiento y lo
bloquea
for (int i = 0; i < 10; i++) { //Ciclo for del 0 al 10
ArrayList copia = copiarTablero(tablero); //Copiamos el
tablero en una nueva lista
if (espacioLibre(copia, i)) { //Si el espacio i esta
libre
hacerMovimiento(copia, letraJugador, i); //Realizamos
un movimiento con la letra del jugador
if (esGanador(copia, letraJugador)) { //Si el jugador
gana con dicha jugada
return i; //Regresamos esa jugada como la próxima
del ordenador
}
}
}
int[] esquinas = {1, 3, 7, 9}; //Arreglo de tipo entero con las
esquinas del tablero
mov = elegirMovimientoAleatorio(tablero, esquinas);
//Elegimos un movimiento aleatorio mediante la función de dicho
nombre del arreglo recién creado
if (mov !=0) { //Si el movimiento no es en 0 (inexistente)
return mov; //Regresamos el valor de esa variable
}

if (espacioLibre(tablero, 5)) { //Si el espacio 5 esta vacio

return 5; //Retornamos el valor de 5
}

int[] laterales = {2, 4, 6, 8}; //Arreglo de tipo entero con los

laterales del tablero
 return elegirMovimientoAleatorio(tablero, laterales);
//Elegimos y retornamos un movimiento aleatorio mediante la función
de dicho nombre del arreglo recién creado
}

public boolean tableroLleno(ArrayList tablero){ //función que

devuelve un booleano y recibe un tablero como parametro
for (int i = 0; i < 10; i++) { //Ciclo for el 0 al 10
if (espacioLibre(tablero, i)) { //Si el espacio i esta
vacio
return false; //Regresamos un valor de falso
}
}
return true; //De lo contrario regresamos un valor de verdadero
}

public static void main(String[] args) { //Método main

System.out.println("Bienvenido al juego del Gato!");
//Imprimimos el mensaje de bienvenida
Gato objG = new Gato(); //Objeto de la clase para realizar los
llamados
while(true){ //Mientras sea verdadero
ArrayList elTablero = new ArrayList(); //Creamos el tablero
for (int i = 0; i < 10; i++) {
elTablero.add(" "); //Llenamos el tablero con espacios
vacios
}
String[] letras = objG.letraParaJugador(); //Lista letras que
contiene que letra usara el jugador y la computadora
String turno = objG.quienEmpieza(); //Variable cadena que
almacena quien tiene el turno
System.out.println(turno + " sale primero"); //Imprimimos
quien es que debe iniciar
boolean jugando = true; //Definimos una variable booleana en
verdadero que indica que estamos jugando
 while (jugando) { //Mientras jugando
if (turno.equals("jugador")) { //Si el turno es del
jugador
objG.dibujaTablero(elTablero); //Dibujamos el tablero
int mov = objG.movimientoJugador(elTablero);
//Preguntamos al jugador por su movimiento
objG.hacerMovimiento(elTablero, letras[0], mov);
//Realizamos el movimiento que indico el jugador

if (objG.esGanador(elTablero, letras[0])) { //Si el

jugador es el ganador
objG.dibujaTablero(elTablero); //Dibujamos el
tablero
System.out.println("Enhorabuena! Ganaste!");
//E indicamos que el fue el ganador
jugando = false; //Terminamos el primer juego
}else{ //De lo contrario (el jugador no ha ganado)
if (objG.tableroLleno(elTablero)) { //Si el tablero
esta lleno
objG.dibujaTablero(elTablero); //Dibujamos el
tablero
System.out.println("Empate!"); //Indicamos un
empate
break; //Pausamos las instrucciones
}else{ //De lo sontrario (no ha ganado ni hay
empate)
turno = "computadora"; //Pasamos el turno a
la computadora
}
}

}else{ //De lo contrario (turno de la computadora)

int mov = objG.movimientoComputadora(elTablero,
letras[1]); //Definimos el movimiento de la computadora
objG.hacerMovimiento(elTablero, letras[1], mov);
//Realizamos el movimiento de la computadora
 if (objG.esGanador(elTablero, letras[1])) { //Si la
computadora gano
objG.dibujaTablero(elTablero); //Dibujamos el
tablero
System.out.println("La computadora ha jugado contigo!
Perdiste."); //Indicamos al jugador que perdió y nos burlamos
jugando = false; //Termina la ronda
}else{ //De lo contrario (la computadora no ha ganado)
if (objG.tableroLleno(elTablero)) { //Verificamos
si el tablero esta lleno
objG.dibujaTablero(elTablero); //Dibujamos el
tablero
System.out.println("Empate!"); //Declaramos
un empate
break; //Pausamos la ejecución
}else{ //De lo contrario (no ha ganado y hay empate)
turno = "jugador"; //Pasamos el turno al
jugador
}
}
}
}
if (!objG.repiteJuego()) { //Si no desea repetir el juego
break; //Salimos del ciclo While
}
}
}
}
Ejecución java
Ejecución Java
La lógica del programa de java es exactamente la misma y la ejecución del código así lo
demuestra, tal y como podemos ver al iniciar se nos muestra el mensaje de bienvenida y
nos pregunta que letra deseamos utilizar.

Después de seleccionarla la computadora inicia primero por lo que se imprime su primer

movimiento.

En este caso dejamos que la maquina gane para mostrar el mismo proceso que en Python,
el mensaje de que perdimos y si es que queremos volver a intentarlo. Finalmente se nos
pide confirmar si deseamos seguir jugando o no.

Cuestionario

1. ¿Por qué los juegos están relacionados con la Inteligencia Artificial?

Este tipo de juegos requieren la presencia de 2 jugadores y al tratarse de un sistema

electrónico es bastante claro que la computadora tendrá la función de ser nuestro
adversario lo que además simboliza un mayor reto debido a la capacidad de análisis que
se le asigna.

2. ¿Existen mejoras en técnicas para mejorar el algoritmo aquí presentado? Menciónalas.

Para mejorar el algoritmo que se nos presentó podría considerarse el uso de los hilos para
que la computadora sea capaz de realizar de manera paralela la comprobación de cada
posible movimiento a la vez

3. Si quisiéramos consideramos juegos con más de un adversario, por ejemplo, el dominó

o el parchís ¿Podríamos implementar el algoritmo MINIMAX? Explica tu respuesta.

Viendo claramente la forma en que se maneja este algoritmo me parece obvio que si puede
implementarse, en este caso seria necesario programar la IA para cada jugador y realizarla
en base a los movimientos del juego de nuestra elección. Lo considero posible debido a
que se trata de un árbol de opciones que puede ser leído sin problemas.

Conclusiones

El uso del algoritmo de MINMAX para el desarrollo de videojuegos es tanto simple como a
la vez complejo, pues si bien no requiere muchos recursos del ordenador o técnicas muy
rebuscadas si requiere una nivel de lógica elevado pues el programar cada una de las
opciones que pueden existir en un videojuego no es sencillo.
En cuanto a Python me parece que las herramientas y características propias del lenguaje
vuelve bastante sencillo el desarrollo de esta práctica, no requiere métodos muy complejos
y solo hace uso de las estructuras básicas que son el for y el while.

Si hablamos del lenguaje Java tenemos que algunas de las funciones si son un poco más
largas que sus respectivas en el lenguaje previamente mencionado, sin embargo, la librería
ArrayList tiene la función de copiado desde otro arreglo lo que la vuelve mejor para esta
aplicación en particular.

Bibliografía

[3] Arcila, D., “HISTORIA DE LA TEORÍA DE JUEGOS”, blogspot.mx, 2010,

http://teoriadanielarcila.blogspot.mx/2010/11/historia-teoria-de-juegos.html (Consultada el
13 de febrero del 2022).