Ineuron_Python_Advanced_Programming20.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming20.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3TkSOJ_t6O1C"
      },
      "source": [
        "#Ineuron Python Advanced Programming 20"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0XK9Xr3F6TSn"
      },
      "source": [
        ">Q.1. Create a function based on the input and output. Look at the examples, there is a pattern.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b-4l4gGh6HRk"
      },
      "source": [
        "def secret(s):\n",
        "    s1=s.replace(\".\",\" \")[2:]\n",
        "    n=\"<p class='str'></p> \"\n",
        "    n=n.replace(\"str\",s1)\n",
        "    return n"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "D4l51Guo6kja",
        "outputId": "677dcf11-f003-49d1-b364-643b41944027"
      },
      "source": [
        "secret(\"p.one.two.three\")\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "\"<p class='one two three'></p> \""
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "Kga1ZI9T6lma",
        "outputId": "dc914cc9-cdd9-4912-b2f2-19e4eb43ee76"
      },
      "source": [
        "secret(\"p.one\")\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "\"<p class='one'></p> \""
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "fZz0ZfGO6nkB",
        "outputId": "940423c0-6e0d-46e3-8abf-adf7bbb8b723"
      },
      "source": [
        "secret(\"p.four.five\")\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "\"<p class='four five'></p> \""
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LFkH5JPc6rq1"
      },
      "source": [
        ">Q.2. Create a function which counts how many lone 1s appear in a given number. Lone means the number doesn't appear twice or more in a row.\n",
        "\n",
        "Examples\n",
        "\n",
        "count_lone_ones(101)  ➞ 2\n",
        "\n",
        "count_lone_ones(1191) ➞ 1\n",
        "\n",
        "count_lone_ones(1111) ➞ 0\n",
        "\n",
        "count_lone_ones(462)  ➞ 0"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LewiOfEo6pjf"
      },
      "source": [
        "def count_lone_ones(num):\n",
        "    count=0\n",
        "    lst=[int(i) for i in str(num)]\n",
        "    if lst[0]==1 and lst[1]!=1:\n",
        "        count+=1\n",
        "    if lst[-2]!=1 and lst[-1]==1:\n",
        "        count+=1\n",
        "    for i in range(1,len(lst)-2):\n",
        "        if lst[i]==1:\n",
        "            if lst[i-1]!=1 and lst[i+1]!=1:\n",
        "                count+=1\n",
        "    return count"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JMSvOI4i6uIF",
        "outputId": "a325eacd-554b-4f3a-ec79-776b361a2ca8"
      },
      "source": [
        "count_lone_ones(101)\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P4oIWlfy6vMh",
        "outputId": "f6b10122-05b5-495e-9791-ab75d62dcc59"
      },
      "source": [
        "count_lone_ones(1191)\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b4noExkM6wVs",
        "outputId": "68ca458c-bbee-4644-eec1-8d9fa8e6e0c9"
      },
      "source": [
        "count_lone_ones(1111)\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nqHw5xT56xcq",
        "outputId": "c274045c-33d3-46eb-9b78-d4983dc52cd7"
      },
      "source": [
        "count_lone_ones(462)\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lgf4w5Fc62Hu"
      },
      "source": [
        ">Q. 3. Write a method that accepts two integer parameters rows and cols. The output is a 2d array of numbers displayed in column-major order, meaning the numbers shown increase sequentially down each column and wrap to the top of the next column to the right once the bottom of the current column is reached."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Efpn1Zrr6y9e"
      },
      "source": [
        "def printGrid(rows,cols):\n",
        "    \n",
        "    rows,cols=cols,rows\n",
        "    arr=[]\n",
        "    x=1\n",
        "    for i in range(rows):\n",
        "        col = []\n",
        "        for j in range(cols):\n",
        "            col.append(x)\n",
        "            x+=1\n",
        "        arr.append(col)\n",
        "    l2 =[[row[i] for row in arr] for i in range(len(arr[0]))]\n",
        "    return l2"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fNzdKFKZ645V",
        "outputId": "32266aa4-2fd3-4fbe-aad7-94cc6f3b62a4"
      },
      "source": [
        "printGrid(3, 6)\n"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1, 4, 7, 10, 13, 16], [2, 5, 8, 11, 14, 17], [3, 6, 9, 12, 15, 18]]"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wTz41jLV66du",
        "outputId": "dda784cf-3aa6-4302-f23e-56cec65ce8e2"
      },
      "source": [
        "printGrid(5, 3)\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1, 6, 11], [2, 7, 12], [3, 8, 13], [4, 9, 14], [5, 10, 15]]"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vcYwYebf68FY",
        "outputId": "8a52f302-a68b-4238-e8eb-6971a0b076fe"
      },
      "source": [
        "printGrid(4, 1)\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1], [2], [3], [4]]"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d_uQMxSu7AGn"
      },
      "source": [
        ">Q.4. Given a list of integers, return the smallest positive integer not present in the list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CDsEywjy69Ok"
      },
      "source": [
        "def min_miss_pos(lst):\n",
        "    pos=[i for i in range(1,11)]\n",
        "    for i in lst:\n",
        "        if i <0:\n",
        "            lst.remove(i)\n",
        "    lst=list(set(pos).difference(lst))\n",
        "    lst.sort()\n",
        "    return lst[0]"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vgyWcP6V7Dlo",
        "outputId": "05c3d528-85a6-4f1a-f3af-6075ca3266c4"
      },
      "source": [
        "min_miss_pos([-2, 6, 4, 5, 7, -1, 1, 3, 6, -2, 9, 10, 2, 2])\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yXeo9_3m7Ewk",
        "outputId": "c35faea5-5d27-4cf1-f392-45d787a69d2b"
      },
      "source": [
        "min_miss_pos([5, 9, -2, 0, 1, 3, 9, 3, 8, 9])\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "knLHk5Nw7GBd",
        "outputId": "5a31640c-2d5a-49f9-b181-9ef092e9f783"
      },
      "source": [
        "min_miss_pos([0, 4, 4, -1, 9, 4, 5, 2, 10, 7, 6, 3, 10, 9])\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xy4rfihP7KYm"
      },
      "source": [
        ">Q.5. Google is launching a network of autonomous pizza delivery drones and wants you to create a flexible rewards system (Pizza Points™) that can be tweaked in the future. The rules are simple: if a customer has made at least N orders of at least Y price, they get a FREE pizza!\n",
        "\n",
        "Create a function that takes a dictionary of customers, a minimum number of orders and a minimum order price. Return a list of customers that are eligible for a free pizza."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U3E_hBEz7Hsq"
      },
      "source": [
        "def pizza_points(customers, minOrders, minPrice):\n",
        "    \n",
        "    new=[]\n",
        "    for cust in customers:\n",
        "        x=[i for i in customers[cust] if i>minPrice]\n",
        "        if len(x)>=minOrders:\n",
        "            new.append(cust)\n",
        "    return new"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n2BzXNXz7O5K",
        "outputId": "143d85b3-a503-419c-bfbc-5e1e636be725",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "customers = {\n",
        "  \"Batman\": [22, 30, 11, 17, 15, 52, 27, 12],\n",
        "  \"Spider-Man\": [5, 17, 30, 33, 40, 22, 26, 10, 11, 45]\n",
        "}\n",
        "pizza_points(customers, 5, 20)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Spider-Man']"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MuT5nEc27Qnp",
        "outputId": "6148082d-f408-4af7-8d55-327f7badc692",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "pizza_points(customers, 3, 10)\n"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Batman', 'Spider-Man']"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    }
  ]
}