Ineuron_Python_Advanced_Programming12.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming12.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IOoyHCu7PJuG"
      },
      "source": [
        "# Ineuron Python Advanced Programming 12"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9pDOzCJKPS4i"
      },
      "source": [
        ">Q.1. For this challenge, forget how to add two numbers together. The best\n",
        "explanation on what to do for this function is this meme:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7eNjd70RPHTS"
      },
      "source": [
        "def appendZero(n1,n2):\n",
        "    \n",
        "    if len(n1) == len(n2):\n",
        "        pass\n",
        "    elif len(n1) > len(n2):\n",
        "        dif = len(n1) - len(n2)\n",
        "        zero = '0'*dif\n",
        "        n2 = zero+n2    \n",
        "    else:\n",
        "        dif = len(n2) - len(n1)\n",
        "        zero = '0'*dif\n",
        "        n1 = zero+n1\n",
        "\n",
        "    return n1,n2   \n",
        "\n",
        "\n",
        "def meme_sum(n1,n2):   \n",
        "\n",
        "    n1,n2 = appendZero(str(n1),str(n2))\n",
        "\n",
        "    cnt = 0\n",
        "    i = 0\n",
        "    sum = 0\n",
        "    sumtotal = ''\n",
        "    while cnt < len(n1):\n",
        "        sum = int(n1[i]) + int(n2[i])\n",
        "        sumtotal = sumtotal + str(sum)\n",
        "        i += 1\n",
        "        sum = 0\n",
        "        cnt += 1\n",
        "    return int(sumtotal)"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C6GLOH7zPXr7",
        "outputId": "8f4cdbfe-1597-4e4c-e0fe-1dad017bab75"
      },
      "source": [
        "meme_sum(26, 39)\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "515"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nvO8dTp-PY_q",
        "outputId": "8d7503bb-7c79-4be8-c49d-8a4f80d9c695"
      },
      "source": [
        "meme_sum(122, 81)\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1103"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tiFt54TVPaKY",
        "outputId": "0450342c-7741-4693-a588-207b5812b05d"
      },
      "source": [
        "meme_sum(1222, 30277)\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "31499"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x41g5xodPd73"
      },
      "source": [
        ">Q.2. Given an integer, create a function that returns the next prime. If the\n",
        "number is prime, return the number itself.\n",
        "Examples\n",
        "\n",
        "next_prime(12) ➞ 13\n",
        "next_prime(24) ➞ 29\n",
        "next_prime(11) ➞ 11"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_Oa3d_eOPb_6"
      },
      "source": [
        "def isPrime(n):\n",
        "    if n==1:\n",
        "        return True\n",
        "    else:\n",
        "        for i in range(2,int(n/2)+1):\n",
        "            if n%i==0:\n",
        "                return False\n",
        "        return True\n",
        "\n",
        "def next_prime(x):\n",
        "    if isPrime(x):\n",
        "        return x\n",
        "    else:\n",
        "        while(isPrime(x)!=True):\n",
        "            x=x+1\n",
        "        return x"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yzhMgWiIPg7C",
        "outputId": "b7c562f8-6bf6-4c74-bcff-ad60a02ef839"
      },
      "source": [
        "next_prime(12)\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "13"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f0n4VHMcPiLb",
        "outputId": "927dc82c-8646-405e-e60c-856267b871a1"
      },
      "source": [
        "next_prime(24)\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "29"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y9FhsUplPjRU",
        "outputId": "03c0973b-8580-47cf-f132-1777c51d6661"
      },
      "source": [
        "next_prime(11)\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oaw5369hPmga"
      },
      "source": [
        ">Q. 3. If a person traveled up a hill for 18mins at 20mph and then traveled back\n",
        "down the same path at 60mph then their average speed traveled was 30mph.\n",
        "Write a function that returns the average speed traveled given an uphill time,\n",
        "uphill rate and a downhill rate. Uphill time is given in minutes. Return the rate\n",
        "as an integer (mph). No rounding is necessary.\n",
        "Examples\n",
        "ave_spd(18, 20, 60) ➞ 30\n",
        "ave_spd(30, 10, 30) ➞ 15\n",
        "ave_spd(30, 8, 24) ➞ 12"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "prL5ObUyPkQr"
      },
      "source": [
        "def ave_spd(time1,speed1,speed2):\n",
        "\n",
        "    uptime = time1/60\n",
        "    #distance\n",
        "    distance = speed1 * uptime\n",
        "    #total distance\n",
        "    totaldistance = distance*2\n",
        "    #time taken \n",
        "    timedown = distance/speed2\n",
        "    totaltime = uptime + timedown\n",
        "    totalspeed = totaldistance/totaltime\n",
        "    return totalspeed"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hWSrL5fLPsbV",
        "outputId": "4758220d-3c5c-414a-e4ff-0f6938f18488"
      },
      "source": [
        "ave_spd(18, 20, 60)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "30.0"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uXvW4gCHPti4",
        "outputId": "cbfe376f-9286-43bd-daf9-479d0275c226"
      },
      "source": [
        "ave_spd(30, 10, 30)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "15.0"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-1kUHdboPu5V",
        "outputId": "93d38b6a-7a64-4806-fbbb-4c07d8c5c57a"
      },
      "source": [
        "ave_spd(30, 8, 24)\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12.0"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GthcfsogPzYa"
      },
      "source": [
        ">Q.4. The Kempner Function, applied to a composite number, permits to find the\n",
        "smallest integer greater than zero whose factorial is exactly divided by the\n",
        "number.\n",
        "kempner(6) ➞ 3\n",
        "1! = 1 % 6 > 0\n",
        "2! = 2 % 6 > 0\n",
        "3! = 6 % 6 === 0\n",
        "kempner(10) ➞ 5\n",
        "1! = 1 % 10 > 0\n",
        "2! = 2 % 10 > 0\n",
        "3! = 6 % 10 > 0\n",
        "4! = 24 % 10 > 0\n",
        "5! = 120 % 10 === 0\n",
        "A Kempner Function applied to a prime will always return the prime itself.\n",
        "kempner(2) ➞ 2\n",
        "kempner(5) ➞ 5\n",
        "\n",
        "Given an integer n, implement a Kempner Function.\n",
        "Examples\n",
        "kempner(6) ➞ 3\n",
        "kempner(10) ➞ 5\n",
        "kempner(2) ➞ 2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k001FxDtPwER"
      },
      "source": [
        "def isPrime(n):\n",
        "    if n==1:\n",
        "        return True\n",
        "    else:\n",
        "        for i in range(2,int(n/2)+1):\n",
        "            if n%i==0:\n",
        "                return False\n",
        "        return True\n",
        "def fact(num):\n",
        "    factorial=1\n",
        "    for i in range(1,num + 1):\n",
        "        factorial = factorial*i\n",
        "    #   print(factorial)\n",
        "    return factorial\n",
        "    \n",
        "def kempner(n):\n",
        "    if isPrime(n):\n",
        "        return n\n",
        "    else:\n",
        "        for i in range(1,n):\n",
        "            if fact(i)%n == 0:\n",
        "                return i"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qf4-S4BOP3Bw",
        "outputId": "7ffb36d3-6180-4f61-e8d3-11d85d119c99"
      },
      "source": [
        "kempner(6)\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": "JI9JzBcKP4rK",
        "outputId": "28f6775f-fd14-4fae-bdb5-8b583735abcc"
      },
      "source": [
        "kempner(10)\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9yW9jzbFP6QZ",
        "outputId": "498ae7eb-6ae0-4b26-f6fa-eabce3bb6317"
      },
      "source": [
        "kempner(2)\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dI-rr1vYP9Z9"
      },
      "source": [
        ">Q. 5. You work in a factory, and your job is to take items from a conveyor belt\n",
        "and pack them into boxes. Each box can hold a maximum of 10 kgs. Given a\n",
        "list containing the weight (in kg) of each item, how many boxes would you\n",
        "need to pack all of the items?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eOeDUdjnP7aA"
      },
      "source": [
        "def boxes(q):\n",
        "    l = len(q)\n",
        "    i = 0\n",
        "    a = []\n",
        "    box=[]\n",
        "    while l :\n",
        "        if sum(a)  <=  10 :\n",
        "            a.append(q[i])\n",
        "            i = i + 1\n",
        "            l = l - 1   \n",
        "        elif sum(a) > 10:\n",
        "            box.append(a[:-1:])\n",
        "            i = i - 1\n",
        "            l = l + 1\n",
        "            a.clear()\n",
        "    box.append(a)\n",
        "\n",
        "    print(\"We need {} boxes\".format(len(box)))\n",
        "    for i in range(len(box)):\n",
        "        print(\"Box{} has {}, and {}kgs\".format(i+1,box[i],sum(box[i])))"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EvgLBYDrQAmH",
        "outputId": "114af8b2-2f3a-4565-e17a-42b7a99e927a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "boxes([2, 1, 2, 5, 4, 3, 6, 1, 1, 9, 3, 2])"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "We need 5 boxes\n",
            "Box1 has [2, 1, 2, 5], and 10kgs\n",
            "Box2 has [4, 3], and 7kgs\n",
            "Box3 has [6, 1, 1], and 8kgs\n",
            "Box4 has [9], and 9kgs\n",
            "Box5 has [3, 2], and 5kgs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zKDi0M1IQCUL",
        "outputId": "57c892f0-6596-4620-9412-68a4d9cc7be9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "boxes([3,4,5,2,5,4,8,1,2,3])"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "We need 5 boxes\n",
            "Box1 has [3, 4], and 7kgs\n",
            "Box2 has [5, 2], and 7kgs\n",
            "Box3 has [5, 4], and 9kgs\n",
            "Box4 has [8, 1], and 9kgs\n",
            "Box5 has [2, 3], and 5kgs\n"
          ]
        }
      ]
    }
  ]
}