Ineuron_Python_Advanced_Programming07.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming07.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "047-bG7ZNXjo"
      },
      "source": [
        "# Ineuron Python Advanced Programming 07"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jXmtWaC7NcMV"
      },
      "source": [
        ">Q. 1. Write a function that counts how many concentric layers a rug.\n",
        "Examples\n",
        "count_layers([\n",
        "'AAAA',\n",
        "'ABBA',\n",
        "'AAAA'\n",
        "]) ➞ 2\n",
        "count_layers([\n",
        "'AAAAAAAAA',\n",
        "'ABBBBBBBA',\n",
        "'ABBAAABBA',\n",
        "'ABBBBBBBA',\n",
        "'AAAAAAAAA'\n",
        "]) ➞ 3"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XYjhgOCGMcZN"
      },
      "source": [
        "def count_layers(lst):\n",
        "    layers = lenth = len(lst)\n",
        "    if layers % 2 == 0:\n",
        "        print(\"Not a concentric layers\")\n",
        "    else:\n",
        "        mid = len(lst)//2\n",
        "    i = 0\n",
        "    layerCnt = 0\n",
        "    while (i <= mid):     # since concetric layers will be symetric, checking for half of the layers\n",
        "        print(lst[lenth-1])\n",
        "        if lst[i] == lst[lenth-1]: \n",
        "            layerCnt +=1\n",
        "            lenth -=1\n",
        "            i +=1\n",
        "        else:\n",
        "            print('not a concentric layer')\n",
        "            return False\n",
        "    return \"Number of layers -> \",layerCnt"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2ppgN9JmNfMr",
        "outputId": "c1000b57-d7c2-456e-dedd-fba440524e14"
      },
      "source": [
        "count_layers([\n",
        "'AAAA',\n",
        "'ABBA',\n",
        "'AAAA'\n",
        "])"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AAAA\n",
            "ABBA\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Number of layers -> ', 2)"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oK_pht0CNhtw",
        "outputId": "f52a6850-5c65-415e-c013-86110adccf54"
      },
      "source": [
        "count_layers([\n",
        "'AAAAAAAAA',\n",
        "'ABBBBBBBA',\n",
        "'ABBAAABBA',\n",
        "'ABBBBBBBA',\n",
        "'AAAAAAAAA'\n",
        "])"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AAAAAAAAA\n",
            "ABBBBBBBA\n",
            "ABBAAABBA\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Number of layers -> ', 3)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i8q6VNpkNkBb",
        "outputId": "0c9b6efa-8909-4ed3-f373-57642d87bbe3"
      },
      "source": [
        "count_layers([\n",
        "'AAAAAAAAAAA',\n",
        "'AABBBBBBBAA',\n",
        "'AABCCCCCBAA',\n",
        "'AABCAAACBAA',\n",
        "'AABCADACBAA',\n",
        "'AABCAAACBAA',\n",
        "'AABCCCCCBAA',\n",
        "'AABBBBBBBAA',\n",
        "'AAAAAAAAAAA'\n",
        "])"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AAAAAAAAAAA\n",
            "AABBBBBBBAA\n",
            "AABCCCCCBAA\n",
            "AABCAAACBAA\n",
            "AABCADACBAA\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Number of layers -> ', 5)"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uqEvDNKgN7A2"
      },
      "source": [
        ">Q. 2. There are many different styles of music and many albums exhibit multiple\n",
        "styles. Create a function that takes a list of musical styles from albums and\n",
        "returns how many styles are unique.\n",
        "Examples\n",
        "unique_styles([\n",
        "'Dub,Dancehall',\n",
        "'Industrial,Heavy Metal',\n",
        "'Techno,Dubstep',\n",
        "'Synth-pop,Euro-Disco',\n",
        "'Industrial,Techno,Minimal'\n",
        "]) ➞ 9\n",
        "unique_styles([\n",
        "\n",
        "'Soul',\n",
        "'House,Folk',\n",
        "'Trance,Downtempo,Big Beat,House',\n",
        "'Deep House',\n",
        "'Soul'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-O2aMIrNy_x"
      },
      "source": [
        "def unique_styles(lst):\n",
        "    uplst = []\n",
        "    for i in lst:\n",
        "        uplst.extend(i.split(','))\n",
        "    return \"unique style \",len(set(uplst))"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O5Lv29gPN-ej",
        "outputId": "ebd60135-fa74-4023-ef90-f05c1ac4923e"
      },
      "source": [
        "unique_styles([\n",
        "'Dub,Dancehall',\n",
        "'Industrial,Heavy Metal',\n",
        "'Techno,Dubstep',\n",
        "'Synth-pop,Euro-Disco',\n",
        "'Industrial,Techno,Minimal'\n",
        "])"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('unique style ', 9)"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3chQhdl4N_tJ",
        "outputId": "f9c5c581-95f8-49c1-bcc6-dcd5260d818b"
      },
      "source": [
        "unique_styles([\n",
        "'Soul',\n",
        "'House,Folk',\n",
        "'Trance,Downtempo,Big Beat,House',\n",
        "'Deep House',\n",
        "'Soul'\n",
        "])"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('unique style ', 7)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HYkExi8vOD43"
      },
      "source": [
        ">Q. 3. Create a function that finds a target number in a list of prime numbers.\n",
        "Implement a binary search algorithm in your function. The target number will\n",
        "be from 2 through 97. If the target is prime then return 'yes' else return 'no'.\n",
        "Examples\n",
        "primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,\n",
        "71, 73, 79, 83, 89, 97]\n",
        "\n",
        "is_prime(primes, 3) ➞ 'yes'\n",
        "is_prime(primes, 4) ➞ 'no'\n",
        "is_prime(primes, 67) ➞ 'yes'\n",
        "is_prime(primes, 36) ➞ 'no'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "el5Iy0iUOBjO"
      },
      "source": [
        "primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,71, 73, 79, 83, 89, 97]\n",
        "\n",
        "def is_prime(primes,item):\n",
        "    first = 0\n",
        "    last = len(primes)-1\n",
        "    found = False\n",
        "    yes = 'No'\n",
        "    while( first<=last and not found):\n",
        "        mid = (first + last)//2\n",
        "        if primes[mid] == item :\n",
        "            found = True\n",
        "            yes = 'Yes'\n",
        "        else:\n",
        "            if item < primes[mid]:\n",
        "                last = mid - 1\n",
        "            else:\n",
        "                first = mid + 1\t\n",
        "    return yes"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "1-bI_eO_OGPy",
        "outputId": "ed235af7-5046-4bdc-edb1-600cfcaad7bf"
      },
      "source": [
        "is_prime(primes, 3)\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Yes'"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "BEUVFFlqOH2H",
        "outputId": "15062948-eb71-41b4-9ad7-1c979d9cdf55"
      },
      "source": [
        "is_prime(primes, 4)\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'No'"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "xkKnGzG0OJGi",
        "outputId": "81e3bbed-3bbb-40b6-f7e7-bb13529a5a86"
      },
      "source": [
        "is_prime(primes, 67)\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Yes'"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "b8aNNyN6OKXS",
        "outputId": "58cd74c1-429e-418a-9fb0-403b298e78fb"
      },
      "source": [
        "is_prime(primes, 36)\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'No'"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4L7TpuekOOee"
      },
      "source": [
        ">Q.4. Create a function that takes in n, a, b and returns the number of positive\n",
        "values raised to the nth power that lie in the range [a, b], inclusive.\n",
        "Examples\n",
        "power_ranger(2, 49, 65) ➞ 2\n",
        " 2 squares (n^2) lie between 49 and 65, 49 (7^2) and 64 (8^2)\n",
        "power_ranger(3, 1, 27) ➞ 3\n",
        " 3 cubes (n^3) lie between 1 and 27, 1 (1^3), 8 (2^3) and 27 (3^3)\n",
        "power_ranger(10, 1, 5) ➞ 1\n",
        " 1 value raised to the 10th power lies between 1 and 5, 1 (1^10)\n",
        "power_ranger(5, 31, 33) ➞ 1\n",
        "power_ranger(4, 250, 1300) ➞ 3"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6wtEmgMuOLbS"
      },
      "source": [
        "def power_ranger(n, min, max):\n",
        "    count = 0 \n",
        "  \n",
        "    for i in range(max): \n",
        "        if i**n in range(min,max): \n",
        "            print('{}^{} lies between {} and {}'.format(i,n,min,max)) \n",
        "            count += 1 \n",
        "    return 'Total values found =',count"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y5HShCheOTmB",
        "outputId": "54f6e0a1-97f1-47ad-ea5d-8f5f7f2b7286"
      },
      "source": [
        "power_ranger(2, 49, 65)\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7^2 lies between 49 and 65\n",
            "8^2 lies between 49 and 65\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Total values found =', 2)"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xyDfFHwVPRYU",
        "outputId": "2fd6ed39-ddd7-416c-a0d8-d891187d0db7"
      },
      "source": [
        "power_ranger(3, 1, 27)\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1^3 lies between 1 and 27\n",
            "2^3 lies between 1 and 27\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Total values found =', 2)"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZAOhWb9zPStr",
        "outputId": "e2767240-449f-45b6-baef-456ade47f206"
      },
      "source": [
        "power_ranger(10, 1, 5)\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1^10 lies between 1 and 5\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Total values found =', 1)"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HolfTymtPUBF",
        "outputId": "acdedf0a-fd82-4c0c-f596-c147971a148d"
      },
      "source": [
        "power_ranger(5, 31, 33)\n"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2^5 lies between 31 and 33\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Total values found =', 1)"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gLR2XogWPVuw",
        "outputId": "2a2a1059-ef2b-4680-fd0b-d1573492d831"
      },
      "source": [
        "power_ranger(4, 250, 1300)\n"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4^4 lies between 250 and 1300\n",
            "5^4 lies between 250 and 1300\n",
            "6^4 lies between 250 and 1300\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('Total values found =', 3)"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y1RHZodfPadb"
      },
      "source": [
        ">Q. 5. Given a number, return the difference between the maximum and minimum\n",
        "numbers that can be formed when the digits are rearranged.\n",
        "Examples\n",
        "rearranged_difference(972882) ➞ 760833\n",
        "988722 - 227889 = 760833\n",
        "rearranged_difference(3320707) ➞ 7709823\n",
        " 7733200 - 23377 = 7709823\n",
        "rearranged_difference(90010) ➞ 90981\n",
        " 91000 - 19 = 90981\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "boyXN6FVPXje"
      },
      "source": [
        "def findDigit(n):\n",
        "    rev = 0\n",
        "    digit = [] \n",
        "    while(n > 0): \n",
        "        a = n % 10\n",
        "        rev = rev * 10 + a \n",
        "        digit.append(a)\n",
        "        n = n // 10  \n",
        "    return digit\n",
        "    \n",
        "\n",
        "def findMax(digit):\n",
        "    max = int(''.join([str(i) for i in sorted(digit,reverse = True)]))\n",
        "    return max\n",
        "      \n",
        "def finMin(digit):  \n",
        "    min = int(''.join([str(i) for i in sorted(digit,reverse = False)]))\n",
        "    return min\n",
        "def rearranged_difference(n):\n",
        "    digit = findDigit(n)\n",
        "    return findMax(digit) - finMin(digit)"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-Vs55Z_mPfem",
        "outputId": "bf7e2cea-ce4a-4169-d783-480dc8ae7e33"
      },
      "source": [
        "rearranged_difference(972882)\n"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "760833"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q6qi2DnXPhCO",
        "outputId": "6c2133e3-c72b-453d-f48f-f4d8c4655c10"
      },
      "source": [
        "rearranged_difference(3320707)\n"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7709823"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IkGGOy2mPi3o",
        "outputId": "53b0c81b-7f71-4f78-c424-a5910143bfbb"
      },
      "source": [
        "rearranged_difference(90010)\n"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "90981"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    }
  ]
}