Departamento de Estadística, Informática y Matemáticas

Estatistika, Informatika eta Matematika Saila

Examen de Informática
1º Ingenierías
23-01-2019

Nombre: Grupo:
1. Escribe un programa que reciba una matriz mat de números reales de nxm, y nos
indique qué columna col tiene más valores por encima del valor medio de la propia
columna. Para ello, implementa las siguientes funciones:
• LeeMatriz: debe leer una matriz mat de nxm de números reales. (0.2 puntos)
• ExtraeColumna: toma la matriz mat y una columna c, y nos devuelva un vector
v con la columna c de la matriz. (0.3 puntos)
• CalculaMedia: nos devuelve la media de los elementos de un vector v. (0.5
puntos)
• CuentaVector: nos dice cuántos valores del vector v son mayores que un
determinado num. (0.5 puntos)
• CuentaMatriz: a partir de una matriz de entrada de mat y utilizando las funciones
anteriores, debe calcular un vector medias de tamaño m (número de columnas de
la matriz de entrada) donde en cada posición j se almacene el valor medio de los
valores de la columna j. También obtendrá otro vector mayores de tamaño m, que
devolverá la función, con el número de elementos que en cada columna sean
mayores que el valor medio correspondiente. (1 puntos)
• IndiceMáximo: dado un vector de entrada de m elementos, debe devolver el
índice que corresponde al mayor de los elementos en el vector. Si hay más de un
valor igual al máximo, devuelve el índice del primero. (0.5 puntos)
El programa principal debe de utilizar las funciones anteriores para: leer una matriz,
obtener la media de sus columnas, contar en cada columna el número de valores que son
mayores que la media de la columna e indicar en qué columna ocurre esto un mayor
número de veces. (0.5 puntos)
Ejemplo: Matriz mat:

1 2 -1 2
2 2 1 2
3 3 0 2
2 3 -2 2
1 2.5 2 2
2 2.5 0 2

CuentaMatriz construye el vector medias: 1.83 2.5 0 2

Y el vector mayores: 4 2 2 0

IndiceMaximo devolvería la posición 0 y el resultado del programa sería: Columna 0

def lee_matriz():
print('Vamos a introducir una matriz {}x{}'.format(n, m))
matriz = []
for i in range(n):
fila = input('Introduce los {} elementos de la fila {}:’
.format(m, i)).split()
for j in range(m):
fila[j] = float(fila[j])
matriz.append(fila)
return(matriz)

def extrae_columna(matr, c):

vector = []
for i in range(n):
vector.append(matr[i][c])
return vector

def calcula_media(vector):
return sum(vector) / len(vector)

def cuenta_vector(vector, numero):

cuenta = 0
for e in vector:
if e > numero:
cuenta += 1
return cuenta

def cuenta_matriz(matriz):
medias = []
mayores = []
for i in range(m):
columna = extrae_columna(matriz, i)
mediaColumna = calcula_media(columna)
medias.append(mediaColumna)
mayores.append(cuenta_vector(columna,
mediaColumna))
return mayores

def indice_maximo(vec):
for i in range(len(vec)):
if vec[i] == max(vec):
return i

