Assignments/PT-BR/Assignment_2_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Crie uma função chamada **\"quadrado\\_par\"** que receba como entrada um valor inteiro **N**, e retorne uma lista contendo, em ordem crescente, o quadrado de cada um dos valores pares, de 1 até N, incluindo N se for o caso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 16, 36, 64, 100, 144, 196]\n"
     ]
    }
   ],
   "source": [
    "def quadrado_par(N):\n",
    "    '''Recebe um inteiro positivo N e retorna uma lista dos quadrados dos numeros pares de 1 a N'''\n",
    "    return [x**2 for x in range(2,N+1,2)]\n",
    "\n",
    "print(quadrado_par(15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2) Fazendo uso de um loop while e da função input, leia uma quantidade indefinida de **números inteiros** até que o número lido seja **-1**. Após esse processo, imprima duas listas na tela: A primeira contendo os elementos pares digitados, e a segunda contendo os elementos ímpares. Ambas devem estar em ordem crescente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Insira um indeiro: 1\n",
      "Insira um indeiro: 2\n",
      "Insira um indeiro: -1\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2]\n",
      "[1]\n"
     ]
    }
   ],
   "source": [
    "par, impar = [], []\n",
    "while 1:\n",
    "    lido = int(input(\"Insira um inteiro:\"))\n",
    "    if lido == -1:\n",
    "        break\n",
    "    if lido%2:\n",
    "        impar.append(lido)\n",
    "    else:\n",
    "        par.append(lido)\n",
    "print(sorted(par))\n",
    "print(sorted(impar))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3) Crie uma função chamada **\"conta\\_par\"** que recebe uma lista de inteiros, conta a quantidade de elementos pares existentes, e retorna essa contagem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "def conta_par(l):\n",
    "    '''Recebe uma lista de inteiros e retorna o valor correspondente à quantidade de números pares desta'''\n",
    "    return len(list(filter(lambda x:x%2==0,l)))\n",
    "\n",
    "print(conta_par([1,5,2,6,8,13,27,154,20,22,25,17]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4) Crie uma função chamada **\"lista\\_ao\\_quadrado\"** que receba uma lista de inteiros e retorne outra lista cujos elementos são os quadrados dos elementos da primeira."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 16, 4, 36]\n"
     ]
    }
   ],
   "source": [
    "def lista_ao_quadrado(l):\n",
    "    '''Recebe uma lista de interios e retorna outra lista com os quadrados de cada um dos elementos da original'''\n",
    "    return list(map(lambda x: x**2, l)) # [element ** 2 for element in l]\n",
    "\n",
    "print(lista_ao_quadrado([1,3,4,2,6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5) Crie uma função chamada **\"decrescente\"** que receba duas listas de inteiros e retorne uma lista única, que contenha todos os elementos das demais em ordem decrescente, podendo incluir elementos repetidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 6, 5, 4, 3, 3, 2, 2, 1, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "def decrescente(A,B):\n",
    "    '''Recebe duas listas de inteiros e retorna uma lista com os elementos de ambas em ordem decrescente'''\n",
    "    C=A+B\n",
    "    C.sort(reverse=True)\n",
    "    return C\n",
    "\n",
    "print(decrescente([1,3,2,4,7],[0,6,5,2,1,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6) Crie uma função chamada **\"adiciona\"** que receba uma lista **A**, e uma quantidade indeterminada de inteiros como entrada; Retorne uma nova lista contendo os elementos de **A** mais os inteiros passados como entrada, na ordem em que foram dados. Segue o exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> A = [10,20,30]\n",
    ">>>> adiciona(A, 4, 10, 50, 1)\n",
    "> [10, 20, 30, 4, 10, 50, 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 10, 15, 20, 11, 25, 30, 35, 40, 45, 127, 12]\n"
     ]
    }
   ],
   "source": [
    "def adiciona(A,*inteiros):\n",
    "    '''Recebe uma lista de inteiros e uma quantidade indefinida de inteiros e retorna uma lista\\\n",
    "    com a lista original extendida com todos os inteiros dados'''\n",
    "    A.extend(inteiros)\n",
    "    return A\n",
    "\n",
    "print(adiciona([5,10,15,20,11],25,30,35,40,45,127,12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7) Crie uma função chamada **\"intercept\"** que receba duas listas de entrada e retorne uma outra lista com os valores que pertencem às duas listas simultaneamente (interseção) sem repetição de valores e em ordem crescente. Use a apenas a estrutura de listas e os comandos de loop e condicionais já vistos. Veja o exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> A = [-2, 0, 1, 2, 3]\n",
    ">>>> B = [-1, 2, 3, 6, 8]\n",
    ">>>> intercept(A,B)\n",
    "> [2, 3]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "def intercept(A,B):\n",
    "    '''Recebe duas listas de inteiros e retorna uma lista com os elementos comuns em ordem crescente'''\n",
    "    C = [value for value in A if value in B]\n",
    "    res = []    \n",
    "    [res.append(x) for x in C if x not in res]\n",
    "    return sorted(res)\n",
    "\n",
    "print(intercept([1,3,2,2,7,4],[2,4,8,16]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8) Crie uma função chamada **\"union\"** que receba duas listas de entrada e retorne uma outra lista com a união dos elementos das duas recebidas, sem repetição de elementos e em ordem crescente. Use apenas a estrutura de listas e os comandos de loop e condicionais já vistos. Veja exemplo:\n",
    "\n",
    ">```python\n",
    ">>>> A = [-2, 0, 1, 2]\n",
    ">>>> B = [-1, 1, 2, 10]\n",
    ">>>> union(A,B)\n",
    "> [-2, ,-1, 0, 1, 2, 10]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "def union(A,B):\n",
    "    '''Recebe duas listas de inteiros e retorna uma lista com todos os\\\n",
    "    elementos das originais em ordem crescente e sem repetições'''\n",
    "    C = A+B\n",
    "    res = []\n",
    "    [res.append(x) for x in C if x not in res]\n",
    "    return sorted(res)\n",
    "\n",
    "print(union([1,3,2],[4,6,5,3,2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9) Generalize a função **\"intercept\"** para que ela receba uma quantidade indefinida de listas e retorne a interceção de todas elas. Chame a nova função de **intercept2**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "import functools\n",
    "\n",
    "def intercept2(*lists):\n",
    "    '''Recebe uma quantidade indefinida de listas de inteiros e retorna uma\\\n",
    "    lista contendo os elementos comuns a todas elas em ordem crescente e sem repetições'''\n",
    "    return functools.reduce(intercept,lists)\n",
    "\n",
    "print(intercept2([1,2,3,4,5,6],[1,2,4,8],[2,4,6,8],[2,3,4,5,6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desafio\n",
    "\n",
    "10) Iremos construir uma função chamada **\"matriz\"** que executa a operação de multiplicação de matrizes.\n",
    "    \n",
    "Seja a matriz:\n",
    "    \n",
    "$A_{m\\times n}=\n",
    "\\left[\\begin{matrix}\n",
    "a_{11}&a_{12}&...&a_{1n}\\\\\n",
    "a_{21}&a_{22}&...&a_{2n}\\\\\n",
    "\\vdots &\\vdots &&\\vdots\\\\\n",
    "a_{m1}&a_{m2}&...&a_{mn}\\\\\n",
    "\\end{matrix}\\right]$\n",
    "    \n",
    "No python, representaremos a matriz acima como uma lista de listas, onde cada lista interna representa uma linha da matriz original.\n",
    "\n",
    "$A = [[a_{11},a_{12},...,a_{1n}],[a_{21},a_{22},...,a_{2n}], . . . ,[a_{m1},a_{m2},...,a_{mn}]]$\n",
    "\n",
    "A sua função **\"matriz\"** dever receber duas matrizes $A$ e $B$ no formato especificado, e retornar $A\\times B$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5, 2, 1], [2, 1, 1], [15, 6, 3]]\n"
     ]
    }
   ],
   "source": [
    "def matriz(A, B):\n",
    "    '''Recebe duas matrizes em formato de lista de listas e retorna, no mesmo formato, a multiplicação matricial das mesmas'''\n",
    "    if len(A)!=len(B[0]) or len(A[0])!=len(B):\n",
    "        raise ValueError('Dimensões incompatíveis com a multiplicação')\n",
    "    m, n , lst, C, element= len(B[0]), len(A), [], [], 0\n",
    "    for i in range(n):\n",
    "        for j in range(m):\n",
    "            for k in range(len(B)):\n",
    "                element+=A[i][k]*B[k][j]\n",
    "            lst.append(element)\n",
    "            element = 0\n",
    "        C.append(lst) \n",
    "        lst= []\n",
    "    return C\n",
    "\n",
    "X=[[1,0],[0,1],[3,0]]\n",
    "Y=[[5,2,1],[2,1,1]]\n",
    "print(matriz(X,Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Dimensões incompatíveis com a multiplicação",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-98df6d768bc8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmatriz\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-14-8cd6af7233a8>\u001b[0m in \u001b[0;36mmatriz\u001b[0;34m(A, B)\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;34m'''Recebe duas matrizes em formato de lista de listas e retorna, no mesmo formato, a multiplicação matricial das mesmas'''\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m!=\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mB\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m!=\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mB\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Dimensões incompatíveis com a multiplicação'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0mm\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m \u001b[0;34m,\u001b[0m \u001b[0mlst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mC\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0melement\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mB\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: Dimensões incompatíveis com a multiplicação"
     ]
    }
   ],
   "source": [
    "matriz([[1,2],[4,5]],[[1,2],[2,3],[3,4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Correção"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      ".........\n",
      "----------------------------------------------------------------------\n",
      "Ran 9 tests in 0.007s\n",
      "\n",
      "OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<unittest.main.TestProgram at 0x7f22196a2130>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import unittest\n",
    "\n",
    "class TestLista02(unittest.TestCase):\n",
    "\n",
    "    def test_quadrado_par(self):\n",
    "        self.assertEqual(quadrado_par(25),[4, 16, 36, 64, 100, 144, 196, 256, 324, 400, 484, 576])\n",
    "        self.assertEqual(quadrado_par(1),[])\n",
    "        self.assertEqual(quadrado_par(123),[4, 16, 36, 64, 100, 144, 196, 256, 324, 400, 484, 576,\\\n",
    "                                            676, 784, 900, 1024, 1156, 1296, 1444, 1600, 1764, 1936,\\\n",
    "                                            2116, 2304, 2500, 2704, 2916, 3136, 3364, 3600, 3844, 4096,\\\n",
    "                                            4356, 4624, 4900, 5184, 5476, 5776, 6084, 6400, 6724, 7056,\\\n",
    "                                            7396, 7744, 8100, 8464, 8836, 9216, 9604, 10000, 10404, 10816,\\\n",
    "                                            11236, 11664, 12100, 12544, 12996, 13456, 13924, 14400, 14884])\n",
    "\n",
    "    '''Questão 2 corrigida manualmente'''\n",
    "    \n",
    "    def test_conta_par(self):\n",
    "        self.assertEqual(conta_par([1,2,3,8,46,12,0,13,27,135,26,168,1649]),7)\n",
    "        self.assertEqual(conta_par([827, 647, 664, 270, 561, 665, 781, 69, 245, 324, 957, 911, 213, 9, 93]),3)\n",
    "        self.assertEqual(conta_par([422, 11, 469, 340, 717, 310, 956, 220, 557, 804, 751, 908, 917, 524, 234, 308]),10)\n",
    "        \n",
    "\n",
    "\n",
    "    def test_lista_ao_quadrado(self):\n",
    "        self.assertEqual(lista_ao_quadrado([697, 983, 600, 651, 747, 884, 769]),\\\n",
    "                        [485809, 966289, 360000, 423801, 558009, 781456, 591361])\n",
    "        self.assertEqual(lista_ao_quadrado([96, 89, 35, 38, 19, 12, 63, 24, 81]),\\\n",
    "                        [9216, 7921, 1225, 1444, 361, 144, 3969, 576, 6561])\n",
    "        self.assertEqual(lista_ao_quadrado([4, 52, 95, 71, 64, 42, 44, 9, 77, 41]),\\\n",
    "                        [16, 2704, 9025, 5041, 4096, 1764, 1936, 81, 5929, 1681])\n",
    "\n",
    "\n",
    "    def test_decrescente(self):\n",
    "        self.assertEqual(decrescente([54, 23, 9, 63, 26, 60, 85, 84, 62, 42, 28, 23, 64, 2, 73],\\\n",
    "                                    [46, 94, 89, 14, 2, 40, 1, 3, 10, 7]),\\\n",
    "                        [94, 89, 85, 84, 73, 64, 63, 62, 60, 54, 46, 42, 40, 28, 26, 23, 23, 14, 10, 9, 7, 3, 2, 2, 1])\n",
    "        self.assertEqual(decrescente([69, 52, 4, 21, 51],\\\n",
    "                                    [71, 7, 86, 100, 18, 90]),\\\n",
    "                        [100, 90, 86, 71, 69, 52, 51, 21, 18, 7, 4])\n",
    "        self.assertEqual(decrescente([74, 22, 32, 52, 45, 29, 99, 54, 3, 21, 54, 5, 26],\\\n",
    "                                    [58, 72, 16, 69, 56, 49, 6, 52]),\\\n",
    "                        [99, 74, 72, 69, 58, 56, 54, 54, 52, 52, 49, 45, 32, 29, 26, 22, 21, 16, 6, 5, 3])\n",
    "        \n",
    "        \n",
    "\n",
    "    def test_adiciona(self):\n",
    "        self.assertEqual(adiciona([95, 23],51, 51, 96, 47, 45, 23, 64, 2, 10, 75, 49),\\\n",
    "                        [95, 23, 51, 51, 96, 47, 45, 23, 64, 2, 10, 75, 49])\n",
    "        self.assertEqual(adiciona([47, 99, 22, 45, 18, 90, 81, 27, 79, 49, 52, 33, 95],33, 88, 89, 93, 9, 29, 95, 94, 12, 36, 6, 0),\\\n",
    "                        [47, 99, 22, 45, 18, 90, 81, 27, 79, 49, 52, 33, 95, 33, 88, 89, 93, 9, 29, 95, 94, 12, 36, 6, 0])\n",
    "        self.assertEqual(adiciona([56, 96, 21, 57, 70],29, 13, 100, 18, 96, 73, 25, 50, 39),\\\n",
    "                        [56, 96, 21, 57, 70, 29, 13, 100, 18, 96, 73, 25, 50, 39])\n",
    "\n",
    "\n",
    "    def test_intercept(self):\n",
    "        self.assertEqual(intercept([37, 94, 61, 12, 50, 37, 10],[36, 2, 76, 31, 67, 2, 40]),[])\n",
    "        self.assertEqual(intercept([67, 19, 76, 31, 55, 53],[76, 7, 24, 48, 8]),[76])\n",
    "        self.assertEqual(intercept([7, 3, 9, 3, 3, 5, 7, 1],[4, 2, 4, 4, 7, 5, 1, 9]),[1, 5, 7, 9])\n",
    "        \n",
    "\n",
    "    def test_union(self):\n",
    "        self.assertEqual(union([1, 3, 42, 23, 14, 28, 86, 86, 0, 68],[52, 18, 11, 14, 27, 38, 79, 51, 38]),\\\n",
    "                        [0, 1, 3, 11, 14, 18, 23, 27, 28, 38, 42, 51, 52, 68, 79, 86])\n",
    "        self.assertEqual(union([4, 5, 9, 3, 9, 6, 9, 10, 3, 6],[1, 8, 3, 1, 8, 10, 3, 6, 8, 9, 5, 10, 6]),\\\n",
    "                        [1, 3, 4, 5, 6, 8, 9, 10])\n",
    "        self.assertEqual(union([6, 0, 2, 4, 4, 0, 7, 5, 1, 5],[2, 1, 7]),\\\n",
    "                        [0, 1, 2, 4, 5, 6, 7])\n",
    "        \n",
    "    def test_intercept2(self):\n",
    "        self.assertEqual(intercept2([2, 4, 5, 0, 4, 3, 5, 2, 2, 0, 0, 3],\\\n",
    "                                    [1, 5, 4, 5, 4, 3, 4, 3, 5, 4, 2, 0, 0, 0],\\\n",
    "                                    [0, 0, 5, 1, 4, 4, 4, 3, 4, 2, 1, 5, 3, 3],\\\n",
    "                                    [4, 3, 4, 2, 5, 0, 3, 1, 0, 4, 4],\\\n",
    "                                    [3, 5, 0, 5, 0, 0, 5, 4, 0, 4, 0, 2, 3, 4],\\\n",
    "                                    [2, 0, 1, 0, 5, 2, 3, 2, 4, 5, 2, 4, 2],\\\n",
    "                                    [1, 4, 5, 3, 1, 5, 2, 2, 5, 1, 1, 5, 1, 0, 5],\\\n",
    "                                    [3, 2, 1, 5, 1, 0, 5, 5, 2, 2, 2, 5, 0, 4, 5],\\\n",
    "                                    [4, 5, 3, 3, 4, 1, 1, 1, 0, 5],\\\n",
    "                                    [2, 2, 1, 2, 4, 3, 1, 2, 5, 3, 4, 4, 3]),\\\n",
    "                         [3, 4, 5])\n",
    "        self.assertEqual(intercept2([4, 4, 5, 1, 0, 3, 0, 4, 5, 2, 5, 2, 3],\\\n",
    "                                    [3, 2, 2, 2, 5, 3, 3, 2, 0, 1, 4],\\\n",
    "                                    [4, 1, 2, 3, 0, 0, 2, 3, 3, 2, 3, 3, 4],\\\n",
    "                                    [1, 3, 1, 4, 4, 5, 4, 4, 5, 2, 5],\\\n",
    "                                    [3, 4, 3, 1, 3, 2, 3, 2, 5, 1, 1],\\\n",
    "                                    [1, 0, 0, 3, 1, 2, 4, 0, 0, 4, 2, 4, 2, 0]),\\\n",
    "                        [1, 2, 3, 4])\n",
    "        self.assertEqual(intercept2([5, 4, 0, 3, 5, 1, 0, 3, 1, 3],\\\n",
    "                                    [1, 5, 4, 2, 1, 0, 4, 3, 4, 3],\\\n",
    "                                    [4, 5, 3, 3, 5, 2, 2, 3, 0, 0, 4, 4, 5],\\\n",
    "                                    [2, 2, 4, 2, 5, 0, 0, 5, 4, 4, 1, 3, 0, 4],\\\n",
    "                                    [1, 4, 3, 5, 3, 0, 3, 0, 3, 1],\\\n",
    "                                    [3, 1, 3, 4, 2, 2, 4, 2, 0, 0, 3, 3, 5, 3, 3]),\\\n",
    "                        [0, 3, 4, 5])\n",
    "\n",
    "\n",
    "    def test_matriz(self):\n",
    "        self.assertEqual(matriz([[97, 22, 30, 3, 49, 16, 10, 55, 53], [83, 50, 62, 13, 51, 18, 28, 89, 17],\\\n",
    "                                 [12, 4, 99, 90, 70, 76, 84, 59, 96], [59, 7, 81, 91, 81, 94, 45, 91, 57]],\\\n",
    "                               [[27, 94, 22, 22], [33, 14, 81, 91], [75, 28, 13, 51], [79, 70, 53, 78],\\\n",
    "                                [19, 29, 93, 99], [18, 8, 50, 3], [31, 92, 63, 66], [81, 49, 53, 75], [34, 2, 64, 49]]),\\\n",
    "                        [[13618, 15746, 16759, 18181], [19516, 19742, 20583, 25011], [28336, 23705, 31518, 34528],\\\n",
    "                         [29023, 26096, 31280, 34053]])\n",
    "        \n",
    "        self.assertEqual(matriz([[7, 45, 49, 39, 4], [0, 26, 88, 44, 51], [32, 69, 16, 99, 10], [17, 15, 37, 19, 20]],\\\n",
    "                               [[56, 77, 33, 39], [40, 94, 1, 95], [20, 55, 55, 72], [40, 75, 86, 13], [20, 29, 82, 25]]),\\\n",
    "                        [[4812, 10505, 6653, 8683], [5580, 12063, 12832, 10653], [9032, 17545, 11339, 10492], [3452, 6759, 5885, 5499]])\n",
    "        self.assertEqual(matriz([[80, 56], [44, 22], [8, 63]],[[88, 18, 100], [94, 37, 95]]),\\\n",
    "                        [[12304, 3512, 13320], [5940, 1606, 6490], [6626, 2475, 6785]])\n",
    "        \n",
    "\n",
    "unittest.main(argv=['first-arg-is-ignored'], exit=False)"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}