Python_Set_Projects.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python Set Projects.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMKTW5n+Ug1L+0qLfmBWrFg",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/natnew/Mini-Python-Projects/blob/main/Python_Set_Projects.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Find the size of a Set"
      ],
      "metadata": {
        "id": "Fqq84P4wCcQr"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OPPME62ABAWY",
        "outputId": "f4490084-9fcf-4ab8-d72c-d79370d9046d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Size of Set1: 744bytes\n",
            "Size of Set2: 744bytes\n",
            "Size of Set3: 232bytes\n"
          ]
        }
      ],
      "source": [
        "import sys\n",
        "  \n",
        "# sample Sets\n",
        "Set1 = {\"A\", 1, \"B\", 2, \"C\", 3}\n",
        "Set2 = {\"Geek1\", \"Raju\", \"Geek2\", \"Nikhil\", \"Geek3\", \"Deepanshu\"}\n",
        "Set3 = {(1, \"Lion\"), ( 2, \"Tiger\"), (3, \"Fox\")}\n",
        "  \n",
        "# print the sizes of sample Sets\n",
        "print(\"Size of Set1: \" + str(sys.getsizeof(Set1)) + \"bytes\")\n",
        "print(\"Size of Set2: \" + str(sys.getsizeof(Set2)) + \"bytes\")\n",
        "print(\"Size of Set3: \" + str(sys.getsizeof(Set3)) + \"bytes\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Iterate over a set"
      ],
      "metadata": {
        "id": "osj-mbt2T65n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a set using string\n",
        "test_set = set(\"geEks\")\n",
        " \n",
        "# Iterating using for loop\n",
        "for val in test_set:\n",
        "    print(val)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LzxSM0yzT85x",
        "outputId": "ddbb53fe-78d7-47a2-8607-25fa80920eba"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "e\n",
            "s\n",
            "g\n",
            "E\n",
            "k\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a set using string\n",
        "test_set = set(\"geEks\")\n",
        " \n",
        "# Iterating using enumerated for loop\n",
        "for id,val in enumerate(test_set):\n",
        "    print(id, val)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R4yTy241UXCH",
        "outputId": "36b4f2ff-6614-4262-834d-390e0fc4abc0"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 e\n",
            "1 s\n",
            "2 g\n",
            "3 E\n",
            "4 k\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# importing libraries\n",
        "from timeit import default_timer as timer\n",
        "import itertools\n",
        "import random\n",
        " \n",
        "# Function under evaluation\n",
        "def test_func(test_set):\n",
        " \n",
        "    for val in test_set:\n",
        "        _ = val\n",
        " \n",
        "# Driver function\n",
        "if __name__ == '__main__':\n",
        " \n",
        "    random.seed(21)\n",
        " \n",
        "    for _ in range(5):\n",
        "        test_set = set()\n",
        " \n",
        "        # generating a set of random numbers\n",
        "        for el in range(int(1e6)):\n",
        "            el = random.random()\n",
        "            test_set.add(el)\n",
        " \n",
        "        start = timer()\n",
        "        test_func(test_set)\n",
        "        end = timer()\n",
        " \n",
        "        print(str(end - start))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e1UvqSKkULta",
        "outputId": "7b682e09-15aa-42cc-8ac2-45f28b4be47c"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.09872130000002244\n",
            "0.09606459799999811\n",
            "0.09349966299998869\n",
            "0.09471714800002928\n",
            "0.09397344100000282\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a set using string\n",
        "test_set = set(\"geEks\")\n",
        " \n",
        "test_list = list(test_set)\n",
        " \n",
        "# Iterating over a set as a indexed list\n",
        "for id in range(len(test_list)):\n",
        "        print(test_list[id])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K1jrQt-NUgZn",
        "outputId": "991e463a-d41e-45ea-c9c6-21fa21163d30"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "e\n",
            "s\n",
            "g\n",
            "E\n",
            "k\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Find the Maximum and Minimum in a Set"
      ],
      "metadata": {
        "id": "nB9bRAtoUmry"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Python code to get the maximum element from a set\n",
        "def MAX(sets):\n",
        "    return (max(sets))\n",
        "      \n",
        "# Driver Code\n",
        "sets = set([8, 16, 24, 1, 25, 3, 10, 65, 55])\n",
        "print(MAX(sets))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F7JZNrDmUodS",
        "outputId": "3894f0b6-f23d-49da-befe-b56bfd1965df"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "65\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Python code to get the minimum element from a set\n",
        "def MIN(sets):\n",
        "    return (min(sets))\n",
        "      \n",
        "# Driver Code\n",
        "sets = set([4, 12, 10, 9, 4, 13])\n",
        "print(MIN(sets))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SOKG7EJhUzUU",
        "outputId": "63a1641e-3a3d-4404-f666-218897c04d21"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Check if two lists have at-least one element common"
      ],
      "metadata": {
        "id": "YCVPNLQNU6gi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Python program to check \n",
        "# if two lists have at-least \n",
        "# one element common\n",
        "# using traversal of list\n",
        "def common_data(list1, list2):\n",
        "    result = False\n",
        "  \n",
        "    # traverse in the 1st list\n",
        "    for x in list1:\n",
        "  \n",
        "        # traverse in the 2nd list\n",
        "        for y in list2:\n",
        "    \n",
        "            # if one common\n",
        "            if x == y:\n",
        "                result = True\n",
        "                return result \n",
        "                  \n",
        "    return result\n",
        "      \n",
        "# driver code\n",
        "a = [1, 2, 3, 4, 5]\n",
        "b = [5, 6, 7, 8, 9]\n",
        "print(common_data(a, b))\n",
        "  \n",
        "a = [1, 2, 3, 4, 5]\n",
        "b = [6, 7, 8, 9]\n",
        "print(common_data(a, b))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7yur1NtcU7Xi",
        "outputId": "5a09473d-1802-4458-9122-871010242309"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Python program to check \n",
        "# if two lists have at-least \n",
        "# one element common\n",
        "# using set and property\n",
        "  \n",
        "def common_member(a, b):\n",
        "    a_set = set(a)\n",
        "    b_set = set(b)\n",
        "    if (a_set & b_set):\n",
        "        return True \n",
        "    else:\n",
        "        return False\n",
        "          \n",
        "  \n",
        "a = [1, 2, 3, 4, 5]\n",
        "b = [5, 6, 7, 8, 9]\n",
        "print(common_member(a, b))\n",
        "  \n",
        "a =[1, 2, 3, 4, 5]\n",
        "b =[6, 7, 8, 9]\n",
        "print(common_member(a, b))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wQqieXIvYS7_",
        "outputId": "e8b01430-f4d6-4fa4-af45-153d67eea908"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Python program to check \n",
        "# if two lists have at-least \n",
        "# one element common\n",
        "# using set intersection\n",
        "  \n",
        "def common_member(a, b):\n",
        "    a_set = set(a)\n",
        "    b_set = set(b)\n",
        "    if len(a_set.intersection(b_set)) > 0:\n",
        "        return(True) \n",
        "    return(False)   \n",
        "  \n",
        "a = [1, 2, 3, 4, 5]\n",
        "b = [5, 6, 7, 8, 9]\n",
        "print(common_member(a, b))\n",
        "  \n",
        "a =[1, 2, 3, 4, 5]\n",
        "b =[6, 7, 8, 9]\n",
        "print(common_member(a, b))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-Ief3Iu3YdKY",
        "outputId": "729ad3b1-e2ac-4d0b-f517-8c65af8c46d8"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Get all subsets of given size of a set"
      ],
      "metadata": {
        "id": "Uw1HA8eiZheA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Python Program to Print\n",
        "# all subsets of given size of a set\n",
        " \n",
        "import itertools\n",
        " \n",
        "def findsubsets(s, n):\n",
        "    return list(itertools.combinations(s, n))\n",
        " \n",
        "# Driver Code\n",
        "s = {1, 2, 3}\n",
        "n = 2\n",
        " \n",
        "print(findsubsets(s, n))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DHUmn0tQZr56",
        "outputId": "f4f05baa-227a-46f4-8bc0-12587d5cef5a"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(1, 2), (1, 3), (2, 3)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Python Program to Print\n",
        "# all subsets of given size of a set\n",
        " \n",
        "import itertools\n",
        "# def findsubsets(s, n):\n",
        "def findsubsets(s, n):\n",
        "    return [set(i) for i in itertools.combinations(s, n)]\n",
        "     \n",
        "# Driver Code\n",
        "s = {1, 2, 3, 4}\n",
        "n = 3\n",
        " \n",
        "print(findsubsets(s, n))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2lnBmhntZ2TO",
        "outputId": "02043351-b224-41a1-c4eb-e5ab791d2ed3"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Convert a set into dictionary"
      ],
      "metadata": {
        "id": "548lSOzjZ7pF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Python code to demonstrate\n",
        "# converting set into dictionary\n",
        "# using fromkeys()\n",
        " \n",
        "# initializing set\n",
        "ini_set = {1, 2, 3, 4, 5}\n",
        " \n",
        "# printing initialized set\n",
        "print (\"initial string\", ini_set)\n",
        "print (type(ini_set))\n",
        " \n",
        "# Converting set to dictionary\n",
        "res = dict.fromkeys(ini_set, 0)\n",
        " \n",
        "# printing final result and its type\n",
        "print (\"final list\", res)\n",
        "print (type(res))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3KKWPCwFZ-nG",
        "outputId": "6ef8163a-41f0-4bde-f43c-145e6939841b"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "initial string {1, 2, 3, 4, 5}\n",
            "<class 'set'>\n",
            "final list {1: 0, 2: 0, 3: 0, 4: 0, 5: 0}\n",
            "<class 'dict'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Python code to demonstrate\n",
        "# converting set into dictionary\n",
        "# using dict comprehension\n",
        " \n",
        " \n",
        "# initializing set\n",
        "ini_set = {1, 2, 3, 4, 5}\n",
        " \n",
        "# printing initialized set\n",
        "print (\"initial string\", ini_set)\n",
        "print (type(ini_set))\n",
        " \n",
        "str = 'fg'\n",
        "# Converting set to dict\n",
        "res = {element:'Geek'+str for element in ini_set}\n",
        " \n",
        "# printing final result and its type\n",
        "print (\"final list\", res)\n",
        "print (type(res))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e22Q9zPkd18D",
        "outputId": "0502d461-dd4d-4f9a-f736-50bf197c702d"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "initial string {1, 2, 3, 4, 5}\n",
            "<class 'set'>\n",
            "final list {1: 'Geekfg', 2: 'Geekfg', 3: 'Geekfg', 4: 'Geekfg', 5: 'Geekfg'}\n",
            "<class 'dict'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Python dictionary, set and counter to check if frequencies can become same"
      ],
      "metadata": {
        "id": "JfxBG8-feJYH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Function to Check if frequency of all characters\n",
        "# can become same by one removal\n",
        "from collections import Counter\n",
        "  \n",
        "def allSame(input):\n",
        "      \n",
        "    # calculate frequency of each character\n",
        "    # and convert string into dictionary\n",
        "    dict=Counter(input)\n",
        "  \n",
        "    # now get list of all values and push it\n",
        "    # in set\n",
        "    same = list(set(dict.values()))\n",
        "  \n",
        "    if len(same)>2:\n",
        "        print('No')\n",
        "    elif len (same)==2 and same[1]-same[0]>1:\n",
        "        print('No')\n",
        "    else:\n",
        "        print('Yes')\n",
        "  "
      ],
      "metadata": {
        "id": "x36xV6N1eNnX"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        " # now check if frequency of all characters \n",
        "    # can become same\n",
        "      \n",
        "# Driver program\n",
        "if __name__ == \"__main__\":\n",
        "    input = 'xxxyyzzt'\n",
        "    allSame(input)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xG5cgGAleRom",
        "outputId": "9d058a09-7300-472e-a63b-0378728e4eee"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "No\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Python | Check if a given string is binary string or not"
      ],
      "metadata": {
        "id": "AQqlrP5CeYvB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Python program to check\n",
        "# if a string is binary or not\n",
        " \n",
        "# function for checking the\n",
        "# string is accepted or not\n",
        "def check(string) :\n",
        " \n",
        "    # set function convert string\n",
        "    # into set of characters .\n",
        "    p = set(string)\n",
        " \n",
        "    # declare set of '0', '1' .\n",
        "    s = {'0', '1'}\n",
        " \n",
        "    # check set p is same as set s\n",
        "    # or set p contains only '0'\n",
        "    # or set p contains only '1'\n",
        "    # or not, if any one condition\n",
        "    # is true then string is accepted\n",
        "    # otherwise not .\n",
        "    if s == p or p == {'0'} or p == {'1'}:\n",
        "        print(\"Yes\")\n",
        "    else :\n",
        "        print(\"No\")\n",
        " \n",
        " \n",
        "         \n",
        "# driver code\n",
        "if __name__ == \"__main__\" :\n",
        " \n",
        "    string = \"101010000111\"\n",
        " \n",
        "    # function calling\n",
        "    check(string)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4jX2sL5OeaVQ",
        "outputId": "3184eb73-602d-48f2-f192-e874a7c5e1ba"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Yes\n"
          ]
        }
      ]
    }
  ]
}