{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "### Exámenes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ejercicio 1:\n", "\n", "Queremos realizar un programa que conste de:\n", "- Un procedimiento llamado LeeMatriz que almacene enteros introducidos por teclado en una matriz M (NxN), N constante conocida. \n", "- Un procedimiento ExtraeFila que reciba como parámetros una matriz M y un número entero num y devuelva un vector V que contenga los valores de la fila de la matriz indicada por dicho número. \n", "- Una función Mayor que reciba como parámetro un vector V de dimensión N y devuelva el mayor de sus valores. \n", "- Un procedimiento CreaVector que reciba como parámetro una matriz M y mediante el procedimiento y la función anteriores devuelva un vector V de dimensión N compuesto por los mayores elementos de cada fila de la matriz. \n", "- Un procedimiento HazMatriz que reciba como parámetro un vector V y devuelva una matriz cuya primera columna sea dicho vector y las posteriores se formen restando 1 a la anterior. Ningún elemento de las columnas a partir de la primera podrá tomar un valor menor que 0. En ese caso, se rellenará el resto de la fila con 0. \n", "- Un procedimiento EscribeMatriz que muestre una matriz por pantalla. \n", "- Un programa principal que solicite una matriz por teclado y mediante los procedimientos anteriores cree una nueva matriz como la del ejemplo. Este programa también imprimirá por pantalla la matriz original y la resultante. \n", "\n", "Ejemplo: si la matriz de entrada es\n", "\n", "$\\begin{bmatrix}\n", "3 & -4 & 2 & -5 \\\\\n", "11 & 4 & 6 & 12 \\\\\n", "-2 & -3 & 2 & -4 \\\\\n", "5 & 3 & 10 & 7\n", "\\end{bmatrix}$ $\\rightarrow$\n", "$\\begin{bmatrix}\n", "3 & 12 & 2 & 10 \n", "\\end{bmatrix}$ $\\rightarrow$\n", "$\\begin{bmatrix}\n", "3 & 2 & 1 & 0 \\\\\n", "12 & 11 & 10 & 9 \\\\\n", "2 & 1 & 0 & 0 \\\\\n", "10 & 9 & 8 & 7\n", "\\end{bmatrix}$ " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Vamos a introducir una matriz 4x4\n", "Introduce los 4 elementos de la fila 0: 3 -4 2 -5\n", "Introduce los 4 elementos de la fila 1: 11 4 6 12\n", "Introduce los 4 elementos de la fila 2: -2 -3 2 -4\n", "Introduce los 4 elementos de la fila 3: 5 3 10 7\n", "La Matriz m es: \n", " 3 -4 2 -5 \n", " 11 4 6 12 \n", " -2 -3 2 -4 \n", " 5 3 10 7 \n", "La Matriz m es: \n", " 3 2 1 0 \n", " 12 11 10 9 \n", " 2 1 0 0 \n", " 10 9 8 7 \n" ] } ], "source": [ "def LeeMatriz():\n", " print(\"Vamos a introducir una matriz {}x{}\".format(N,N))\n", " M = []\n", " for i in range (N):\n", " fila=input(\"Introduce los {} elementos de la fila {}: \".format(N,i)).split()\n", " for j in range(N):\n", " fila[j] = int(fila[j])\n", " M.append(fila)\n", " return M\n", "\n", "def ExtraeFila(M,num):\n", " V = M[num]\n", " return V\n", "def Mayor(V):\n", " maximo = V[0]\n", " for x in V:\n", " if x > maximo:\n", " maximo = x\n", " return maximo\n", "\n", "def CreaVector(M):\n", " V = []\n", " for i in range(N):\n", " fila = ExtraeFila(M,i)\n", " maximo = Mayor(fila)\n", " V.append(maximo)\n", " return V\n", "\n", "def HazMatriz(V):\n", " M = []\n", " for i in range(N):\n", " M.append([0]*N)\n", " for i in range(N):\n", " for j in range(N):\n", " if j == 0:\n", " M[i][j]= V[i]\n", " else:\n", " if M[i][j - 1]>1:\n", " M[i][j]=M[i][j-1]-1\n", " return M\n", "\n", "def ImprimeMatriz(M):\n", " print(\"La Matriz m es: \")\n", " for fila in M:\n", " for i in fila:\n", " print(\"{0:3}\".format(i),end=' ')\n", " print()\n", "\n", "N = 4\n", "m = LeeMatriz()\n", "v = CreaVector(m)\n", "m2 =HazMatriz(v)\n", "ImprimeMatriz(m)\n", "ImprimeMatriz(m2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ejercicio 2\n", "\n", "Escribe un programa que, a partir de una matriz, calcule en otra matriz las sumas acumuladas de la primera desde la posición [1,1] hasta cada posición de la matriz. Para ello, implementa los siguientes procedimientos y funciones:\n", "- Un procedimiento LeeMatriz que lea del usuario NxM (constantes conocidas) números enteros y los almacene en una matriz.\n", "- Un procedimiento SubMatriz que reciba una matriz, un número de fila F y un número de columna C. Este procedimiento debe devolver una matriz del mismo tamaño que la original en la que los elementos del cuadrado formado desde la posición [1,1] hasta la posición [F,C] sean iguales que en la matriz original y el resto de elementos valgan 0. \n", "\n", "Matriz original: $\\begin{bmatrix}\n", "1 & 4 & 7 & 3 & 8 \\\\\n", "10 & 9 & 5 & 3 & 6 \\\\\n", "3 & 12 & 1 & 0 & 9\\\\\n", "2 & 5 & 4 & 8 & 2 \\\\\n", "\\end{bmatrix}$; Submatriz hasta la posición [2,3]\n", "$\\begin{bmatrix}\n", "1 & 4 & 7 & 0 & 0 \\\\\n", "10 & 9 & 5 & 0 & 0 \\\\\n", "0 & 0 & 0 & 0 & 0\\\\\n", "0 & 0 & 0 & 0 & 0 \\\\\n", "\\end{bmatrix}$\n", "- Una función SumaMatriz que reciba una matriz y devuelva la suma de todos los elementos almacenados en ella. \n", "- Un procedimiento Sumas que, utilizando el procedimiento y la función anterior, reciba una matriz y cree otra nueva matriz en la que en cada posición se almacene la suma de todos los elementos desde la posición [1,1] hasta dicha posición de la matriz original. \n", "- Un programa principal que, después de leer los números de una matriz y construir la matriz de sumas acumuladas, muestre la suma de los elementos de la matriz de sumas acumuladas. (0,7 puntos)\n", "\n", "Ejemplo:\n", "$\\begin{bmatrix}\n", "1 & 4 & 7 & 3 & 8 \\\\\n", "10 & 9 & 5 & 3 & 6 \\\\\n", "3 & 12 & 1 & 0 & 9\\\\\n", "2 & 5 & 4 & 8 & 2 \\\\\n", "\\end{bmatrix}$ $\\rightarrow$\n", "$\\begin{bmatrix}\n", "1 & 5 & 12 & 15 & 23 \\\\\n", "11 & 24 & 36 & 42 & 56 \\\\\n", "14 & 39 & 52 & 58 & 81\\\\\n", "16 & 46 & 63 & 77 & 102 \\\\\n", "\\end{bmatrix}$" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Vamos a introducir una matriz 4x5\n", "Introduce los 5 elementos de la fila 0: 1 4 7 3 8\n", "Introduce los 5 elementos de la fila 1: 10 9 5 3 6\n", "Introduce los 5 elementos de la fila 2: 3 12 1 0 9\n", "Introduce los 5 elementos de la fila 3: 2 5 4 8 2\n", "Introduce el numero de fila de la submatriz: 2\n", "Introduce el numero de columna de la submatriz: 3\n", "La submatriz hasta la posicion [2,3]: \n", " 1 4 7 0 0 \n", " 10 9 5 0 0 \n", " 0 0 0 0 0 \n", " 0 0 0 0 0 \n", "La matriz de sumas acumuladas es: \n", " 1 5 12 15 23 \n", " 11 24 36 42 56 \n", " 14 39 52 58 81 \n", " 16 46 63 77 102 \n" ] } ], "source": [ "def LeeMatriz():\n", " print(\"Vamos a introducir una matriz {}x{}\".format(N,m))\n", " M = []\n", " for i in range (N):\n", " fila=input(\"Introduce los {} elementos de la fila {}: \".format(m,i)).split()\n", " for j in range(N):\n", " fila[j] = int(fila[j])\n", " M.append(fila)\n", " return M\n", "def SubMatriz(M,f,c):\n", " V = []\n", " for i in range(N):\n", " V.append([0]*m)\n", " for i in range(N):\n", " for j in range(m):\n", " if j < c and i < f:\n", " V[i][j] = M[i][j]\n", " else:\n", " V[i][j] = 0\n", " return V\n", "def SumaMatriz(M):\n", " s = 0\n", " for i in range(N):\n", " for j in range(m):\n", " s = s + int(M[i][j])\n", " return s\n", "def Sumas(M):\n", " V = []\n", " T = []\n", " for i in range(N):\n", " V.append([0]*m)\n", " T.append([0]*m)\n", " for i in range(N):\n", " for j in range(m):\n", " for l in range(0,j+1):\n", " T[i][l]=M[i][l]\n", " c = SumaMatriz(T)\n", " V[i][j]=c + V[i-1][j] \n", " T=[]\n", " for k in range(N):\n", " T.append([0]*m)\n", " return V\n", "def printeamos(M):\n", " for fila in M:\n", " for i in fila:\n", " print(\"{0:3}\".format(i),end=' ')\n", " print()\n", "\n", "N = 4\n", "m = 5\n", "M=LeeMatriz()\n", "f=int(input(\"Introduce el numero de fila de la submatriz: \"))\n", "c=int(input(\"Introduce el numero de columna de la submatriz: \"))\n", "print(\"La submatriz hasta la posicion [{},{}]: \".format(f,c))\n", "printeamos(SubMatriz(M,f,c))\n", "print(\"La matriz de sumas acumuladas es: \")\n", "printeamos(Sumas(M))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ejercicio 3\n", "\n", "Este programa estudiará el nivel de coincidencia de dos matrices de números enteros. Dos matrices A y B (NxN, N constante conocida) tienen nivel T de coincidencia si hay exactamente T posiciones de A y B cuyos valores coinciden. \n", "- Escribe un procedimiento LeeMatriz que lea una matriz M(NxN). \n", "- El procedimiento LeeVector leerá un vector de enteros V(M), M constante conocida. \n", "- Diseña una función CoincidenMatrices que tome dos matrices A y B y nos diga cuántas posiciones de ambas matrices tienen valores coincidentes. \n", "- Diseña ahora una función booleana CoincideT que tome dos matrices A y B, y un valor entero T y utilizando la función anterior nos diga si hay exactamente T posiciones coincidentes en las dos matrices. \n", "- La función PosCoincidentes tomará dos matrices A y B y un vector V y nos devolverá la posición del vector donde esté el número de coincidencias entre ambas matrices. Para hacerlo, deberás recorrer el vector y utilizar la función CoincideT. Si el número de coincidencias no está en el vector, devolverá 0 y si está repetido en el vector, la posición de la primera aparición. \n", "\n", "Completa el ejercicio con un programa principal que lea las dos matrices y el vector y nos diga si en alguna de las posiciones del vector está el número de coincidencias de las dos matrices. \n", "\n", "Ejemplo:\n", "A: $\\begin{bmatrix}\n", "21 & 12 & 0 & 3 \\\\\n", "8 & 9 & 16 & 16 \\\\\n", "15 & 8 & 112 & 19\\\\\n", "12 & 7 & 18 & 2 \\\\\n", "\\end{bmatrix}$; B:\n", "$\\begin{bmatrix}\n", "21 & 10 & 2 & 3 \\\\\n", "18 & 9 & 16 & 6\\\\\n", "5 & 78 & 12 & 9\\\\\n", "7 & 17 & 33 & 2\\\\\n", "\\end{bmatrix}$; V: \n", "$\\begin{bmatrix}\n", "3 & 7 & 5 & 1 & 2 & 1\n", "\\end{bmatrix}$" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Vamos a introducir una matriz 4x4: \n", "Introduce los 4 elementos de la fila 0: 21 12 0 3\n", "Introduce los 4 elementos de la fila 1: 8 9 16 16\n", "Introduce los 4 elementos de la fila 2: 15 8 112 19\n", "Introduce los 4 elementos de la fila 3: 12 7 18 2\n", "Vamos a introducir una matriz 4x4: \n", "Introduce los 4 elementos de la fila 0: 21 10 2 3\n", "Introduce los 4 elementos de la fila 1: 18 9 16 6\n", "Introduce los 4 elementos de la fila 2: 5 78 12 9\n", "Introduce los 4 elementos de la fila 3: 7 17 33 2\n", "Dame 6 numeros: 3 7 5 1 2 1\n", "En la posicion 3 del vector esta el numero de coincidentes de las matrices\n" ] } ], "source": [ "print(\"En la posicion {} del vector esta el numero de coincidentes de las matrices\".format(poscoincidentes(A,B,V)))\n", "\n", "def leematriz():\n", " print(\"Vamos a introducir una matriz {}x{}: \".format(N,N))\n", " M = []\n", " for i in range(N):\n", " fila = input(\"Introduce los {} elementos de la fila {}: \".format(N,i)).split()\n", " for j in range(len(fila)):\n", " fila[j] = int(fila[j])\n", " M.append(fila)\n", " return M\n", "\n", "def leevector():\n", " v = input(\"Dame {} numeros: \".format(C)).split()\n", " for i in range(C):\n", " v[i] = int(v[i])\n", " return v\n", "\n", "def coincidematrices(A,B):\n", " cont = 0\n", " for i in range(N):\n", " for j in range(N):\n", " if A[i][j] == B[i][j]:\n", " cont += 1\n", " return cont\n", "\n", "def coincideT(A,B,T):\n", " return coincidematrices(A,B) == T\n", "\n", "def poscoincidentes(A,B,V):\n", " for i in range(C):\n", " if coincideT(A,B,V[i]):\n", " return i+1\n", " return 0\n", "\n", "N = 4\n", "C = 6\n", "A = leematriz()\n", "B = leematriz()\n", "V = leevector()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ejercicio 4\n", "\n", "Escribe los siguientes procedimientos y funciones:\n", "- Un procedimiento LeeMatriz que lea del usuario NxN números enteros (N constante conocida) y los almacene en una matriz. \n", "- Una función ExtraeDiagonalPrincipal que devuelva la diagonal principal de una matriz de entrada M en forma de vector. \n", "- Un procedimiento ExtraeDiagonalSecundaria que devuelva la diagonal secundaria de una matriz de entrada M en forma de vector. \n", "- Un procedimiento ComparaVectores que reciba dos vectores de entrada V1 y V2 de dimensión N y devuelva dos nuevos vectores (PAR, IMPAR), así como el número de elementos almacenados en cada uno de estos vectores (TamPar, TamImpar). Para ello, deben compararse los elementos de V1 y V2 elemento a elemento y guardar en los vectores la división entera del elemento en V1 entre el de V2. La división se guardará en el vector PAR si el resto de la división entre los dos elementos es par y en IMPAR en otro caso. \n", "- Un procedimiento EscribeVector que reciba un vector y el número de elementos almacenados en él y muestre por pantalla dichos números en una única fila. \n", "\n", "Utilizando los procedimientos y funciones anteriores, crea un programa que lea dos matrices de números enteros, extraiga la diagonal principal de la primera matriz y la secundaria de la segunda y, posteriormente, compare las dos diagonales obteniendo los vectores PAR e IMPAR. Finalmente muestra el contenido de dichos vectores por pantalla. \n", "\n", "Ejemplo: si las matrices de entrada son :\n", "M1: $\\begin{bmatrix}\n", "1 & 4 & 7 & 3\\\\\n", "10 & 9 & 5 & 3\\\\\n", "3 & 12 & 14 & 0\\\\\n", "2 & 5 & 4 & 11\\\\\n", "\\end{bmatrix}$ y M2:\n", "$\\begin{bmatrix}\n", "6 & 3 & 5 & 4\\\\\n", "7 & 8 & 3 & 12\\\\\n", "9 & 3 & 3 & 3\\\\\n", "2 & 0 & 11 & 2\\\\\n", "\\end{bmatrix}$\n", "\n", "Las diagonales serán:\n", "\n", "DiagM1: 1$\\ $ 9$\\ $ 14$\\ $ 11\n", "\n", "DiagM2: 4$\\ $ 3$\\ $ 3$\\ $ 2\n", "\n", "Y los vectores:\n", "\n", "PAR = 3 $\\ $ 4 (resultado de 9 entre 3 = 3, resto=; 14 entre 3 = 4, resto = 2)\n", "\n", "IMPAR = 0 $\\ $2 (resultado de 1 entre 4 = 0, resto = 4; 11 entre 4 = 2, resto = 3)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Vamos a introducir una matriz 4x4: \n", "1 4 7 3\n", "10 9 5 3\n", "3 12 14 0\n", "2 5 4 11\n", "Vamos a introducir una matriz 4x4: \n", "6 3 5 4\n", "7 8 3 12\n", "9 3 3 3\n", "2 0 11 2\n", "PAR = [3 4 ]\n", "IMPAR = [0 5 ]\n" ] } ], "source": [ "def LeeMatriz():\n", " print(\"Vamos a introducir una matriz {}x{}: \".format(N,N))\n", " M = []\n", " for i in range(N):\n", " fila = input().split()\n", " for j in range(len(fila)):\n", " fila[j] = int(fila[j])\n", " M.append(fila)\n", " return M\n", "def ExtraeDiagonalPrincipal(M):\n", " V=[]\n", " for i in range(N):\n", " V.append(M[i][i])\n", " return V\n", "\n", "def ExtraeDiagonalSecundaria(M):\n", " V = []\n", " for i in range(N):\n", " V.append(M[i][N-1-i])\n", " return V\n", "\n", "def ComparaVectores(V1,V2):\n", " Par = []\n", " Impar=[]\n", " TamPar = 0\n", " TamImpar=0\n", " for i in range(N):\n", " if (V1[i]%V2[i])==0 or (V1[i]%V2[i])%2==0:\n", " Par.append(V1[i]//V2[i])\n", " TamPar += 1\n", " else:\n", " Impar.append(V1[i]//V2[i])\n", " TamImpar += 1\n", " print(\"PAR = [\",end='')\n", " EscribeVector(Par,TamPar)\n", " print(\"IMPAR = [\",end='')\n", " EscribeVector(Impar,TamImpar)\n", "\n", "def EscribeVector(V,t):\n", " for i in range(t):\n", " print(V[i],end=' ')\n", " print(\"]\")\n", " \n", "N=4\n", "M1=ExtraeDiagonalPrincipal(LeeMatriz())\n", "M2=ExtraeDiagonalSecundaria(LeeMatriz())\n", "ComparaVectores(M1,M2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ejercicio 5\n", "\n", "Nuestro programa leerá una frase f y una lista de enteros positivos l (ambos del mismo tamaño). A continuación, construirá una matriz m (nxn), n constante, que tenga en cada columna c los n primeros caracteres de la frase que estén en la misma posición que los n primeros múltiplos de c de la lista, en el orden de lectura. Si no hay n múltiplos de c, la columna se completará con espacios en blanco.\n", "Para hacerlo, diseña las siguientes funciones:\n", "- LeeLista: lee una lista l de enteros positivos. \n", "- MúltiplosColumna: toma una matriz m, la frase f, la lista l y una columna c, y rellena la columna c de la matriz m con los n primeros caracteres de la frase que están en la misma posición que los n primeros múltiplos de c que haya en la lista (en el orden de lectura) \n", "- CreaMatriz: recibe una frase f y una lista l y utilizando la función anterior, crea la matriz con los caracteres correspondientes en cada una de las columnas. \n", "- EscribeMatriz: muestra en pantalla el resultado. \n", "\n", "Completa el ejercicio con un programa principal que utilizando las funciones anteriores, lea la frase y la lista (del mismo tamaño), construya la matriz y la muestre como en el ejemplo. \n", "\n", "Ejemplo:\n", "\n", "Introduce una frase: perro gato leon\n", "\n", "Introduce una lista de 15 enteros positivos: 3 5 12 7 34 6 9 8 3 23 67 1 4 5 90\n", "\n", "La matriz $5\\times 5$ resultante es:\n", "$\\begin{bmatrix}\n", "p & r & p & r & e \\\\\n", "e & o & r & a & o \\\\\n", "r & & & e & n \\\\\n", "r & a & g & & \\\\\n", "o & e & t & & \n", "\\end{bmatrix}$\n", "\n", "Nota explicativa: para evitar divisiones por , llamaremos columna 1 a la primera columna de la matriz, aunque se almacene internamente en la columna . Además, ten en cuenta la relación entre las letras de la frase y la lista de números:\n", "\n", "$\\begin{bmatrix}\n", "3 & 5 & 12 & 7 & 34 & 6 & 9 & 8 & 3 & 23 & 67 & 1 & 4 & 5 & 90 \\\\\n", "p & e & r & r & o & & g & a & t & o & & l & e & o & n\n", "\\end{bmatrix}$\n", "\n", "Por tanto, como los 5 primeros múltiplos de 2 en la lista son 12, 34, 6, 8 y 4, tomaremos las correspondientes letras (r, o, blanco, a, e) para completar la columna 2 de la matriz." ] }, { "cell_type": "code", "execution_count": 5009, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Introduce una frase: perro gato leon\n", "Dame 15 enteros: 3 5 12 7 34 6 9 8 3 23 67 1 4 5 90\n", "La matriz 5x5 resultante es: \n", "p r p r e \n", "e o r a o \n", "r e n \n", "r a g \n", "o e t \n" ] } ], "source": [ "# Escribe aquí tu programa \n", "def LeeLista():\n", " l =input(\"Dame {} enteros: \".format(len(f))).split()\n", " for i in range(len(f)):\n", " l[i]= int(l[i])\n", " return l\n", "def MultiplosColumnas(M,f,l,c):\n", " i = 0\n", " for k in range(len(l)):\n", " if l[k] % c == 0:\n", " M[i][c-1]= f[k]\n", " i += 1\n", " if i == N:\n", " break\n", " return M\n", "def CreaMatriz(f,l):\n", " M=[]\n", " for i in range(N):\n", " M.append([' ']*N)\n", " for i in range(1,N+1):\n", " MultiplosColumnas(M,f,l,i)\n", " return M\n", "def EscribeMatriz(M):\n", " print(\"La matriz {}x{} resultante es: \".format(len(M),len(M)))\n", " for i in range(len(M)):\n", " for j in range(len(M)):\n", " print(\"{0:3}\".format(M[i][j]),end=' ')\n", " print()\n", "N = 5\n", "f=input(\"Introduce una frase: \")\n", "l=LeeLista()\n", "EscribeMatriz(CreaMatriz(f,l))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ejercicio 6\n", "\n", "Crea un programa que aplique una media basada en 8 vecinos a cada posición de una matriz. Para ello, utiliza las siguientes funciones:\n", "- LeeMatriz: debe leer y devolver una matriz m de nxn de números reales. \n", "- Extrae8vecinos: debe recibir una matriz m de nxn números reales y una posición dada por dos valores enteros i, j. La función debe devolver una nueva matriz de 3x3 con los valores de la submatriz de 3x3 centrada en la posición i, j (asumimos que i, j nunca estará situada en los bordes de la matriz). \n", "- CalculaMedia: recibe una matriz y debe devolver la media de sus elementos. \n", "- AplicaMediaVecinos: recibe una matriz m de nxn de números reales y devuelve una nueva matriz m2 de números reales de tamaño nxn. Los bordes de la nueva matriz tendrán valor 0 ya que no es posible obtener los 8 vecinos. Para el resto, se recorrerá cada posición de la matriz original, obteniendo sus 8 vecinos, calculando su media y asignando este nuevo valor a la matriz resultado. \n", "- EscribeMatriz: debe de imprimir por pantalla la matriz que recibe como entrada. \n", "\n", "Finalmente, escribe el programa principal que lea una matriz, aplique la media basada en 8 vecinos e imprima la matriz por pantalla. \n", "\n", "Ejemplo:\n", "$\\begin{bmatrix}\n", "1 & 4 & 7 & 3 & 8 \\\\\n", "1 & 3 & 1 & 3 & 6 \\\\\n", "3 & 2 & 1 & 0 & 9\\\\\n", "2 & 5 & 4 & 8 & 2\\\\\n", "1 & 3 & 5 & 2 & 1 \\\\\n", "\\end{bmatrix}$ $\\rightarrow$\n", "$\\begin{bmatrix}\n", "0 & 0 & 0 & 0 & 0 \\\\\n", "0 & 2.55 & 2.66 & 4.22 & 0\\\\\n", "0 & 2.44 & 3 & 3.77 & 0 \\\\\n", "0 & 2.88 & 3.33 & 3.55 & 0\\\\\n", "0 & 0 & 0 & 0 & 0\\\\\n", "\\end{bmatrix}$\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Vanos a introducir una matriz 5x5\n", "Introduce los 5 elementos de la fila 0: 1 4 7 3 8\n", "Introduce los 5 elementos de la fila 1: 1 3 1 3 6\n", "Introduce los 5 elementos de la fila 2: 3 2 1 0 9\n", "Introduce los 5 elementos de la fila 3: 2 5 4 8 2\n", "Introduce los 5 elementos de la fila 4: 1 3 5 2 1\n", "La matriz 5x5 resultante es: \n", "0.00 0.00 0.00 0.00 0.00 \n", "0.00 2.56 2.67 4.22 0.00 \n", "0.00 2.44 3.00 3.78 0.00 \n", "0.00 2.89 3.33 3.56 0.00 \n", "0.00 0.00 0.00 0.00 0.00 \n" ] } ], "source": [ "def lee_matriz():\n", " m = []\n", " print(\"Vamos a introducir una matriz {}x{}\".format(n,n))\n", " for i in range(n):\n", " fila=input(\"Introduce los {} elementos de la fila {}: \".format(n,i)).split()\n", " for j in range(n):\n", " fila[j] = int(fila[j])\n", " m.append(fila)\n", " return m\n", "\n", "def Extrae8Vecinos(m,i,j):\n", " m2 = []\n", " for r in range(3):\n", " m2.append([0.0]*3)\n", " for r in range(3):\n", " for c in range(3):\n", " m2[r][c]= m[i-1+r][j-1+c]\n", " return m2\n", "def CalculaMedia(m):\n", " r = 0\n", " for i in range(len(m)):\n", " for j in range(len(m)):\n", " r = r + m[i][j]\n", " r = r / 9\n", " return r\n", "def AplicaMediaVecinos(m):\n", " M = []\n", " for r in range(n):\n", " M.append([0]*n)\n", " for i in range(1,n-1):\n", " for j in range(1,n-1):\n", " M[i][j]=CalculaMedia(Extrae8Vecinos(m1,i,j))\n", " return M\n", "def EscribeMatriz(M):\n", " print(\"La matriz {}x{} resultante es: \".format(len(M),len(M)))\n", " for i in range(n):\n", " for j in range(n):\n", " print(\"{0:3.2f}\".format(M[i][j]),end=' ')\n", " print()\n", "n=5\n", "m1=lee_matriz()\n", "EscribeMatriz(AplicaMediaVecinos(m1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ejercicio 7\n", "\n", "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:\n", "- LeeMatriz: debe leer una matriz mat de nxm de números reales. \n", "- ExtraeColumna: toma la matriz mat y una columna c, y nos devuelva un vector v con la columna c de la matriz. \n", "- CalculaMedia: nos devuelve la media de los elementos de un vector v. \n", "- CuentaVector: nos dice cuántos valores del vector v son mayores que un determinado num. \n", "- 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. \n", "- 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. \n", "\n", "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. \n", "\n", "Ejemplo:\n", "\n", "$\\begin{bmatrix}\n", "1 & 2 & -1 & 2 \\\\\n", "2 & 2 & 1 & 2 \\\\\n", "3 & 3 & 0 & 2 \\\\\n", "2 & 3 & -2 & 2 \\\\\n", "1 & 2.5 & 2 & 2 \\\\\n", "2 & 2.5 & 0 & 2 \\\\\n", "\\end{bmatrix}$\n", "\n", "CuentaMatriz construye el vector medias: [1.83, 2.5, , 2]\n", "\n", "Y el vector mayores: [4,2,2,0]\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Vamos a introducir una matriz 6x4\n", "Introduce los 4 elementos de la fila 0: 1 2 -1 2\n", "Introduce los 4 elementos de la fila 1: 2 2 1 2\n", "Introduce los 4 elementos de la fila 2: 3 3 0 2\n", "Introduce los 4 elementos de la fila 3: 2 3 -2 2\n", "Introduce los 4 elementos de la fila 4: 1 2.5 2 2\n", "Introduce los 4 elementos de la fila 5: 2 2.5 0 2\n", "La columna (1-4) con valores mayores a su media es: 1\n" ] } ], "source": [ "def lee_matriz():\n", " mat = []\n", " print(\"Vamos a introducir una matriz {}x{}\".format(n,m))\n", " for i in range(n):\n", " fila=input(\"Introduce los {} elementos de la fila {}: \".format(m,i)).split()\n", " for j in range(m):\n", " fila[j] = float(fila[j])\n", " mat.append(fila)\n", " return mat\n", "\n", "def ExtraeMatriz(mat, c):\n", " v = []\n", " for i in range(n):\n", " v.append(mat[i][c])\n", " return v\n", "\n", "def CalculaMedia(v):\n", " s = 0\n", " for i in range(len(v)):\n", " s = s + v[i]\n", " s = s/len(v)\n", " return s\n", "\n", "def CuentaVector(mat,s,c):\n", " r = 0\n", " for i in range(len(mat)):\n", " if s < mat[i][c]:\n", " r += 1\n", " return r\n", "\n", "def CuentaMatriz(mat):\n", " v = []\n", " for i in range(m):\n", " s = CalculaMedia(ExtraeMatriz(mat,i))\n", " r = CuentaVector(mat,s,i)\n", " v.append(r)\n", " return v\n", "\n", "def IndiceMaximo(v):\n", " max = v[0]\n", " pos = 1\n", " for i in range(1,len(v)):\n", " if max < v[i]:\n", " pos = i + 1\n", " return pos\n", "n = 6\n", "m = 4\n", "mat = lee_matriz()\n", "print(\"La columna (1-{}) con valores mayores a su media es: {}\".format(m,IndiceMaximo(CuentaMatriz(mat))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Ejercicio 8\n", "\n", "Queremos implementar las siguientes funciones:\n", "- LeeMatriz: recibe el número de filas f y columnas c y devuelve una matriz m de ese tamaño leída por teclado. \n", "- MediaMatriz: recibe una matriz m y devuelve la media aritmética de sus valores. \n", "- MaxDiferencia: recibe una matriz m y devuelve la mayor diferencia entre todos sus elementos. \n", "- 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%. \n", "- 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. \n", "- EscribeMatriz: escribe en pantalla una matriz. \n", "\n", "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. " ] }, { "cell_type": "code", "execution_count": 1270, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Itroduce el numero de filas: 3\n", "Introduce el numero de columnas: 3\n", "Vamos a introducir una matriz 3x3\n", "Introduce los 3 elementos de la fila 0: 1 2 3\n", "Introduce los 3 elementos de la fila 1: 3 1 2\n", "Introduce los 3 elementos de la fila 2: 2 3 1\n", "Introduce el numero umbral: 2\n", "Introduce el numero maximo de iteraciones: 2\n", "La matriz es: \n", "1.20 2.00 2.40 \n", "2.40 1.20 2.00 \n", "2.00 2.40 1.20 \n", "El numero de iteraciones ha sido: 1\n" ] } ], "source": [ "def lee_matriz(f,c):\n", " m = []\n", " print(\"Vamos a introducir una matriz {}x{}\".format(f,c))\n", " for i in range(f):\n", " fila=input(\"Introduce los {} elementos de la fila {}: \".format(c,i)).split()\n", " for j in range(c):\n", " fila[j] = float(fila[j])\n", " m.append(fila)\n", " return m\n", "def MediaMatriz(m):\n", " s = 0\n", " t = 0\n", " for i in range(len(m)):\n", " for j in range(len(m[0])):\n", " s = s + m[i][j]\n", " t += 1\n", " s = s/t\n", " return s\n", "\n", "def MaxDiferencia(m):\n", " minimo = m[0][0]\n", " maximo = m[0][0]\n", " d = 0\n", " for i in range(len(m)):\n", " for j in range(len(m[0])):\n", " if maximo < m[i][j]:\n", " maximo = m[i][j]\n", " elif minimo > m[i][j]:\n", " minimo = m[i][j]\n", " d = maximo -minimo\n", " return d\n", "\n", "def Compensa(m):\n", " s = MediaMatriz(m)\n", " for i in range(len(m)):\n", " for j in range(len(m[0])):\n", " if s > m[i][j]:\n", " m[i][j] = m[i][j] * 1.2\n", " elif s < m[i][j]:\n", " m[i][j] = m[i][j] * 0.8\n", " return m\n", "\n", "def CompensaIterativa(m,e,maxIt):\n", " i = 0\n", " while (e <=MaxDiferencia(m) and i != maxIt):\n", " Compensa(m)\n", " i += 1\n", " EscribeMatriz(m)\n", " return i\n", "def EscribeMatriz(m):\n", " print(\"La matriz es: \")\n", " for i in range(len(m)):\n", " for j in range(len(m[0])):\n", " print(\"{0:3.2f}\".format(m[i][j]),end=' ')\n", " print()\n", "\n", "f =int(input(\"Itroduce el numero de filas: \"))\n", "c = int(input(\"Introduce el numero de columnas: \"))\n", "m = lee_matriz(f,c)\n", "e = int(input(\"Introduce el numero umbral: \"))\n", "maxIt=int(input(\"Introduce el numero maximo de iteraciones: \"))\n", "print(\"El numero de iteraciones ha sido: {}\".format(CompensaIterativa(m,e,maxIt)))" ] }, { "cell_type": "code", "execution_count": 5006, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Introduce una frase: hola que tal estas? yo estoy muy bien, la verdad\n", "02011\n", "40010\n", "01000\n", "11001\n", "01100\n" ] } ], "source": [ "\n", "def f1(m):\n", " N = len(m)\n", " for i in range(N):\n", " for j in range(N):\n", " print(m[i][j],end='')\n", " print()\n", " \n", "def f2 (m,i,j):\n", " m[i][j]= m[i][j] + 1\n", "\n", "def f3(N):\n", " m = []\n", " for i in range(N):\n", " f = []\n", " for j in range(N):\n", " f.append(0)\n", " m.append(f)\n", " return m\n", "\n", "def f4(s):\n", " aux = ''\n", " for i in s:\n", " if i == 'a' or i == 'e' or i == 'i' or i == 'o' or i == 'u':\n", " aux = aux + i\n", " return aux\n", "\n", "def f5 (v):\n", " if v == 'a':\n", " return 0\n", " elif v == 'e':\n", " return 1\n", " elif v == 'i':\n", " return 2\n", " elif v == 'o':\n", " return 3\n", " elif v == 'u':\n", " return 4\n", "N = 5\n", "m=f3(N)\n", "s = input(\"Introduce una frase: \")\n", "s = f4(s)\n", "for i in range(1,len(s)):\n", " v1=f5(s[i-1])\n", " v2=f5(s[i])\n", " f2(m,v1,v2)\n", "f1(m)\n", " " ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.8" } }, "nbformat": 4, "nbformat_minor": 2 }