Ineuron_Python_Advanced_Programming01.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming01.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U3f9jygIzpJa"
      },
      "source": [
        "# Ineuron Python Advanced Programming 01"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e4_BeqQ0zuTo"
      },
      "source": [
        "> Q. Write a function that takes a list of lists and returns the value of all of the\n",
        "symbols in it, where each symbol adds or takes something from the total\n",
        "score. Symbol values:\n",
        " = 5\n",
        "O = 3\n",
        "X = 1\n",
        "! = -1\n",
        "!! = -3\n",
        "!!! = -5\n",
        "A list of lists containing 2 #s, a O, and a !!! would equal (0 + 5 + 5 + 3 - 5) 8.\n",
        "If the final score is negative, return 0 (e.g. 3 #s, 3 !!s, 2 !!!s and a X would be\n",
        "(0 + 5 + 5 + 5 - 3 - 3 - 3 - 5 - 5 + 1) -3, so return 0.\n",
        "Examples\n",
        "check_score([\n",
        "['#', '!'],\n",
        "['!!', 'X']\n",
        "]) ➞ 2\n",
        "check_score([\n",
        "['!!!', 'O', '!'],\n",
        "['X', '#', '!!!'],\n",
        "['!!', 'X', 'O']\n",
        "]) ➞ 0"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RBKNzZ77y5_p"
      },
      "source": [
        "def check_score(lst):\n",
        "    symbol = {'#' : 5, 'O' : 3, 'X' : 1, '!' : -1, '!!' : -3, '!!!' : -5}\n",
        "    expression = ''\n",
        "    for i in lst:\n",
        "        for j in i:\n",
        "            expression = expression + '+' + '(' + str(symbol[j]) + ')'\n",
        "    print('The Expression : ',expression )\n",
        "    if eval(expression) < 0 :\n",
        "        return 0\n",
        "    else:\n",
        "        return eval(expression)"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cloXZvBEzy7Q",
        "outputId": "a69b9f6a-2dc3-48f2-ed40-07140609be19"
      },
      "source": [
        "check_score([\n",
        "['#', '!'],\n",
        "['!!', 'X']\n",
        "])"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The Expression :  +(5)+(-1)+(-3)+(1)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hf0qdLrFz0ON",
        "outputId": "f724da92-9fe4-45f9-87ae-94850be0ca84"
      },
      "source": [
        "check_score([\n",
        "['!!!', 'O', '!'],\n",
        "['X', '#', '!!!'],\n",
        "['!!', 'X', 'O']\n",
        "])"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The Expression :  +(-5)+(3)+(-1)+(1)+(5)+(-5)+(-3)+(1)+(3)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_Tv4HKILz4xU"
      },
      "source": [
        ">Q.  Create a function that takes a variable number of arguments, each\n",
        "argument representing the number of items in a group, and returns the\n",
        "number of permutations (combinations) of items that you could get by taking\n",
        "one item from each group.\n",
        "Examples\n",
        "combinations(2, 3) ➞ 6\n",
        "combinations(3, 7, 4) ➞ 84\n",
        "combinations(2, 3, 4, 5) ➞ 120"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HBNkDNDdz24q"
      },
      "source": [
        "def combinations(*args):\n",
        "    comb = 1\n",
        "    for i in args:\n",
        "        comb = comb*i\n",
        "    return comb"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HbOqepuo0jF1",
        "outputId": "8b3cee98-058d-4d66-ea80-591ac6a2d688"
      },
      "source": [
        "combinations(2, 3)\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "htYGtvGd0kVQ",
        "outputId": "a2b1f932-c439-4429-bff3-e284e7c023d4"
      },
      "source": [
        "combinations(3, 7, 4)\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "84"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TRr0Djew0lh3",
        "outputId": "7b589a0e-46e9-4c91-d9a6-3c96278ddce6"
      },
      "source": [
        "combinations(2, 3, 4, 5)\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "120"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8DF2kZVP0pJo"
      },
      "source": [
        ">Q. Create a function that takes a string as an argument and returns the Morse"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1UBqfJMH0mrM"
      },
      "source": [
        "char_to_dots = {\n",
        "'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.',\n",
        "'G': '--.', 'H': '....', 'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..',\n",
        "'M': '--', 'N': '-.', 'O': '---', 'P': '.--.', 'Q': '--.-', 'R': '.-.',\n",
        "'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-',\n",
        "'Y': '-.--', 'Z': '--..', ' ': ' ', '0': '-----',\n",
        "'1': '.----', '2': '..---', '3': '...--', '4': '....-', '5': '.....',\n",
        "'6': '-....', '7': '--...', '8': '---..', '9': '----.',\n",
        "'&': '.-...', \"'\": '.----.', '@': '.--.-.', ')': '-.--.-', '(': '-.--.',\n",
        "':': '---...', ',': '--..--', '=': '-...-', '!': '-.-.--', '.': '.-.-.-',\n",
        "'-': '-....-', '+': '.-.-.', \"\": '.-..-.', '?': '..--..', '/': '-..-.'\n",
        "}\n",
        "\n",
        "def encode_morse(str):\n",
        "    morse = []\n",
        "    for c in str:\n",
        "        \n",
        "        morse.append(char_to_dots[c])\n",
        "    print(morse)\n",
        "        \n",
        "    return ''.join(morse)"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "RQl8SwLF0uB1",
        "outputId": "598b13a6-f067-4ab9-a108-5466bbc07a84"
      },
      "source": [
        "encode_morse('EDABBIT CHALLENGE')"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['.', '-..', '.-', '-...', '-...', '..', '-', ' ', '-.-.', '....', '.-', '.-..', '.-..', '.', '-.', '--.', '.']\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'.-...--...-.....- -.-......-.-...-...-.--..'"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "NAyFTPhp0vko",
        "outputId": "0870bc59-5b16-4957-ead8-24b4a65efeba"
      },
      "source": [
        "encode_morse('HELP ME @')"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['....', '.', '.-..', '.--.', ' ', '--', '.', ' ', '.--.-.']\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'......-...--. --. .--.-.'"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4t0JT4xo0zCm"
      },
      "source": [
        ">Q. Write a function that takes a number and returns True if it's a prime; False otherwise.\n",
        "The number can be 2^64-1 (2 to the power of 63, not XOR). With\n",
        "the standard technique it would be O(2^64-1), which is much too large for the\n",
        "10 second time limit.\n",
        "Examples\n",
        "prime(7) ➞ True\n",
        "prime(56963) ➞ True\n",
        "prime(5151512515524) ➞ False"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cdybQXWe0xMG"
      },
      "source": [
        "def prime(n):\n",
        "    if (n==1):\n",
        "        return False\n",
        "    elif (n==2):\n",
        "        return True;\n",
        "    else:\n",
        "        for x in range(2,n):\n",
        "            if(n % x==0):\n",
        "                return False\n",
        "        return True"
      ],
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CmaeiG1o02cJ",
        "outputId": "3e73c124-48ec-4b70-8e02-747ffc2d2ed0"
      },
      "source": [
        "prime(7)\n"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l2EOmvR303iU",
        "outputId": "582aa8a3-78be-4714-ad66-d60a65ad22e7"
      },
      "source": [
        "prime(56963)\n"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TcpJb3j204i5",
        "outputId": "fb6336a0-b635-401b-c29a-a73f1f9cd62f"
      },
      "source": [
        "prime(545664556456)\n"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7UtcaA2Q08kV"
      },
      "source": [
        ">Q. Create a function that converts a word to a bitstring and then to a boolean list based on the following criteria:\n",
        "\n",
        "1. Locate the position of the letter in the English alphabet (from 1 to 26).\n",
        "2. Odd positions will be represented as 1 and 0 otherwise.\n",
        "3. Convert the represented positions to boolean values, 1 for True and 0\n",
        "for False.\n",
        "4. Store the conversions into an array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a5vdZI8r05rZ"
      },
      "source": [
        "def char_position(letter):\n",
        "    return (ord(letter) - 97) + 1\n",
        "\n",
        "def to_boolean_list(s):\n",
        "    lst = []\n",
        "    for i in range(len(s)):\n",
        "        if char_position(s[i]) % 2 == 0:\n",
        "            lst.append(False)\n",
        "        else:\n",
        "            lst.append(True)\n",
        "    return lst"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-qkhdS-03_lw",
        "outputId": "0da179e8-964b-4faf-ae88-c25d113110cf"
      },
      "source": [
        "to_boolean_list('deep')"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[False, True, True, False]"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GJzwznm44A9P",
        "outputId": "8e5d4884-658b-4c6b-d1da-390ef840df85"
      },
      "source": [
        "to_boolean_list('loves')"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[False, True, False, True, True]"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "38xzpcCj4C1o",
        "outputId": "d0cad911-610f-455a-febf-de396dd979a7"
      },
      "source": [
        "to_boolean_list('tesh')"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[False, True, True, False]"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    }
  ]
}