Está en la página 1de 8

FACULTAD DE INGENIERÍA

FUNDAMENTOS DE COMPUTACION Y PROGRAMACION

PRUEBA PARCIAL PROGRAMADA N°2

ASPECTOS GENERALES DE LA PRUEBA

● Lea atentamente la prueba y las instrucciones antes de comenzar a desarrollarla.


● Queda prohibido hablar con los compañeros(as) durante el desarrollo de la PEP.
● La PEP contiene 2 preguntas de desarrollo, con un total de 45 puntos y una exigencia del 60%
● Tiene un límite de tiempo de 90 minutos para responder.
● El equipo docente tiene la prohibición de responder consultas.
● El/La estudiante que se sorprenda en actos deshonestos será calificado con la nota mínima.
● Los elementos tecnológicos deben permanecer apagados y guardados. Queda absolutamente
prohibido el uso todo elemento tecnológico. Su uso puede significar la nota mínima o sanciones
mayores.
● El alumno deberá identificarse con su Cédula de Identidad.
● Sobre el escritorio sólo podrá existir lápiz (obligatorio) y goma/lápiz corrector (opcional).
● Complete sus datos personales antes de comenzar la evaluación.
● Considere que la evaluación contempla el código, los comentarios y el seguimiento de las buenas
prácticas de programación.
● Responda cada pregunta, a continuación de su enunciado, en el espacio que se le entrega para
ello.

NOMBRE RUT SECCIÓN

1. (30 puntos) SUDOKU

El Sudoku es un juego matemático que se inventó en Japón a finales de 1970 y que se hizo
mundialmente popular hace unos 15 años, cuando numerosos periódicos comenzaron a
incluirlo en la sección de pasatiempos. El objetivo del Sudoku es rellenar una matriz de 9 x 9
celdas (81 casillas) dividida en sub-matrices de 3 x 3 llamadas “cajas” o “regiones” con cifras
del 1 al 9 partiendo de algunos números dispuestos en algunas celdas, llamados pistas.

Para rellenar exitosamente la matriz, se deben cumplir ciertas condiciones las cuáles son:
• Un número no se puede repetir en una misma fila de la matriz.
• Un número no se puede repetir en la misma columna de la matriz.
• Un número no se puede repetir dentro de una “caja” o “región”.

A partir de las reglas dadas anteriormente, se solicita a usted la construcción de un programa


destinado a validar si una solución entregada para un Sudoku cumple con las reglas
anteriormente indicadas. Para ello, se le hará entrega de un archivo de texto “intento.txt” que
contendrá 9 filas (separadas por un salto de línea) cada una con 9 números (separados por
un espacio).

El programa deberá leer el archivo e informar al usuario si el intento es válido o contiene


errores. Para ilustrar el funcionamiento del programa, se entregan a continuación dos
ejemplos, uno de una respuesta válida y otro de una respuesta con errores. Considere que
estas entradas corresponden a ejemplos, y que su programa deberá funcionar para cualquier
combinación de 81 números, siempre que mantengan el formato descrito en el párrafo anterior.
25 de agosto de 2018

Intento válido Intento no válido


5 3 4 6 7 8 9 1 2 7 3 5 6 1 4 8 9 2
6 7 2 1 9 5 3 4 8 8 4 2 9 7 3 5 6 1
1 9 8 3 4 2 5 6 7 9 6 1 2 8 5 3 7 4
8 5 9 7 6 1 4 2 3 2 8 6 3 4 9 1 5 7
4 2 6 8 5 3 7 9 1 4 1 3 8 5 7 9 2 6
7 1 3 9 2 4 8 5 6 5 7 9 1 2 8 4 3 8
9 6 1 5 3 7 2 8 4 1 5 7 4 9 2 6 8 3
2 8 7 4 1 9 6 3 5 6 9 4 7 3 8 2 1 5
3 4 5 2 8 6 1 7 9 3 2 8 2 8 6 1 7 9

Como se puede observar, el intento no válido, tiene dos veces el valor 8 en una misma región,
el que a su vez, se repite en la sexta columna de la matriz, por lo que no sería una solución
válida. Mientras que el intento válido, tiene todos los números solo una vez en cada fila,
columna y región.

Un ejemplo del funcionamiento puede verse a continuación, en el que se entrega un intento


que si bien, cumple la regla de las filas y de las columnas, no cumple la regla de las regiones:

intento.txt Respuesta
1 2 3 4 5 6 7 8 9 El sudoku ingresado es
2 3 4 5 6 7 8 9 1 incorrecto.
3 4 5 6 7 8 9 1 2
4 5 6 7 8 9 1 2 3
5 6 7 8 9 1 2 3 4
6 7 8 9 1 2 3 4 5
7 8 9 1 2 3 4 5 6
8 9 1 2 3 4 5 6 7
9 1 2 3 4 5 6 7 8

# Función que lee el contenido de un archivo de texto