n = int(input(‘Número de filas:’)
m = int(input(‘Número de columnas:’)
mat = lee_matriz()
indice = indice_maximo(cuenta_matriz(mat))
print('Columna',indice)
2. Queremos implementar las siguientes funciones:
• LeeMatriz: recibe el número de filas f y columnas c y devuelve una matriz m de
ese tamaño leída por teclado. (0.3 puntos)
• MediaMatriz: recibe una matriz m y devuelve la media aritmética de sus valores.
(0.3 puntos)
• MaxDiferencia: recibe una matriz m y devuelve la mayor diferencia entre todos
sus elementos. (0.5 puntos)
• Compensa: recibe una matriz m y devuelve la matriz modificada de manera que
los elementos mayores que la media, reduzcan su valor un 20% y los menores lo
aumenten un 20%. (0.7 puntos)
• CompensaIterativa: recibe una matriz m, un número real umbral y un número
entero maxIt. Mediante sucesivas llamadas a la función Compensa transformará
la matriz hasta que la mayor diferencia entre dos de sus elementos sea menor que
el umbral dado o se hayan realizado maxIt iteraciones. La función deberá
devolver la matriz resultante, así como el número de iteraciones realizadas. (1
puntos)
• EscribeMatriz: escribe en pantalla una matriz. (0.2 puntos)
Haciendo uso de estas funciones, crearemos un programa que lea una matriz por teclado
(tamaño constante conocido definido en el programa principal) y calcule la matriz
compensada haciendo uso de CompensaIterativa. El umbral (un número real) y el
máximo número de iteraciones (número entero) serán valores que deberá de introducir el
usuario por teclado. Finalmente, se imprimirá la matriz resultante, así como el número de
iteraciones utilizadas para obtener dicha matriz. (0.5 puntos)

def lee_matriz():
print('Vamos a introducir una matriz {}x{}'.format(f, c))
matriz = []
for i in range(f):
fila = input('Introduce los {} elementos de la fila {}:
'.format(c, i)).split()
for j in range(c):
fila[j] = float(fila[j])
matriz.append(fila)
return(matriz)

def media_matriz(m):
suma = 0
cont = 0
for fila in m:
suma += sum(fila)
cont += len(fila)
return suma / cont
def max_diferencia(m):
v = []
for fila in m:
for elem in fila:
v.append(elem)
return max(v) - min(v)

def compensa(m):
media = media_matriz(m)
for i in range(len(m)):
for j in range(len(m[0])):
if m[i][j] < media:
m[i][j] = m[i][j] * 1.2
elif m[i][j] > media:
m[i][j] = m[i][j] * 0.8
return m

def compensa_iterativa(m,u,mxI):
iteraciones = 0
while max_diferencia(m) > u and iteraciones < mxI:
m = compensa(m)
iteraciones += 1
return(m, iteraciones)

def escribe_matriz(m):
for fila in m:
for elem in fila:
print('{:7.2f}'.format(elem), end='')
print()
print()

f=2
c=3
mat = lee_matriz()
umbral = float(input('Introduce el umbral: '))
maxItera = int(input('Introduce el màximo de iteraciones: '))
mRes,numItera = compensa_iterativa(mat, umbral, maxItera)
print('La matriz resultante es: ')
escribe_matriz(mRes)
print('Número de iteraciones:',numItera)
 3. Se requiere de una hoja Excel para saber cuánto le va a costar a cada cliente la entrada
al teatro. El precio de la entrada depende de la posición en la que se vaya a sentar dentro
del teatro y la fila que ocupe en dicha posición. Además, los socios del teatro tienen un
descuento del 20% sobre el precio de la entrada.
A partir de los datos de entrada y utilizando funciones de búsqueda, se pide:

E2…E6: Obtener el precio que debe pagar cada cliente.

Nota: La fórmula se diseñará para E2 de tal forma que se pueda copiar (arrastrar) al resto
de celdas de la misma columna y el resultado sea el correcto. (1 punto)

E2 = BUSCARV(C2; $G$3:$Q$6; B2 + 1 ;FALSO) * SI(D2 = “Sí”; 0,8; 1))

______________________________________________________________________

4. La Unión Ciclista Internacional gestiona la participación de los ciclistas en las

diferentes carreras a través de una base de datos compuesta por 4 tablas: Equipos,
Ciclistas, Participaciones y Carreras. La tabla de Equipos contiene el nombre del equipo
(que es único), su identificador, el año de fundación y el lugar de su sede. La tabla
Ciclistas contiene el DNI, el número de licencia, el equipo al que pertenece y la fecha de
nacimiento de cada ciclista, además de otros datos personales. La tabla Carreras
almacena para cada carrera su identificador, el nombre, la fecha en la que tuvo lugar y la
ciudad y país donde se celebra (una carrera se puede identificar por su nombre y la fecha
de celebración unívocamente). Por último, la tabla Participaciones registra las carreras
donde ha participado cada ciclista y el puesto en el que ha acabado en dicha carrera.

Equipos Ciclistas Participaciones Carreras

Id_equipo DNI Ciclista Id_carrera
Nombre Número_licencia Carrera Nombre
Año_fundación Nombre Puesto Fecha
Sede Apellidos Ciudad
Equipo País
Fecha_nacimiento

* ClavePrincipal
* Clave Ajena
a) Escribe las posibles claves candidatas de cada una de las tablas. Si hay más de una,
escribe una por línea. (0.3 puntos)

Claves candidatas de Equipos: Id_equipo

Nombre

Claves candidatas de Ciclistas: DNI

Número_licencia
Nombre + Apellidos

Claves candidatas de Participaciones: Ciclista + Carrera

Carrera + Puesto

Claves candidatas de Carreras: Id_carrera

Nombre + Fecha

b) Escribe las claves ajenas (externas) que haya en estas tablas. Indica, para cada una, en
qué tabla es clave externa y a qué tabla y atributo (o campo) hace referencia.
(0.2 puntos)

-Equipos no tiene claves ajenas

-Equipo es clave ajena en Ciclistas y hace referencia al campo

Id_equipo de la tabla Equipos

-Participaciones tiene dos claves ajenas: Ciclista, que hace

referencia al campo DNI de la tabla Ciclistas y Carrera, que
hace referencia al campo Id_carrera de la tabla Carreras

-Carreras no tiene claves ajenas

c) Realiza las siguientes consultas.

-En la parte superior de la parrilla las tablas (no es necesario que escribas todos los
campos sobre las que se basa la consulta). Nota importante: no poner para la
resolución de cada cuestión más de las tablas absolutamente necesarias para ello.
-En la parte inferior de la parrilla, los campos, criterios, operadores, etc. necesarios.
c1) Se quiere obtener un listado de los nombres y apellidos de los ciclistas de menos de
25 años a día 1 de enero de 2019 que han sido ganadores de alguna carrera celebrada en
Francia o España. Además, queremos tener en la misma lista a aquellos ciclistas que
independientemente de su edad, han quedado en el top 10 en carreras celebradas en Japón.
(0.75 puntos)

Nombre Apellidos Fecha_nacimiento Puesto Páís

Campo:
Ciclistas Ciclistas Ciclistas Participaciones Carreras
Tabla:

Orden:

Mostrar: X X

Criterios: >#1/1/1994# 1 “ Francia” o “España”

O: <11 “ Japón”

c2) Se quiere dar un premio a equipos con una larga y exitosa trayectoria. Por ello,
necesitamos una lista con los equipos que tienen más de 25 años (a fecha 1 de enero de
2019), ordenada de mayor a menor por el número de puestos top 5 que han conseguido
los ciclistas de dicho equipo a lo largo de la historia del mismo (independientemente de
cuándo se hayan cosechado dichos resultados). (0.75 puntos)

Campo: Nombre Año_fundación Ciclista Puesto

Tabla: Equipos Equipos Participaciones Participaciones
Total: Agrupar Dónde Cuenta Dónde
Orden: Descendente

Mostrar: X X
< #1/1/1994# <6
Criterios: