{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Práctica 05. Funciones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Índice de ejercicios\n",
    "\n",
    " \n",
    "[P5_01. Operaciones](#P5_01.      )  \n",
    "[P5_02. Figura](#P5_02.)   \n",
    "[P5_03. Multiplica listas](#P5_03.     )     \n",
    "[P5_04. Construye matriz de enteros](#P5_04.        )   \n",
    "[P5_05. Crea matriz ROMA](#P5_05.)   \n",
    "[P5_06. L invertida](#P5_06.         )   \n",
    "[P5_07. Cuadrado](#P5_07.          )     \n",
    "[P5_08. Cruz](#P5_08.)      \n",
    "[P5_09. Suma cuadrados](#P5_09.         )   \n",
    "[P5_10. Combina letras](#P5_10.         )\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P5_01.  \n",
    "Escribe una función que tome dos números enteros y muestre en pantalla su suma, su resta y su producto. Deberás leer los dos números en el programa principal y llamar a la función para que calcule y muestre los resultados.  \n",
    "Ejemplo:  \n",
    "~~~\n",
    "Escribe el primer número: 3  \n",
    "Escribe el segundo número: 5   \n",
    "La suma es 8, la resta es -2 y el producto es 15  \n",
    "\n",
    "~~~\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola\n"
     ]
    }
   ],
   "source": [
    "# Escribe aquí tu programa\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P5_02.  \n",
    "Escribe una funciòn que reciba como parámetros de entrada un entero y dos caracteres. El primer carácter será ‘t’ si la figura es un triángulo y ‘c’ si es un cuadrado. El segundo carácter será el que usaremos para hacer la figura. Escribe ahora un programa principal que lea un número entero y dos caracteres y llame a la función que mostrará una figura como las de los ejemplos.   \n",
    "Ejemplos:    \n",
    "~~~\n",
    "Escribe un número: 3                   Escribe un número: 4  \n",
    "Escribe un carácter (t/c): t           Escribe un carácter (t/c): c  \n",
    "Escribe otro carácter: G               Escribe otro carácter: @  \n",
    "\n",
    "      G                                         @ @ @ @\n",
    "      G G                                       @ @ @ @\n",
    "      G G G                                     @ @ @ @ \n",
    "                                                @ @ @ @ \n",
    "\n",
    "~~~\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu programa\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P5_03.  \n",
    "Escribe un programa que almacene números en dos listas de tamaño **N** (**N** constante conocida) y construya otra lista que contenga la multiplicación de las anteriores elemento a elemento. Diseñaremos una función que almacene **una** lista que usaremos para leer los vectores en dos llamadas sucesivas desde el programa principal. También crearemos una función que construya y devuelva al programa principal el vector resultante a partir de los iniciales y finalmente diseñaremos otra función que muestre por pantalla **un** vector. Utilizando esta función en tres llamadas sucesivas mostraremos los vectores en el monitor.     \n",
    "Ejemplo: (para **N**=6)  \n",
    "~~~\n",
    "Escribe 6 números separados por espacios: 2   2   6   3  11   5  \n",
    "Escribe otros 6 números: 1   7   8  16   4   6   \n",
    "La lista a es: 2   2   6   3  11   5  \n",
    "La lista b es: 1   7   8  16   4   6  \n",
    "La lista c es: 2  14  48  48  44  30\n",
    "\n",
    "~~~\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu programa\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P5_04.  \n",
    "Escribe una función que devuelva una matriz **m**(**N**x**N**) a partir de una lista de **N** enteros menores o iguales que  **N** (**N** constante conocida). La matriz debe ser construida de la siguiente forma: Cada columna estará formada por la secuencia decreciente que comienza con el elemento correspondiente de la lista inicial.  \n",
    "Deberás diseñar también una función para leer una lista (puedes reutilizar la del ejercicio P5_04) y otra función que usaremos para mostrar la matriz en la pantalla.  \n",
    "Ejemplo: (para N=7)  \n",
    "~~~\n",
    "Escribe los 7 elementos de la lista: 4  3  1  7  2  3  0\n",
    "La matriz m es:  \n",
    "\n",
    "\t4  3  1  7  2  3  0\n",
    "\t3  2  0  6  1  2  0\n",
    "\t2  1  0  5  0  1  0\n",
    "\t1  0  0  4  0  0  0\n",
    "\t0  0  0  3  0  0  0\n",
    "\t0  0  0  2  0  0  0\n",
    "\t0  0  0  1  0  0  0\n",
    "~~~\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu programa\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P5_05.  \n",
    "Escribe una función que tome como parámetros de entrada una cadena de caracteres (en mayúsculas) y una lista de enteros de tamaño **n** (**n** la conseguiremos usando **len()** sobre la palabra introducida). Los enteros de la segunda lista deben ser menores o iguales que **n**. La función  devolverá al programa principal una matriz (**n**x**n**) donde las letras del primer vector estarán distribuidas como en el ejemplo.       \n",
    "Ejemplo:  \n",
    "~~~\n",
    "Escribe una palabra: ROMA  \n",
    "Escribe 4 números entre 1 y 4: 4 2 1 3  \n",
    "La matriz resultante es:  \n",
    "\n",
    "\tR\n",
    "\tR           A\n",
    "\tR   O       A\n",
    "\tR   O   M   A\n",
    "\n",
    "~~~\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu programa\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P5_06.  \n",
    " \n",
    "\n",
    "Escribe una función **lee_matriz** que lea desde teclado una matriz **m**(**N**x**N** con **N** constante conocida).  A continuación diseña una función **suma_valores** que tome dos valores **k, r < N**  leídos en el programa principal y una matriz **m** y devuelva la suma de los valores de la matriz que forman una L invertida con esquina en la posición **[k, r]**, tal como se indica en el dibujo. Finalmente, escribe el programa principal que llame a las funciones anteriores obteniendo el resultado indicado.      \n",
    "Ejemplo: (para N=5)   \n",
    "~~~\n",
    "Escribe una matriz 5x5:   \n",
    "\n",
    "\t3   4   1   5   6\n",
    "\t1   2   3   7   2\n",
    "\t6   2   9   4   1\n",
    "\t5   2   8   4   3\n",
    "    5   9   2   5   3  \n",
    "    \n",
    "Escribe un número que indique la fila(k): 1\n",
    "Escribe otro número para la columna(r): 3\n",
    "El resultado es: 26\n",
    "~~~\n",
    "Nota: la función SUMA devolverá 26 que es el resultado de 1 + 2 + 3 + 7 + 4 + 4 + 5.  \n",
    "\n",
    "   3   4   1   5   6   \n",
    "   **1   2   3   7**   2  \n",
    "   6   2   9   **4**   1  \n",
    "   5   2   8   **4**   3    \n",
    "   5   9   2   **5**   3 \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "### Escribe aquí tu programa\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P5_07.  \n",
    "\n",
    "Escribe una función que tome como parámetro de entrada una lista de **N** (**N** constante conocida) números enteros y devuelva una matriz cuadrada de tamaño **M**x**M** como la del ejemplo (**M** constante conocida asumiendo que cumple **N**<=**M**x**M**). Construiremos otra función para mostrar la matriz por pantalla.  \n",
    "Si los números de la lista no llenan la matriz, la completaremos con ceros.  \n",
    "Ejemplo: (para **N**=14, **M**=4)  \n",
    "~~~\n",
    "Para la lista: 5  34  9  1  4  1  3  72  8  2  5  7  6  9   \n",
    "La matriz resultante es:  \n",
    "\n",
    "\t5  34   9   1\n",
    "\t4   1   3  72\n",
    "\t8   2   5   7\n",
    "\t6   9   0   0\n",
    "~~~\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu programa\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P5_08.  \n",
    "\n",
    "Escribe una función que tome como parámetros de entrada una matriz **m** de dimensión **N**x**N** (**N** constante conocida) y una lista **v** de **N** valores entre 0 y **N**-1. La función devolverá una nueva lista de valores calculados de la siguiente forma: El elemento **i** de la nueva listá será el resultado de sumar los elementos de **m** correspondientes a la columna **v[i]** y restar los de la fila **v[i]**.\n",
    "La función también devolverá la suma de todos los elementos de matriz. \n",
    "Ejemplo: (para **N**=3)   \n",
    "~~~\n",
    "Para la matriz 3x3:  \n",
    "\n",
    "\t7   4   3\n",
    "\t2   9   1\n",
    "\t3   6   4  \n",
    "    \n",
    "y la lista: 2  0  1  \n",
    "\n",
    "La nueva lista es [-5, -2, 7] y la suma total es 39\n",
    "~~~\n",
    "Nota: El primer elemento de la nueva lista es el resultado de sumar la columna 2: (3, 1, 4) y restar la fila 2: ( 3, 6, 4), resultando -5. De igual manera calcularemos los otros dos componentes de la nueva lista.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu programa\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P5_09.  \n",
    "\n",
    "Diseña las funciones **suma_cuadrado_sup** y **suma_cuadrado_inf**. La primera tomará la matriz  cuadrada **m**(**N**x**N**), (**N** constante conocida)  y un valor entero **sup** y devolverá la suma de los valores de la matriz que están en una posición cuya fila y columna sean menores o iguales que **sup** y la segunda tomará la matriz **m** y otro valor **inf** y devolverá la suma de los valores de la matriz cuya fila y columna sean mayores o iguales que **inf**.\n",
    "Además tenemos una función **lectura** que lee desde teclado una matriz **m**(**N**x**N**). Escribe finalmente un programa principal que utilizando las funciones anteriores, lea una matriz  y dos enteros y nos devuelva en pantalla la diferencia en valor absoluto de las sumas realizadas.\n",
    "Para facilitar las pruebas, se ha definido una matriz 7x7.  \n",
    "Ejemplo (para **N**=7): \n",
    "~~~\n",
    "Escribe una matriz 7x7:  \n",
    "    \n",
    "   3    4    2    1    0    6    2\n",
    "   6    8    1    1    3    8    0\n",
    "   3    4    1    7    2    3    5\n",
    "   5    2    6    4    5    8    1\n",
    "   4    1    4    5    8    1    1\n",
    "   6    2    4    2    8    5    6\n",
    "   7    3    5    2    2    3    1  \n",
    "   \n",
    "Escribe el extremo superior (sup): 2\n",
    "Escribe el extremo inferior (inf): 5\n",
    "El resultado es: 17\n",
    "   ~~~\n",
    "Llamando a **suma_cuadrado_sup**, obtenemos 32 y llamando a **suma_cuadrado_inf** obtenemos 15. Por tanto, la diferencia en valor absoluto es 17.   \n",
    "\n",
    "   **3   4   2**   1   0   6   2  \n",
    "   **6\t8\t1**\t1      \t3\t8\t0  \n",
    "   **3\t4\t1**\t7\t2\t3\t5  \n",
    "     5\t2\t6\t4\t5\t8\t1      \n",
    "   4\t1\t4\t5\t8\t1\t1  \n",
    "   6\t2\t4\t2\t8\t**5\t 6**  \n",
    "   7\t3\t5\t2\t2\t**3\t 1**  \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu programa\n",
    "\n",
    "N = 7\n",
    "m = [[3, 4, 2, 1, 0, 6, 2], [6, 8, 1, 1, 3, 8, 0], [3, 4, 1, 7, 2, 3, 5],\n",
    "     [5, 2, 6, 4, 5, 8, 1], [4, 1, 4, 5, 8, 1, 1], [6, 2, 4, 2, 8, 5, 6], \n",
    "     [7, 3, 5, 2, 2, 3, 1]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### P5_10.  \n",
    "\n",
    "Diseña una función que tome tres palabras y devuelva un booleano diciéndonos si la tercera palabra se puede formar combinando letras de las otras dos. Si la función recibe las palabras **'LACA'**, **'REMO'** Y **'MACERO'**, devolverá **True**.  \n",
    "Si la función recibe las palabras **'LACA'**, **'REMO'** Y **'CAMELLO'**, devolverá **False** ya que nos falta una **'L'**.   \n",
    "El programa principal leera ahora una frase y llamando a la función nos dirá si cada palabra (a partir de la tercera) se puede formar con las dos que le preceden. Validaremos que la frase tiene al menos 3 palabras.  \n",
    "Ejemplo:  \n",
    "~~~\n",
    "Escribe una frase: la casa  \n",
    "Debe tener al menos 3 palabras.   \n",
    "Escribe una frase:  Esta masa verde es claramente rala\n",
    "VERDE       ----->  False \n",
    "ES          ----->  True  \n",
    "CLARAMENTE  ----->  False \n",
    "RALA        ----->  True \n",
    "   ~~~\n",
    "'es' se puede formar combinando letras de 'masa' y 'verde'.  \n",
    "'rala' se puede formar combinando letras de 'es' y 'claramente'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu programa\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Create Assignment",
  "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
}