Ineuron_Python_Advanced_Programming08.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Ineuron_Python_Advanced_Programming08.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KJqGUsbPQfzm"
      },
      "source": [
        "#Ineuron Python Advanced Programming 08"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hVYWzNfzRDKt"
      },
      "source": [
        ">Q. 1. Given a sentence as txt, return True if any two adjacent words have this\n",
        "property: One word ends with a vowel, while the word immediately after\n",
        "begins with a vowel (a e i o u).\n",
        "Examples\n",
        "vowel_links('a very large appliance') ➞ True\n",
        "vowel_links('go to edabit') ➞ True\n",
        "vowel_links('an open fire') ➞ False\n",
        "vowel_links('a sudden applause') ➞ False"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KyRNPTLmQE6N"
      },
      "source": [
        "def vowel_links(txt):   \n",
        "    vowel = 'aeiou'                        # check the vowels\n",
        "    lst = txt.split(\" \")                   # split the texts in the list\n",
        "    found = False                          # lets set we have not met the condition\n",
        "    i = 0\n",
        "    j = 0\n",
        "    while i < len(lst)-1:                  # loops through the list elements\n",
        "        j = i + 1    \n",
        "        vl = lst[i][-1]\n",
        "        vf = lst[j][0]\n",
        "        if vl in vowel and vf in vowel:     # if last letter ends with vowel and first letter stats with vowel and adjacent words\n",
        "            found = True\n",
        "        i += 1\n",
        "        j += 1\n",
        "    return found"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FxBZ6n3kRGXU",
        "outputId": "4b05d7c1-4710-45d9-a859-de9eea609bd4"
      },
      "source": [
        "vowel_links('a very large appliance')\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XZ6K1jXKRHwu",
        "outputId": "12916656-d000-4f50-f13c-41e8e87210b8"
      },
      "source": [
        "vowel_links('go to edabit')\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XcADtn-YRI5Q",
        "outputId": "bb3013aa-c278-4be6-95cf-e22403003cd3"
      },
      "source": [
        "vowel_links('an open fire')\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cilpDDNbRJ-R",
        "outputId": "726ee306-568d-4e75-f30c-5f51d4de86b4"
      },
      "source": [
        "vowel_links('a sudden applause')\n"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OjxVKYcJRONG"
      },
      "source": [
        ">Q. 2. You are given three inputs: a string, one letter, and a second letter.\n",
        "Write a function that returns True if every instance of the first letter occurs\n",
        "before every instance of the second letter.\n",
        "Examples\n",
        "first_before_second('a rabbit jumps joyfully', 'a', 'j') ➞ True\n",
        "Every instance of 'a' occurs before every instance of 'j'.\n",
        "first_before_second('knaves knew about waterfalls', 'k', 'w') ➞ True\n",
        "first_before_second('happy birthday', 'a', 'y') ➞ False\n",
        " The 'a' in 'birthday' occurs after the 'y' in 'happy'.\n",
        "first_before_second('precarious kangaroos', 'k', 'a') ➞ False"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "13Q8_nBKRLJD"
      },
      "source": [
        "def findIdx(text,s):\n",
        "    lst= []\n",
        "    for i in range(len(text)):\n",
        "        if (text[i] == s):\n",
        "            lst.append(i)\n",
        "    return lst\n",
        "\n",
        "def findidxDiff(list1,list2):\n",
        "    found = False\n",
        "    for i in list1:\n",
        "        for j in list2:\n",
        "            if i < j :\n",
        "                found = True\n",
        "            else:\n",
        "                found = False\n",
        "                break\n",
        "    return found\n",
        "\n",
        "\n",
        "def first_before_second(text,ch1,ch2):\n",
        "    idxCh1 = findIdx(text,ch1)\n",
        "    idxCh2 = findIdx(text,ch2)\n",
        "    print(\"Indexs of first letter {} is/are {}: \".format(ch1,idxCh1))\n",
        "    print(\"Indexs of Second letter {} is/are {}: \".format(ch2,idxCh2))\n",
        "    return findidxDiff(idxCh1,idxCh2)"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0gBdepBmRZa0",
        "outputId": "4ecc77df-7016-4da3-9022-d15d1af01966"
      },
      "source": [
        "first_before_second('a rabbit jumps joyfully', 'a', 'j')\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Indexs of first letter a is/are [0, 3]: \n",
            "Indexs of Second letter j is/are [9, 15]: \n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ERQy5UCJRaqM",
        "outputId": "2a8e69fd-6470-4ef1-dd38-924a68beb6ce"
      },
      "source": [
        "first_before_second('knaves knew about waterfalls', 'k', 'w')\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Indexs of first letter k is/are [0, 7]: \n",
            "Indexs of Second letter w is/are [10, 18]: \n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ys2p0RtQRdCn",
        "outputId": "cf235876-7cc8-45c4-8c27-2a0127562a16"
      },
      "source": [
        "first_before_second('happy birthday', 'a', 'y')\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Indexs of first letter a is/are [1, 12]: \n",
            "Indexs of Second letter y is/are [4, 13]: \n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kL-KLoBSRewi",
        "outputId": "674d4a8f-981b-4da3-cc55-d7aa7b9c50a7"
      },
      "source": [
        "first_before_second('precarious kangaroos', 'k', 'a')\n"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Indexs of first letter k is/are [11]: \n",
            "Indexs of Second letter a is/are [4, 12, 15]: \n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5oyEDUxiRi7G"
      },
      "source": [
        ">Q. 3. Create a function that returns the characters from a list or string r on odd or\n",
        "even positions, depending on the specifier s. The specifier will be 'odd' for\n",
        "items on odd positions (1, 3, 5, ...) and 'even' for items on even positions (2,\n",
        "4, 6, ...).\n",
        "Examples\n",
        "char_at_pos([2, 4, 6, 8, 10], 'even') ➞ [4, 8]\n",
        " 4 & 8 occupy the 2nd & 4th positions\n",
        "char_at_pos('EDABIT', 'odd') ➞ 'EAI'\n",
        " 'E', 'A' and 'I' occupy the 1st, 3rd and 5th positions\n",
        "\n",
        "char_at_pos(['A', 'R', 'B', 'I', 'T', 'R', 'A', 'R', 'I', 'L', 'Y'], 'odd') ➞ ['A',\n",
        "'B', 'T', 'A', 'I', 'Y']"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DoRWybQmRf3d"
      },
      "source": [
        "def char_at_pos(data,specifier):\n",
        "\n",
        "    resultlist = []\n",
        "    if specifier == 'odd':\n",
        "        for i in range(len(data)):\n",
        "            i = i+1\n",
        "            if i % 2 != 0 :\n",
        "                resultlist.append(data[i-1])\n",
        "    elif specifier == 'even':\n",
        "        for i in range(len(data)):\n",
        "            i = i+1\n",
        "            if i % 2 == 0 :\n",
        "                resultlist.append(data[i-1])\n",
        "\n",
        "    if type(data) == str:\n",
        "        return ''.join(resultlist)\n",
        "    else:\n",
        "        return resultlist"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yEJseBRyRomq",
        "outputId": "7dc09d16-b86f-4b66-ba02-659c7f61204b"
      },
      "source": [
        "char_at_pos([2, 4, 6, 8, 10], 'even')\n"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[4, 8]"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "Tb96Xp6VRqz5",
        "outputId": "12f18397-8204-4812-85fd-4e9a40205586"
      },
      "source": [
        "char_at_pos('EDABIT', 'odd')\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'EAI'"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n-YRgd9jRsAB",
        "outputId": "3428b721-4930-4a36-f186-976c79f62952"
      },
      "source": [
        "char_at_pos(['A', 'R', 'B', 'I', 'T', 'R', 'A', 'R', 'I', 'L', 'Y'], 'odd')\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['A', 'B', 'T', 'A', 'I', 'Y']"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xa7oe1zkRv7d"
      },
      "source": [
        ">Q. 4. Write a function that returns the greatest common divisor of all list\n",
        "elements. If the greatest common divisor is 1, return 1.\n",
        "Examples\n",
        "GCD([10, 20, 40]) ➞ 10\n",
        "GCD([1, 2, 3, 100]) ➞ 1\n",
        "GCD([1024, 192, 2048, 512]) ➞ 64"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B-ATqYVdRtvj"
      },
      "source": [
        "def find_gcd(x, y):\n",
        "    while(y):\n",
        "        x, y = y, x % y  \n",
        "    return x      \n",
        "      \n",
        "def GCD(data):\n",
        "    \n",
        "    num1=data[0]\n",
        "    num2=data[1]\n",
        "    gcd=find_gcd(num1,num2)\n",
        "\n",
        "    for i in range(2,len(data)):\n",
        "        gcd=find_gcd(gcd,data[i])\n",
        "\n",
        "    return gcd"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ga0M77CmRzuH",
        "outputId": "b750c6e4-05ff-4df9-8a9b-c7332b53f50e"
      },
      "source": [
        "GCD([10, 20, 40])\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tbD1IvYDR0tI",
        "outputId": "6a1fb095-d1b2-40b6-b7c0-9b8c4a143d27"
      },
      "source": [
        "GCD([1, 2, 3, 100])\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hir-VwzYR1sv",
        "outputId": "c5108281-a2ae-456c-818d-9e33336b0bee"
      },
      "source": [
        "GCD([1024, 192, 2048, 512])\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "64"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k3v_pvy9R5pV"
      },
      "source": [
        ">Q. 5. A number/string is a palindrome if the digits/characters are the same when\n",
        "read both forward and backward. Examples include 'racecar' and 12321.\n",
        "Given a positive number n, check if n or the binary representation of n is\n",
        "palindromic. Return the following:\n",
        "- 'Decimal only.' if only n is a palindrome.\n",
        "- 'Binary only.' if only the binary representation of n is a palindrome.\n",
        "- 'Decimal and binary.' if both are palindromes.\n",
        "- 'Neither!' if neither are palindromes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gyeGuE4FR3E1"
      },
      "source": [
        "def is_symmetrical(num):\n",
        "    currentDigit = reversedDigit = 0\n",
        "    remainingNum = num\n",
        "    while(remainingNum != 0):\n",
        "\n",
        "        currentDigit = remainingNum % 10\n",
        "\n",
        "        reversedDigit = reversedDigit * 10 + currentDigit\n",
        "        remainingNum = remainingNum // 10\n",
        "\n",
        "    if reversedDigit == num:\n",
        "        print('Num {} is palindromic'.format(num))\n",
        "        return True\n",
        "    else:\n",
        "        print('Num {} is not palindromic'.format(num))\n",
        "        return False\n",
        "\n",
        "def palindrome_type(num):\n",
        "    \n",
        "    binNum = int(str(bin(num))[2::]) # change num to bin number\n",
        "    print(\"The number - \", num)\n",
        "    print(num,\" in binary\", binNum)\n",
        "    decCheck = is_symmetrical(num)\n",
        "    binCheck = is_symmetrical(binNum)\n",
        "    msg = ''\n",
        "    if decCheck and binCheck:\n",
        "        msg = 'Decimal and binary.'\n",
        "    elif decCheck and not binCheck:\n",
        "        msg = 'Decimal only.'\n",
        "    elif not decCheck and binCheck:\n",
        "        msg = 'Binary only.'\n",
        "    else:\n",
        "        msg = 'Neither!'\n",
        "\n",
        "    return msg"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 105
        },
        "id": "78bGxM7nSN-P",
        "outputId": "91eb0abb-fcec-431b-fdc9-1ba95c81aa4e"
      },
      "source": [
        "palindrome_type(1306031)\n"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The number -  1306031\n",
            "1306031  in binary 100111110110110101111\n",
            "Num 1306031 is palindromic\n",
            "Num 100111110110110101111 is not palindromic\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Decimal only.'"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w_5i7FSMSTvp",
        "outputId": "00534750-4698-4b7f-ea36-cf7aa3bc4eef",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 105
        }
      },
      "source": [
        "palindrome_type(427787)\n"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The number -  427787\n",
            "427787  in binary 1101000011100001011\n",
            "Num 427787 is not palindromic\n",
            "Num 1101000011100001011 is palindromic\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Binary only.'"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B_fbIBhrSU66",
        "outputId": "05cc1ca8-8db7-45bc-f256-1f2915d6b00b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 105
        }
      },
      "source": [
        "palindrome_type(313)\n"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The number -  313\n",
            "313  in binary 100111001\n",
            "Num 313 is palindromic\n",
            "Num 100111001 is palindromic\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Decimal and binary.'"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AWVyzJXSSV2U",
        "outputId": "a44aed2d-39bf-427f-eb19-dfab22335b78",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 105
        }
      },
      "source": [
        "palindrome_type(934)\n"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The number -  934\n",
            "934  in binary 1110100110\n",
            "Num 934 is not palindromic\n",
            "Num 1110100110 is not palindromic\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Neither!'"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    }
  ]
}