EJERCICIOS01-Conjuntos_RESUELTOS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/keepcoding.png\" width=200 align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/me.jpg\" width=150 align=\"right\">\n",
    "\n",
    "# Ejercicios de Conjuntos\n",
    "\n",
    "Autor: Carlos Moreno Morera\n",
    "\n",
    "Contacto: carlos.moreno@ibm.com\n",
    "\n",
    "Última revisión: 10/Jul/2022"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 1:\n",
    "Definir en Python los siguientes conjuntos:\n",
    "1. El conjunto de los satélites de la Tierra.\n",
    "2. Los posibles resultados al tirar un dado de 6 caras y una moneda.\n",
    "3. Todos los cuadrados perfectos (números naturales elevados al cuadrado) de los números naturales menores que 11."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'La Luna'}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1.1\n",
    "{'La Luna'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{(1, 'cara'), (4, 'cruz'), (2, 'cruz'), (5, 'cruz'), (4, 'cara'), (3, 'cruz'), (6, 'cruz'), (1, 'cruz'), (2, 'cara'), (3, 'cara'), (5, 'cara'), (6, 'cara')}\n"
     ]
    }
   ],
   "source": [
    "#1.2\n",
    "print({(dado, moneda) for dado in range(1,7) for moneda in {'cara', 'cruz'}})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 64, 4, 36, 100, 9, 16, 49, 81, 25}\n"
     ]
    }
   ],
   "source": [
    "#1.3\n",
    "print({x**2 for x in range(0, 11)})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 2:\n",
    "1. Sin utilizar el método `isdisjoint`, implementar una función *sondisjuntos(A, B)* que devuelva verdadero cuando los conjuntos pasados por parámetros sean disjuntos y falso en caso contrario.\n",
    "2. Repetir el apartado anterior sin utilizar el método `intersection` ni el operador `&`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#2.1\n",
    "def sondisjuntos(A,B):\n",
    "    return len(A & B) == 0\n",
    "\n",
    "print(sondisjuntos({1,2,3}, {3,4,5}))\n",
    "print(sondisjuntos(set(), {3,4,5}))\n",
    "print(sondisjuntos({1,2,3}, {4,5}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#2.2\n",
    "def sondisjuntos(A,B):\n",
    "    for a in A:\n",
    "        if a in B:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "print(sondisjuntos({1,2,3}, {3,4,5}))\n",
    "print(sondisjuntos(set(), {3,4,5}))\n",
    "print(sondisjuntos({1,2,3}, {4,5}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 3:\n",
    "Sin utilizar el método `issubset` ni el operador `<=`, implementar una función *essubconjunto(A,B)* que devuelva verdadero cuando el primer conjunto pasado por parámetro sea subconjunto del segundo y falso en caso contrario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#3\n",
    "def essubconjunto(A,B):\n",
    "    for a in A:\n",
    "        if a not in B:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "print(essubconjunto({1,2}, {1,2,3}))\n",
    "print(essubconjunto(set(), {1,2,3,4}))\n",
    "print(essubconjunto({0,1}, {1,2,3,4}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 4:\n",
    "Sin utilizar la función `len`, implementar una función *cardinal(A)* que devuelva el cardinal del conjunto que se le pasa por parámetro:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#4\n",
    "def cardinal(A):\n",
    "    card = 0\n",
    "    for a in A:\n",
    "        card += 1\n",
    "    return card\n",
    "\n",
    "print(cardinal(set()))\n",
    "print(cardinal({1,2,3,4}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 5:\n",
    "Sin utilizar la función `producto` vista en teoría ni la definición por comprensión, implementar una función *productocartesiano(A, B)* que dados dos conjuntos pasados por parámetro devuelva el producto cartesiano de dichos conjuntos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n",
      "{(3, 4), (4, 3), (3, 1), (5, 4), (4, 6), (5, 1), (2, 2), (1, 6), (2, 5), (1, 3), (6, 2), (6, 5), (4, 2), (4, 5), (3, 3), (5, 6), (3, 6), (5, 3), (2, 4), (1, 2), (2, 1), (1, 5), (6, 1), (6, 4), (3, 2), (4, 1), (3, 5), (5, 2), (4, 4), (5, 5), (1, 1), (1, 4), (2, 3), (2, 6), (6, 6), (6, 3)}\n"
     ]
    }
   ],
   "source": [
    "#5\n",
    "def productocartesiano(A, B):\n",
    "    resultado = set()\n",
    "    for a in A:\n",
    "        for b in B:\n",
    "            resultado.add((a,b))\n",
    "    return resultado\n",
    "print(productocartesiano(set(), {1,2}))\n",
    "print(productocartesiano({1,2,3,4,5,6}, {1,2,3,4,5,6}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ♦️Ejercicio 6:\n",
    "Implementar una función *binarios(n)* que devuelva el conjunto de todas las cadenas de caracteres de tamaño *n* (el número natural pasado por parámetro) que se pueden construir con ceros y unos. Por ejemplo:\n",
    "$$\n",
    "\\text{binarios}(3)=\\{000,001,010,100, 110, 101, 011, 111\\}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'101', '010', '000', '001', '110', '011', '100', '111'}\n",
      "{'101', '010', '000', '110', '001', '011', '100', '111'}\n",
      "{'101', '010', '000', '110', '001', '011', '100', '111'}\n"
     ]
    }
   ],
   "source": [
    "#6\n",
    "\n",
    "#Resolveremos este ejercicio de tres maneras distintas (las dos primeras son meramente didácticas, no se esperaría que\n",
    "# el alumno las desarrollara):\n",
    "\n",
    "#la primera es haciendo uso de la función bin()\n",
    "\n",
    "#Esta primera solución no es la que se espera que el alumno desarrolle, se muestra para que el alumno pueda aprender\n",
    "#  de otras posibilidades\n",
    "def binarios_simple(n):\n",
    "    # Como son las cadenas con n caracteres, habrá dos elevado a n posibles cadenas\n",
    "    \n",
    "    #Estas cadenas coincidirán con todos los números binarios desde 0 a (2**n - 1)\n",
    "    #Por eso, se usa la función bin para transformar el número i a binario\n",
    "    return {bin(i)[2:].zfill(n) for i in range(2**n)}\n",
    "\n",
    "#La segunda solución tampoco se espera que el alumno la desarrolle, ya que utiliza la recursividad de funciones\n",
    "def binarios_recursiva(n):\n",
    "    if n == 0:\n",
    "        return set()\n",
    "    if n == 1:\n",
    "        return {'0', '1'}\n",
    "    return {(cadena + bit) for cadena in binarios_recursiva(n-1) for bit in {'0', '1'}}\n",
    "\n",
    "#La tercera solución sí se espera que el alumno sea capaz de desarrollarla\n",
    "def binarios(n):\n",
    "    #El conjunto de cadenas de 0 caracteres es el conjunto vacío\n",
    "    if n == 0:\n",
    "        return set()\n",
    "    \n",
    "    resultado = {'0', '1'}\n",
    "    for i in range(2, n+1):\n",
    "        #Vamos generando el conjunto de todas las cadenas posibles de tamaño i y guardándolo en resultado\n",
    "        resultado = {(cadena + bit) for cadena in resultado for bit in {'0', '1'}}\n",
    "    return resultado\n",
    "\n",
    "print(binarios_simple(3))\n",
    "print(binarios_recursiva(3))\n",
    "print(binarios(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ♦️Ejercicio 7:\n",
    "Implementar una función *partesde(A)* que devuelva el conjunto potencia (apartado 3.2 de la teoría) del conjunto que se le pasa por parámetro.\n",
    "\n",
    "*Pista: es posible usar la función binarios(n) implementada en el ejercicio 6 interpretando un 0 como coger un elemento y un 1 como no elegirlo. Al final habrá que generar todos los conjuntos posibles al escoger un elemento de A y al no escogerlo.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{frozenset({2}), frozenset({2, 3}), frozenset({1, 2}), frozenset({1, 2, 3}), frozenset({3}), frozenset({1}), frozenset(), frozenset({1, 3})}\n",
      "{frozenset({2}), frozenset({2, 3}), frozenset({1, 2}), frozenset({1, 2, 3}), frozenset({3}), frozenset({1}), frozenset(), frozenset({1, 3})}\n"
     ]
    }
   ],
   "source": [
    "#7\n",
    "\n",
    "#Se muestra la solución sin usar la función binarios y utilizándola\n",
    "#En esta función no se utiliza binarios\n",
    "def partesde(A):\n",
    "    #Empezamos generando todos los conjuntos posibles si A tuviera solo un elemento\n",
    "    resultado = [set(), {A.pop()}]\n",
    "    for e in A:\n",
    "        # Para cada uno de el resto de elementos de A, generamos todos los conjuntos posibles al añadirlo y no añadirlo\n",
    "        # a los conjuntos ya creados\n",
    "        aux = []\n",
    "        for conjunto in resultado:\n",
    "            aux.append(conjunto)\n",
    "            aux.append(conjunto | {e})\n",
    "        resultado = aux\n",
    "    return {frozenset(conjunto) for conjunto in resultado}\n",
    "\n",
    "#En la siguiente función utilizamos binarios, para facilitarnos la implementación definiremos antes una función auxiliar\n",
    "def filtrar_lista(lista, cadena_binaria):\n",
    "    #Esta función, dada una lista de tamaño n y una cadena de caracteres del mismo tamaño devuelve un conjunto con\n",
    "    #los elementos que se encuentran en las posiciones donde están los 1\n",
    "    return {elemento for elemento, bit in zip(lista, cadena_binaria) if bit == '1'}\n",
    "\n",
    "def partesde_binarios(A):\n",
    "    lista_A = list(A)\n",
    "    return {frozenset(filtrar_lista(lista_A, cadena)) for cadena in binarios(len(A))}\n",
    "\n",
    "print(partesde({1,2,3}))\n",
    "print(partesde_binarios({1,2,3}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 8:\n",
    "Sin utilizar `in` en ningún lugar (ni siquiera en los bucles) implementar una función *pertenece(elemento, conjunto)* que compruebe si el elemento pasado por parámetro pertenece al conjunto dado. Puede suponerse que todos los elementos del conjunto son del mismo tipo que la variable elemento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#8\n",
    "def pertenece(elemento, conjunto):\n",
    "    #Como no podemos usar in, no es posible acceder a los elementos del conjunto a menos que se convierta en una lista\n",
    "    l = list(conjunto)\n",
    "    for i in range(len(l)):\n",
    "        if elemento == l[i]:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "print(pertenece(3, {1,2,3}))\n",
    "print(pertenece(0, {1,2,3}))\n",
    "print(pertenece(0, set()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 9:\n",
    "Sin utilizar `in` en ningún lugar (ni siquiera en los bucles) implementar una función *insertar(elemento, conjunto)* que primero compruebe si el elemento recibido por parámetro está en el conjunto dado. A continuación, si lo está, que muestre por pantalla el mensaje \"El elemento ya se encuentra en el conjunto\". En caso contrario, que inserte el elemento sin utilizar los métodos `add` ni `update`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El elemento ya se encuentra en el conjunto.\n",
      "{1, 2, 3}\n",
      "{0, 1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "#9\n",
    "def insertar(elemento, conjunto):\n",
    "    if pertenece(elemento, conjunto):\n",
    "        print('El elemento ya se encuentra en el conjunto.')\n",
    "        return conjunto\n",
    "    return conjunto | {elemento}\n",
    "\n",
    "print(insertar(3,{1,2,3}))\n",
    "print(insertar(0,{1,2,3}))"
   ]
  }
 ],
 "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": 4
}