# Entrada: Nombre del archivo (string)
# Salida: Contenido del archivo (lista de strings)
def leerArchivo(nombreArchivo):
# Se abre el archivo en modo de lectura
archivo = open(nombreArchivo, 'r')
# Se obtiene el contenido del archivo
contenido = archivo.readlines()
# Se cierra el archivo
archivo.close()
# Se retorna el contenido
return contenido

# Función que convierte una lista de strings en una


# lista de listas de números, es decir, una matriz
# Entrada: lista (lista de strings)
# Salida: matriz (lista de lista de ints)
2
25 de agosto de 2018

def convertirAMatriz(lista):
# Se declara una lista vacia para almacenar el contenido
matriz = []
# Se declara un iterador para recorrer las líneas del archivo
i = 0
# Mientras no haya recorrido todos los elementos de la lista (lineas del
archivo)
while i < len(lista):
# Se declara un iterador para recorrer cada elemento de la línea
j = 0
# Se dividen los elementos de la línea por el caracter espacio
# Y se almacenan en una lista llamada fila
fila = lista[i].split(' ')
# Mientras no se haya alcanzado el largo de la fila
while j < len(fila):
# Se convierte cada elemento de la fila en un entero
# y se actualiza en la fila
fila[j] = int(fila[j])
# Incremento el valor de j
j = j + 1
# Agrego la fila a la matriz
matriz.append(fila)
# Incremento el iterador de las filas para recorrer el siguiente
# elemento de la lista
i = i + 1
# Retorno la matriz
return matriz

# Función que una valida que una lista cumpla con la regla
# de tener los nueve dígitos una sola vez
# Entrada: lista de enteros
# Salida: Booleano
def validar(lista):
# Ordeno la lista que se recibió de entrada
lista.sort()
# Declaro una lista que tiene los elementos de 1 a 9
listaValida = [1,2,3,4,5,6,7,8,9]
# Comparo la lista recibida con la lista que sería
# considerada válida
if lista == listaValida :
# En caso de que ambas listas sean iguales
# Se retorna True
return True
# En caso contrario, se retorna False
return False

# Función que valida que las filas cumplan con la regla


# de tener los nueve dígitos una sola vez
# Entrada: matriz (lista de lista de ints)
3
25 de agosto de 2018

# Salida: booleano (True si es valida, False en caso contrario)


def validarFilas(matriz):
# Se declara un iterador para recorrer las filas de la matriz
i = 0
# Mientras no se hayan recorrido todas las filas
while i < len(matriz) :
# Se valida la fila que estoy revisando usando la función
# validar()
resultado = validar(matriz[i])
# Si validar entrega True
if resultado :
# Reviso la fila siguiente
i = i + 1
# En caso contrario
else :
# Retorno False y dejo de revisar
# pues ya encontré un error en la solución
return False
# Si reviso todas las filas sin retornar un False
# retorno un True
return True

# Función que valida que las columnas cumplan con la regla


# de tener los nueve dígitos una sola vez
# Entrada: matriz (lista de lista de ints)
# Salida: booleano (True si es valida, False en caso contrario)
def validarColumnas(matriz):
# Declaro un iterador para recorrer todas las columnas
i = 0
# Mientras no alcance la última columna
# (Es equivalente a decir, mientras no alcance el largo
# de la primera fila)
while i < len(matriz[0]) :
# Declaro un iterador para recorrer la columna en particular
j = 0
# Declaro una lista vacia para agregar los elementos de la columna
columna = []
# Mientras j no alcance el último elemento de la columna
# (Es equivalente a decir, mientras j no alcance el total de filas)
while j < len(matriz) :
# Agrego el elemento a la lista columna
columna.append(matriz[j][i])
# Incremento el valor de j
j = j + 1
# Como columna es una lista de enteros, utilizo la funcion validar()
# para verificar que cumpla con la condición
resultado = validar(columna)
# En caso de que cumpla
if resultado :
# Aumento el iterador para revisar la columna siguiente
4
25 de agosto de 2018

i = i + 1
# En caso contrario
else :
# Retorno False, pues ya encontré un error en la solución
return False
# Si reviso todas las filas sin retornar un False
# entrego un True, pues todas cumplen con la condición
return True

# Función que valida que una región cumpla con la


# regla de tener los nueve dígitos sin repeticiones
# Entrada: matriz (lista de enteros),
# fila del primer elemento de la region (int),
# columna del primer elemento de la region (int),
# Salida: booleano (True si es valida, False en caso contrario)
def validarRegion(matriz, filaInicial, columnaInicial):
# Se declara una lista, para almacenar los valores de la region
lista = []
# Se declara un iterador para recorrer las filas
i = 0
# Mientras i no alcance tres valores
while i < 3 :
# Se declara un iterador para recorrer las columnas
j = 0
# Mientras j no alcance los 3 valores
while j < 3 :
# Se obtiene el elemento de la submatriz
elemento = matriz[columnaInicial + i][filaInicial + j]
# Se agrega el elemento a la lista
lista.append(elemento)
# Se incrementa el j para agregar el elemento que sigue
j = j + 1
# Se incrementa i para ir a la siguiente fila
i = i + 1
# Como tengo una lista con los 9 elementos de la region
# Puedo usar la función validar() para revisar si estos cumplen la
# condición, por lo que retorno el resultado de validar
return validar(lista)

