Ineuron_Python_Advanced_Programming10.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming10.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GbvwavE7Mk0b"
      },
      "source": [
        "#Ineuron Python Advanced Programming 10"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G3M9mRiLMr6c"
      },
      "source": [
        ">Q. 1. Create a function that takes the width, height and character and returns a\n",
        "picture frame as a 2D list.\n",
        "Examples\n",
        "get_frame(4, 5, '#') ➞ [\n",
        "['####'],\n",
        "['# #'],\n",
        "['# #'],\n",
        "['# #'],\n",
        "['####']\n",
        "]\n",
        "Frame is 4 characters wide and 5 characters tall.\n",
        "\n",
        "get_frame(10, 3, '*') ➞ [\n",
        "['**********'],\n",
        "['* *'],\n",
        "['**********']\n",
        "]\n",
        "Frame is 10 characters and wide and 3 characters tall.\n",
        "\n",
        "get_frame(2, 5, '0') ➞ 'invalid'"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UFLp_51ZMgq4",
        "outputId": "f07a5240-0acf-4ece-992f-7bdac1c373be"
      },
      "source": [
        "def get_frame(m, n,sign) :\n",
        "    row = []\n",
        "    frame = []\n",
        "    boxStr = '' \n",
        "    if m <= 2 or n <= 2:\n",
        "        return \"invalid\"\n",
        "    for i in range(1, n+1) :\n",
        "        boxStr = ''\n",
        "        row = []\n",
        "        for j in range(1, m+1) :\n",
        "            if (i == 1 or i == n or\n",
        "                j == 1 or j == m) :\n",
        "                boxStr = boxStr + sign\n",
        "            else :\n",
        "                boxStr = boxStr + ' '\n",
        "        row.append(boxStr)\n",
        "        frame.append(row)\n",
        "    for i in frame:\n",
        "        print(i)\n",
        "    #return frame\n",
        "        \n",
        " \n",
        " \n",
        "get_frame(4, 5, '#')"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['####']\n",
            "['#  #']\n",
            "['#  #']\n",
            "['#  #']\n",
            "['####']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "queCPIeuM2h7"
      },
      "source": [
        ">Q.2. Write three functions:\n",
        "1. boolean_and\n",
        "2. boolean_or\n",
        "3. boolean_xor\n",
        "These functions should evaluate a list of True and False values, starting from\n",
        "the leftmost element and evaluating pairwise.\n",
        "Examples\n",
        "boolean_and([True, True, False, True]) ➞ False\n",
        "[True, True, False, True] => [True, False, True] => [False, True] => False\n",
        "boolean_or([True, True, False, False]) ➞ True\n",
        "[True, True, False, True] => [True, False, False] => [True, False] => True\n",
        "boolean_xor([True, True, False, False]) ➞ False\n",
        "[True, True, False, False] => [False, False, False] => [False, False] =>\n",
        "False"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9jgCOZMKMwvb"
      },
      "source": [
        "from functools import reduce\n",
        "\n",
        "def boolean_and(items):\n",
        "    status = reduce(lambda a,b: True if (a & b) else False, items)\n",
        "    return status\n",
        "\n",
        "def boolean_or(items):\n",
        "    status = reduce(lambda a,b: True if (a | b) else False, items)\n",
        "    return status\n",
        "\n",
        "def boolean_xor(items):\n",
        "    status = reduce(lambda a,b: True if (a ^ b) else False, items)\n",
        "    return status"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hiluc0vVM9Zr",
        "outputId": "5659aa2e-197a-490a-d8ac-798170156690"
      },
      "source": [
        "boolean_and([True, True, False, True])\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x7ZqX2hjM-vO",
        "outputId": "b571acc6-aa3c-480f-b936-975e0e09444b"
      },
      "source": [
        "boolean_or([True, True, False, False])\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PT_SDj0YNAQs",
        "outputId": "e37c18cc-e7e2-4dd9-a459-b4b67f26eb14"
      },
      "source": [
        "boolean_xor([True, True, False, False])\n"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gyooTq6XNEFj"
      },
      "source": [
        ">Q. 3. Create a function that creates a box based on dimension n.\n",
        "Examples\n",
        "make_box(5) ➞ [\n",
        "'#####',\n",
        "'# #',\n",
        "'# #',\n",
        "'# #',\n",
        "'#####'\n",
        "]\n",
        "make_box(3) ➞ [\n",
        "'###',\n",
        "'# #',\n",
        "'###'\n",
        "]\n",
        "make_box(2) ➞ [\n",
        "'##',\n",
        "'##'\n",
        "]\n",
        "make_box(1) ➞ [\n",
        "'#'\n",
        "]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rIESqKofNBpQ"
      },
      "source": [
        "def make_box(n) :\n",
        "    box = []\n",
        "    boxStr =''\n",
        "    for i in range(1, n+1) :\n",
        "        boxStr = ''\n",
        "        for j in range(1, n+1) :\n",
        "            if (i == 1 or i == n or\n",
        "                j == 1 or j == n) :           \n",
        "                boxStr = boxStr + '#'\n",
        "            else :\n",
        "                boxStr = boxStr + ' '\n",
        "        box.append(boxStr)\n",
        "    for i in range(len(box)):\n",
        "        print(box[i],end='\\n')\n",
        "    return box"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RubDfI5QNHhV",
        "outputId": "c795bc93-b587-4ff4-fb55-2e796e86911a"
      },
      "source": [
        "make_box(5)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "#####\n",
            "#   #\n",
            "#   #\n",
            "#   #\n",
            "#####\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['#####', '#   #', '#   #', '#   #', '#####']"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vBjN57nTNIqg",
        "outputId": "7b626207-843f-42b4-8396-74a0d4871956"
      },
      "source": [
        "make_box(3)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "###\n",
            "# #\n",
            "###\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['###', '# #', '###']"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GYhJAV3QNJ8C",
        "outputId": "184fbd8d-93d0-4174-fb23-e01ca4921a2f"
      },
      "source": [
        "make_box(2)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "##\n",
            "##\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['##', '##']"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_rxo1tnXNLrJ",
        "outputId": "bfca114b-0ac2-4922-a6fb-9dd58636e649"
      },
      "source": [
        "make_box(1)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "#\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['#']"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vKy7afKZNPx7"
      },
      "source": [
        ">Q. 4. Given a common phrase, return False if any individual word in the phrase\n",
        "contains duplicate letters. Return True otherwise.\n",
        "Examples\n",
        "no_duplicate_letters('Fortune favours the bold.') ➞ True\n",
        "no_duplicate_letters('You can lead a horse to water, but you can't make him\n",
        "drink.') ➞ True\n",
        "no_duplicate_letters('Look before you leap.') ➞ False"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yRnAPrO0NNC7"
      },
      "source": [
        "def no_duplicate_letters(text):\n",
        "    lst = text.split(' ')\n",
        "    for word in lst:\n",
        "        for i in range(len(word)):\n",
        "            for j in range(i + 1,len(word)):\n",
        "                if(word[i] == word[j]):\n",
        "                    return False;\n",
        "        # If no duplicate characters, return true\n",
        "    return True;"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mFXr7a2tNSoS",
        "outputId": "0f6cee56-2b39-448c-be4d-3edc6ae8c26f"
      },
      "source": [
        "no_duplicate_letters('Fortune favours the bold.')"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SoTrQ-pkNT1p",
        "outputId": "800fa543-daab-44a6-b019-f6570828c73f"
      },
      "source": [
        "no_duplicate_letters(\"You can lead a horse to water, but you can't make him drink.\")"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LHAfVgRBNVYj",
        "outputId": "fb81f611-b64c-4a26-9948-27ea149a5eb5"
      },
      "source": [
        "no_duplicate_letters('Look before you leap.')"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kJELt_ZgNXUx",
        "outputId": "7abe052f-8022-4716-9eb2-9199d181d47b"
      },
      "source": [
        "no_duplicate_letters('An apple a day keeps the doctor away.')"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "59UJzQAgNa5o"
      },
      "source": [
        ">Q. 5. Write a regular expression that will match the states that voted yes to\n",
        "President Trump's impeachment. You must use RegEx positive lookahead.\n",
        "Example\n",
        "txt = 'Texas = no, California = yes, Florida = yes, Michigan = no'\n",
        "pattern = '?=yes'\n",
        "re.findall(pattern, txt) ➞ ['California', 'Florida']"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mwUZ_0iqNYwB",
        "outputId": "6f7dff82-07be-4467-8cfe-8599dba8bfdd"
      },
      "source": [
        "txt = 'Texas = no, California = yes, Florida = yes, Michigan = no'\n",
        "pattern = '?=yes'\n",
        "import re\n",
        "pattern = r'\\w+(?= = yes)'\n",
        "result = re.findall(pattern, txt) \n",
        "print(result)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['California', 'Florida']\n"
          ]
        }
      ]
    }
  ]
}