Ineuron_Python_Advanced_Programming09.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming09.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "68awChyTLXQU"
      },
      "source": [
        "#Ineuron Python Advanced Programming 09"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O2WAOv9LLasl"
      },
      "source": [
        ">Q. 1. YouTube offers different playback speed options for users. This allows\n",
        "users to increase or decrease the speed of the video content. Given the\n",
        "actual duration and playback speed of the video, calculate the playback\n",
        "duration of the video.\n",
        "Examples\n",
        "playback_duration('00:30:00', 2) ➞ '00:15:00'\n",
        "playback_duration('01:20:00', 1.5) ➞ '00:53:20'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aDJZtq6YLRSz"
      },
      "source": [
        "import datetime\n",
        "def playback_duration(actualDuration,speed):\n",
        "\n",
        "    hour = int(actualDuration.split(':')[0])\n",
        "    minute = int(actualDuration.split(':')[1])\n",
        "    sec = int(actualDuration.split(':')[2])\n",
        "    #Total playbackduration in x speed\n",
        "    totalsec = ((hour*60*60) + (minute*60) + sec)/speed\n",
        "    #convert seconds in to time formate\n",
        "    conversion = datetime.timedelta(seconds=totalsec)\n",
        "    converted_time = str(conversion)\n",
        "    return converted_time"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "eFHSFWD4LdTX",
        "outputId": "2838745a-dd53-4cc3-d54b-64ac37261eea"
      },
      "source": [
        "playback_duration('00:30:00', 2)\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'0:15:00'"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "sSjb-betLez8",
        "outputId": "d47ef80e-6891-4987-b0f8-f03ef5fb9354"
      },
      "source": [
        "playback_duration('01:20:00', 1.5)\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'0:53:20'"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "XrE0VGu7LggA",
        "outputId": "106b8f19-2aa0-44b9-87b3-89f731d019b6"
      },
      "source": [
        "playback_duration('03:20:00', 3)\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'1:06:40'"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cAu8pq__Lk17"
      },
      "source": [
        ">Q. 2. We needs your help to construct a building which will be a pile of n cubes.\n",
        "The cube at the bottom will have a volume of n^3, the cube above will have\n",
        "volume of (n-1)^3 and so on until the top which will have a volume of 1^3.\n",
        "Given the total volume m of the building, can you find the number of cubes n\n",
        "required for the building?\n",
        "In other words, you have to return an integer n such that:\n",
        "n^3 + (n-1)^3 + ... + 1^3 == m\n",
        "Return None if there is no such number.\n",
        "Examples\n",
        "pile_of_cubes(1071225) ➞ 45\n",
        "pile_of_cubes(4183059834009) ➞ 2022\n",
        "pile_of_cubes(16) ➞ None"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J2rdZTI8LiAv"
      },
      "source": [
        "def max_level(remain_volume, currLevel):\n",
        "    if remain_volume < currLevel ** 3:\n",
        "        return -1\n",
        "    if remain_volume == currLevel ** 3:\n",
        "        return currLevel\n",
        "    return max_level(remain_volume - currLevel**3, currLevel + 1)\n",
        "\n",
        "def pile_of_cubes(vol):\n",
        "    level = 1\n",
        "    return max_level(vol, level)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5IFjvPtILnrJ",
        "outputId": "16d9c7c1-630e-4607-cc6a-10da1e909216"
      },
      "source": [
        "pile_of_cubes(1071225)\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "45"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XecMsCkILp7q",
        "outputId": "9a70492e-5b5a-410b-9131-e2fe67a7c887"
      },
      "source": [
        "pile_of_cubes(16)\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "91cM_RUUL2T2"
      },
      "source": [
        ">Q. 3. A fulcrum of a list is an integer such that all elements to the left of it and all\n",
        "elements to the right of it sum to the same value. Write a function that finds\n",
        "the fulcrum of a list.\n",
        "To illustrate:\n",
        "find_fulcrum([3, 1, 5, 2, 4, 6, -1]) ➞ 2\n",
        "// Since [3, 1, 5] and [4, 6, -1] both sum to 9\n",
        "Examples\n",
        "\n",
        "find_fulcrum([1, 2, 4, 9, 10, -10, -9, 3]) ➞ 4\n",
        "find_fulcrum([9, 1, 9]) ➞ 1\n",
        "find_fulcrum([7, -1, 0, -1, 1, 1, 2, 3]) ➞ 0\n",
        "find_fulcrum([8, 8, 8, 8]) ➞ -1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G3GqBuU6LrDo"
      },
      "source": [
        "# Function to compute partition\n",
        "def find_fulcrum(arr) :\n",
        "    size = len(arr)\n",
        "    right_sum, left_sum = 0, 0\n",
        " \n",
        "    # Computing right_sum\n",
        "    for i in range(1, size) :\n",
        "        right_sum += arr[i]\n",
        " \n",
        "    i, j = 0, 1\n",
        " \n",
        "    # Checking the point of partition\n",
        "    # i.e. left_Sum == right_sum\n",
        "    while j < size :\n",
        "        right_sum -= arr[j]\n",
        "        left_sum += arr[i]\n",
        " \n",
        "        if left_sum == right_sum :\n",
        "            return arr[i + 1]\n",
        " \n",
        "        j += 1\n",
        "        i += 1\n",
        " \n",
        "    return -1"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_yPHDGGiL6Qx",
        "outputId": "79586b26-53fc-4ab8-edde-b856e88ebe5b"
      },
      "source": [
        "find_fulcrum([1, 2, 4, 9, 10, -10, -9, 3])\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eylVuoR4L7dv",
        "outputId": "459c0c66-0ef7-4d46-9ad0-bdaa7a199311"
      },
      "source": [
        "find_fulcrum([9, 1, 9])\n"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "urMZkR6FL8lE",
        "outputId": "0f0a417f-835a-45eb-8779-c9c416db903b"
      },
      "source": [
        "find_fulcrum([7, -1, 0, -1, 1, 1, 2, 3])\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5hdG8vAOL-g-",
        "outputId": "bc522eb3-8c9d-46a3-fa2a-9dc713c1b353"
      },
      "source": [
        "find_fulcrum([8, 8, 8, 8])\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-1"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8TNZx67-MB2d"
      },
      "source": [
        ">Q. 4. Given a list of integers representing the color of each sock, determine how\n",
        "many pairs of socks with matching colors there are. For example, there are 7\n",
        "socks with colors [1, 2, 1, 2, 1, 3, 2]. There is one pair of color 1 and one of\n",
        "color 2. There are three odd socks left, one of each color. The number of\n",
        "pairs is 2.\n",
        "Create a function that returns an integer representing the number of matching\n",
        "pairs of socks that are available.\n",
        "Examples\n",
        "sock_merchant([10, 20, 20, 10, 10, 30, 50, 10, 20]) ➞ 3\n",
        "sock_merchant([50, 20, 30, 90, 30, 20, 50, 20, 90]) ➞ 4\n",
        "sock_merchant([]) ➞ 0"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pFQajR2XL_lZ"
      },
      "source": [
        "def sock_merchant(lst):\n",
        "    listUnique = list(set(lst))\n",
        "    # find count\n",
        "    pairs = 0\n",
        "    for i in listUnique:\n",
        "        if lst.count(i) // 2 > 0:\n",
        "            pairs = pairs + lst.count(i) // 2\n",
        "    return pairs"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r7Aach1jMFYD",
        "outputId": "91cf5878-1a7e-48cd-cfeb-6310e343af51"
      },
      "source": [
        "sock_merchant([10, 20, 20, 10, 10, 30, 50, 10, 20])\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zpZs81GJMGga",
        "outputId": "2394317e-9340-417b-c3b5-d7d32f860f13"
      },
      "source": [
        "sock_merchant([50, 20, 30, 90, 30, 20, 50, 20, 90])\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E7J3Wo5IMIS-",
        "outputId": "4ab0b73f-002d-44c1-9833-6241eaa1b9b9"
      },
      "source": [
        "sock_merchant([])\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YkfZ-nE6MLny"
      },
      "source": [
        ">Q. 5. Create a function that takes a string containing integers as well as other\n",
        "characters and return the sum of the negative integers only.\n",
        "Examples\n",
        "negative_sum('-12 13%14&-11') ➞ -23\n",
        "// -12 + -11 = -23\n",
        "negative_sum('22 13%14&-11-22 13 12') ➞ -33\n",
        "// -11 + -22 = -33"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HblWxgmIMJax"
      },
      "source": [
        "import re\n",
        "def negative_sum(s):\n",
        "    result = [int(d) for d in re.findall(r'-\\d+', s)]\n",
        "    print('Negative numbers in string is/are - ',result)\n",
        "    return 'sum is ',sum(result)"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "60-iNeEzMNqw",
        "outputId": "58243e46-9508-461b-872b-459e4f421857"
      },
      "source": [
        "negative_sum('-12 13%14&amp;-11')"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Negative numbers in string is/are -  [-12, -11]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('sum is ', -23)"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GrwisursMXLJ",
        "outputId": "52372a41-6ad9-4605-b178-b43d613b7f56"
      },
      "source": [
        "negative_sum('22 13%14&amp;-11-22 13 12')"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Negative numbers in string is/are -  [-11, -22]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "('sum is ', -33)"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    }
  ]
}