# Función que valida que las regiones cumplan con la regla


# de tener los nueve dígitos una sola vez
# Entrada: matriz (lista de lista de ints)
# Salida: booleano (True si es valida, False en caso contrario)
def validarRegiones(matriz):
# Se genera un lista para almacenar el resultado de cada region
regionesValidas = []
# Se agrega el resultado de invocar validarRegion
# a la lista regionesValidas
5
25 de agosto de 2018

# Se llama la función validar region con la posición del


# primer elemento de cada submatriz
regionesValidas.append(validarRegion(matriz, 0, 0))
regionesValidas.append(validarRegion(matriz, 0, 3))
regionesValidas.append(validarRegion(matriz, 0, 6))
regionesValidas.append(validarRegion(matriz, 3, 0))
regionesValidas.append(validarRegion(matriz, 3, 3))
regionesValidas.append(validarRegion(matriz, 3, 6))
regionesValidas.append(validarRegion(matriz, 6, 0))
regionesValidas.append(validarRegion(matriz, 6, 3))
regionesValidas.append(validarRegion(matriz, 6, 6))
# Si al revisar las regiones apareció alguna que no fuese válida
if False in regionesValidas :
# Retorno False para indicar que existen problemas en las regiones
return False
# En caso contrario
else :
# Retorno True
return True

# BLOQUE PRINCIPAL

# ENTRADA
# Se obtiene el contenido del archivo de texto
entrada = leerArchivo('intento2.txt')

# PROCESAMIENTO
# Se convierte el contenido a matriz
sudoku = convertirAMatriz(entrada)

# SALIDA
# Se revisa si se cumplen las condiciones y se informa al usuario
# del error encontrado
if not validarRegiones(sudoku):
print 'El intento ingresado es incorrecto'
print 'Debido a un problema con las regiones'

elif not validarColumnas(sudoku):


print 'El intento ingresado es incorrecto'
print 'Debido a un problema con las columnas'

elif not validarFilas(sudoku):


print 'El intento ingresado es incorrecto'
print 'Debido a un problema con las filas'

else :
print 'El intento ingresado es correcto'

6
25 de agosto de 2018

2. (15 puntos) GRÁFICADOR DE POLINOMIOS

Se le solicita a usted la construcción de un programa capaz de graficar polinomios de cualquier


grado, para ello, se deberá solicitar al usuario el polinomio, y el rango a evaluar, es decir, desde
qué punto a qué punto se desea graficar el polinomio.

Para representar el polinomio, se utilizará una lista, en la que la posición de cada elemento
representa el grado y el elemento almacenado en cada posición representa el valor del
coeficiente. Por ejemplo para el polinomio:

𝑝(𝑥) = −3𝑥 5 + 12𝑥 3 − 2𝑥 + 2

La lista [2, -2, 0, 12, 0, -3] lo representaría adecuadamente, pues cada posición indica
el valor al que se debe elevar x y el valor de la lista presenta el coeficiente por el que se debe
multiplicar.

A partir de esta representación y los puntos de inicio y fin de la evaluación, construya un


programa capaz de graficar cualquier polinomio con grados positivos. Considere que el usuario
conoce la forma en que debe ingresar el polinomio.

# Se importa el módulo para gráficar


import matplotlib.pyplot as grafico
# Se importa numpy para realizar cálculos vectoriales
import numpy

# Se declara una constante con la cantidad de puntos


# que se usará para el gráfico
CANTIDAD_DE_PUNTOS = 100
# BLOQUE PRINCIPAL

# ENTRADAS
# Se solicita el inicio y final del rango
inicio = input('Ingrese el inicio del rango a evaluar: ')
fin = input('Ingrese el fin del rango a evaluar: ')
# Se solicita el polinomio
polinomio = input('Ingrese la lista que representa al polinomio: ')

# PROCESAMIENTO
# Creo el vector que representa los puntos de X
vectorX = numpy.linspace(inicio, fin, CANTIDAD_DE_PUNTOS)
# Creo un vector del mismo tamaño para almacenar los puntos
# del eje Y
resultado = numpy.zeros(CANTIDAD_DE_PUNTOS)
# Declaro un iterador, para ir recorriendo los términos del polinomio
i = 0
# Mientras i no alcance el largo del polinomio
while i < len(polinomio) :
# Realizo el cálculo del valor del vector X por el término del polinomo
# Y lo acumulo al valor que llevo en resultado

7
25 de agosto de 2018

resultado += vectorX ** i * polinomio[i]


# Incremento el iterador para evaluar el siguiente término del polinomio
i = i + 1

# SALIDA
# Se genera el polinomio a evaluar
recta = grafico.plot(vectorX, resultado, label='polinomio')

# Se define el título
grafico.title('Grafico del polinomio ingresado')

# Se define el nombre del eje X


grafico.xlabel('eje X')

# Se define el nombre del eje Y


grafico.ylabel('eje Y')

# Se muestra la leyenda
grafico.legend()

# Se muestra el gráfico
grafico.show()

También podría gustarte