Ineuron_Python_Advanced_Programming05.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming05.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "794vOWjDlOdv"
      },
      "source": [
        "# Ineuron Python Advanced Programming 05"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sFU60WODlSrb"
      },
      "source": [
        ">Q. 1. Create a function that takes a number n (integer greater than zero) as an\n",
        "argument, and returns 2 if n is odd and 8 if n is even.\n",
        "You can only use the following arithmetic operators: addition of numbers +,\n",
        "subtraction of numbers -, multiplication of number *, division of number /, and\n",
        "exponentiation **.\n",
        "You are not allowed to use any other methods in this challenge (i.e. no if\n",
        "statements, comparison operators, etc).\n",
        "Examples\n",
        "f(1) ➞ 2\n",
        "f(2) ➞ 8\n",
        "f(3) ➞ 2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "REoR6eoQlIxL"
      },
      "source": [
        "def f(num):\n",
        "    evenOddList = [8,2]\n",
        "    return evenOddList[num & 1]"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FHVONFMklU6c",
        "outputId": "6a2e7525-029e-4be2-87ae-d256b8af3f76"
      },
      "source": [
        "f(1)\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eEnnKmkRlWFD",
        "outputId": "0cb9a27d-870d-4fee-f133-20a2fd0bd507"
      },
      "source": [
        "f(2)\n"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "auPbrqGplXOn",
        "outputId": "c946ecb0-ad36-43ce-fd8e-0ad0a6ea35d7"
      },
      "source": [
        "f(3)\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bcZOXGHOlbhf"
      },
      "source": [
        ">Q. 2. Create a function that returns the majority vote in a list. A majority vote is\n",
        "an element that occurs > N/2 times in a list (where N is the length of the list).\n",
        "Examples\n",
        "majority_vote(['A', 'A', 'B']) ➞ 'A'\n",
        "majority_vote(['A', 'A', 'A', 'B', 'C', 'A']) ➞ 'A'\n",
        "majority_vote(['A', 'B', 'B', 'A', 'C', 'C']) ➞ None"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s7oEqH1AlYai"
      },
      "source": [
        "def majority_vote(lst):\n",
        "    done = []\n",
        "    maxCount = 0\n",
        "    count = 0\n",
        "    for i in lst:\n",
        "        if i not in done:\n",
        "            count = lst.count(i)\n",
        "            done.append(i)\n",
        "            if count > maxCount:\n",
        "                maxCount = count\n",
        "                ele = i\n",
        "\n",
        "    if maxCount > len(lst)//2:\n",
        "        maxCount = count\n",
        "        return \"Majority Element \",ele\n",
        "    else:\n",
        "        return \"no majority elements\""
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QmwjWnnulfEA",
        "outputId": "8abf41e7-0154-47ff-82e7-2235a42137a6"
      },
      "source": [
        "majority_vote(['A', 'A', 'B'])\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Majority Element ', 'A')"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9pyJng8blgsh",
        "outputId": "1d4a170c-c7b0-4bb1-f53d-5b4f24f3e169"
      },
      "source": [
        "majority_vote(['A', 'A', 'A', 'B', 'C', 'A'])\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Majority Element ', 'A')"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "azXQG5Ndlr26",
        "outputId": "8cd33b87-16b8-4845-8d9e-acd8ab93da35"
      },
      "source": [
        "majority_vote(['A', 'B', 'B', 'A', 'C', 'C'])\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'no majority elements'"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9asozY2wlvcs"
      },
      "source": [
        ">Q. 3. Create a function that takes a string txt and censors any word from a given\n",
        "list lst. The text removed must be replaced by the given character char.\n",
        "Examples\n",
        "censor_string('Today is a Wednesday!', ['Today', 'a'], '-') ➞ '----- is -\n",
        "Wednesday!'\n",
        "censor_string('The cow jumped over the moon.', ['cow', 'over'], '*'), 'The ***\n",
        "jumped **** the moon.')\n",
        "censor_string('Why did the chicken cross the road?', ['Did', 'chicken',\n",
        "'road'], '*') ➞ 'Why *** the ******* cross the ****?'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0v_qzG1Qls9J"
      },
      "source": [
        "def censor_string(text, censorlst, replacer):\n",
        "\n",
        "    word_list = text.split()\n",
        "    for censor in censorlst:\n",
        "        index = 0\n",
        "        for word in word_list:\n",
        "            if censor.lower() == word.lower():\n",
        "                ch = len(censor) * replacer\n",
        "                word_list[index] = ch\n",
        "            elif censor.lower() == word[0:-1].lower():\n",
        "                ch = len(censor) * replacer\n",
        "                word_list[index] = ch+word[-1]\n",
        "            index+=1\n",
        "\n",
        "    return \" \".join(word_list)"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "Ac8mEaGblyeq",
        "outputId": "26faf789-3b8b-4a2a-81c4-2ab289440fa9"
      },
      "source": [
        "censor_string('Today is a Wednesday!', ['Today', 'a'], '-')\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'----- is - Wednesday!'"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "XKp7jLJDlzpF",
        "outputId": "f86522a4-f360-42d4-9826-f8160803d960"
      },
      "source": [
        "censor_string('The cow jumped over the moon.', ['cow', 'over'], '*')\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'The *** jumped **** the moon.'"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "Fx4riQ-Rl04f",
        "outputId": "c17bf1b3-9482-43a8-9174-8b21965c708e"
      },
      "source": [
        "censor_string('Why did the chicken cross the road?', ['Did', 'chicken','road'], '*')\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Why *** the ******* cross the ****?'"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nvNLAKzMl45r"
      },
      "source": [
        ">Q. 4. In mathematics a Polydivisible Number (or magic number) is a number in a\n",
        "given number base with digits abcde... that has the following properties:\n",
        "- Its first digit a is not 0.\n",
        "- The number formed by its first two digits ab is a multiple of 2.\n",
        "- The number formed by its first three digits abc is a multiple of 3.\n",
        "- The number formed by its first four digits abcd is a multiple of 4.\n",
        "Create a function which takes an integer n and returns True if the given\n",
        "number is a Polydivisible Number and False otherwise.\n",
        "Examples\n",
        "is_polydivisible(1232) ➞ True\n",
        "1 / 1 = 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "paURPBWfl2JN"
      },
      "source": [
        "def is_polydivisible(n):\n",
        "    tempNum = n\n",
        "    digit = []\n",
        "  \n",
        "    # digit extraction of input number\n",
        "    while (n > 0):          \n",
        "        digit.append(n % 10)\n",
        "        n /= 10\n",
        "  \n",
        "    digit.reverse()\n",
        "  \n",
        "    flag = True\n",
        "    n = digit[0]\n",
        "    for i in range(1, len(digit)):\n",
        "\n",
        "        n = n * 10 + digit[i] # second digit  \n",
        "   \n",
        "        if (n % (i + 1) != 0):\n",
        "            flag = False\n",
        "            break\n",
        "      \n",
        "    if (flag):\n",
        "        return tempNum, \"is Polydivisible number.\"\n",
        "    else:\n",
        "        return tempNum, \"is Not Polydivisible number.\""
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4-T7h0CUl8sy",
        "outputId": "914b9bfc-ecd8-4414-c3b3-aff7ac6e9058"
      },
      "source": [
        "is_polydivisible(1232)\n"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1232, 'is Not Polydivisible number.')"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eDi1d7ajl-cG",
        "outputId": "e948b7ba-d180-4f7a-8d31-d87f1d4d1a94"
      },
      "source": [
        "\n",
        "is_polydivisible(123220)\n"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(123220, 'is Not Polydivisible number.')"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SloB1PPRmEQH"
      },
      "source": [
        ">Q. 5. Create a function that takes a list of numbers and returns the sum of all\n",
        "prime numbers in the list.\n",
        "Examples\n",
        "sum_primes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) ➞ 17\n",
        "sum_primes([2, 3, 4, 11, 20, 50, 71]) ➞ 87\n",
        "sum_primes([]) ➞ None"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dS8b288rmAtE"
      },
      "source": [
        "def is_prime(n):\n",
        "    if n < 2:\n",
        "        return False\n",
        "    elif n <= 3:\n",
        "        return True\n",
        "    elif n % 2 == 0:\n",
        "        return False\n",
        "  \n",
        "    length = int(n**.5) + 1  # n**.5 is equal to sqrt(n)\n",
        "    for i in range(3, length, 2):\n",
        "        if n % i == 0:\n",
        "            return False\n",
        "\n",
        "    return True\n",
        "def sum_primes(l):\n",
        "    return sum(n for n in l if is_prime(n))"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UwN7Ccn2mHpd",
        "outputId": "377661d5-3c84-4aa5-8097-4401ae8aae5c"
      },
      "source": [
        "sum_primes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "17"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zr7D1jvMmJRm",
        "outputId": "6f6acac1-8186-4486-8546-d19fdba74f36"
      },
      "source": [
        "sum_primes([2, 3, 4, 11, 20, 50, 71])\n"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "87"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yROvv3ZwmKWX",
        "outputId": "ae218089-b20b-497a-9130-2e456a167bbe"
      },
      "source": [
        "sum_primes([])\n"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    }
  ]
}