programming_assignment_advance_08.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1f5d7e73",
   "metadata": {},
   "source": [
    "#Question : 01\n",
    "\n",
    "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",
    "\n",
    "Examples\n",
    "\n",
    "vowel_links(\"a very large appliance\") ➞ True\n",
    "\n",
    "vowel_links(\"go to edabit\") ➞ True\n",
    "\n",
    "vowel_links(\"an open fire\") ➞ False\n",
    "\n",
    "vowel_links(\"a sudden applause\") ➞ False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9b91c057",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "def vowel_links(strr):\n",
    "    match = \"aAeEiIoOuU\"\n",
    "    words = strr.split()\n",
    "    for i in words:\n",
    "        words.append(\" \")\n",
    "        if i[len(i)-1] in match:\n",
    "            if words[words.index(i) + 1][0] in match:\n",
    "                return True\n",
    "        words.pop()\n",
    "    return False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a495761c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vowel_links(\"a very large appliance\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "7703c1fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vowel_links(\"go to edabit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "bd8d13a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vowel_links(\"an open fire\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1a912c12",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vowel_links(\"a sudden applause\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f9f50b7",
   "metadata": {},
   "source": [
    "#Question : 02\n",
    "\n",
    "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",
    "\n",
    "Examples\n",
    "\n",
    "first_before_second(\"a rabbit jumps joyfully\", \"a\", \"j\") ➞ True\n",
    "\n",
    "# Every instance of \"a\" occurs before every instance of \"j\".\n",
    "\n",
    "first_before_second(\"knaves knew about waterfalls\", \"k\", \"w\") ➞ True\n",
    "\n",
    "first_before_second(\"happy birthday\", \"a\", \"y\") ➞ False\n",
    "\n",
    "# The \"a\" in \"birthday\" occurs after the \"y\" in \"happy\".\n",
    "\n",
    "first_before_second(\"precarious kangaroos\", \"k\", \"a\") ➞ False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "95f49a5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "def first_before_second(sentence,first_letter,second_letter):\n",
    "    for i in range(len(sentence)):\n",
    "        if sentence[i] == second_letter:\n",
    "            for j in range(i+1,len(sentence)):\n",
    "                if sentence[j] == first_letter:\n",
    "                    return False\n",
    "                else:continue                \n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "64a2d068",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_before_second(\"knaves knew about waterfalls\", \"k\", \"w\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "c136d1d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_before_second(\"happy birthday\", \"a\", \"y\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "c2f28d1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_before_second(\"precarious kangaroos\", \"k\", \"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "fa30a6ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_before_second(\"a rabbit jumps joyfully\", \"a\", \"j\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d19c2803",
   "metadata": {},
   "source": [
    "#Question : 03\n",
    "\n",
    "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",
    "\n",
    "Examples\n",
    "\n",
    "char_at_pos([2, 4, 6, 8, 10], \"even\") ➞ [4, 8]\n",
    "\n",
    "# 4 &amp; 8 occupy the 2nd &amp; 4th positions\n",
    "\n",
    "char_at_pos(\"EDABIT\", \"odd\") ➞ \"EAI\"\n",
    "\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\",\"B\", \"T\", \"A\", \"I\", \"Y\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "677f33e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def char_at_pos(value,category):\n",
    "    if category.lower() == \"odd\":\n",
    "        Ans = []\n",
    "        for i in range(len(value)):\n",
    "            if (i+1)%2!=0:\n",
    "                Ans.append(value[i])\n",
    "        return Ans\n",
    "    if category.lower() == \"even\":\n",
    "        Ans = []\n",
    "        for i in range(len(value)):\n",
    "            if (i+1)%2==0:\n",
    "                Ans.append(value[i])\n",
    "        return Ans\n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "2ffb88e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 8]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "char_at_pos([2, 4, 6, 8, 10], \"even\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "5bd6b6e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['E', 'A', 'I']"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "char_at_pos(\"EDABIT\", \"odd\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "b7de5b5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'T', 'A', 'I', 'Y']"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "char_at_pos([\"A\", \"R\", \"B\", \"I\", \"T\", \"R\", \"A\", \"R\", \"I\", \"L\", \"Y\"], \"odd\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "f9cb8efb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Question : 04\n",
    "\n",
    "def GCD(values):\n",
    "    count = 0\n",
    "    Ans=0\n",
    "    if min(values)==1:\n",
    "        return 1\n",
    "    elif min(values)>1:\n",
    "        for j in range(min(values),1,-1):\n",
    "            for i in range(len(values)):\n",
    "                if values[i] % j != 0:\n",
    "                    break\n",
    "            else:\n",
    "                count+=1\n",
    "                Ans = j\n",
    "                return Ans\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "3291b261",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GCD([10, 20, 40])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "32e3fc3b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GCD([1, 2, 3, 100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "f969b478",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GCD([1024, 192, 2048, 512])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83396c35",
   "metadata": {},
   "source": [
    "#Question : 05\n",
    "\n",
    "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",
    "\n",
    "    - \"Decimal only.\" if only n is a palindrome.\n",
    "\n",
    "    - \"Binary only.\" if only the binary representation of n is a palindrome.\n",
    "\n",
    "    - \"Decimal and binary.\" if both are palindromes.\n",
    "\n",
    "    - \"Neither!\" if neither are palindromes.\n",
    "\n",
    "Examples\n",
    "\n",
    "palindrome_type(1306031) ➞ \"Decimal only.\"\n",
    "\n",
    "# decimal = 1306031\n",
    "\n",
    "# binary = \"100111110110110101111\"\n",
    "\n",
    "palindrome_type(427787) ➞ \"Binary only.\"\n",
    "\n",
    "# decimal = 427787\n",
    "\n",
    "# binary = \"1101000011100001011\"\n",
    "\n",
    "palindrome_type(313) ➞ \"Decimal and binary.\"\n",
    "\n",
    "# decimal = 313\n",
    "\n",
    "# binary = 100111001\n",
    "\n",
    "palindrome_type(934) ➞ \"Neither!\"\n",
    "\n",
    "# decimal = 934\n",
    "\n",
    "# binary = \"1110100110\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "32546791",
   "metadata": {},
   "outputs": [],
   "source": [
    "#code\n",
    "\n",
    "def palindrome_type(check_this):\n",
    "    binary = str(bin(check_this))\n",
    "    binary_reverse = binary[::-1]\n",
    "    check_this = str(check_this)\n",
    "    check_this_reverse = check_this[::-1]\n",
    "    bina=0\n",
    "    deci=0\n",
    "    if check_this == check_this_reverse:\n",
    "        deci=1\n",
    "    if binary[2:] == binary_reverse[:-2]:\n",
    "        bina=1\n",
    "    if deci == 1 and bina == 1:\n",
    "        return \"Decimal and Binary\"\n",
    "    elif deci == 1 :\n",
    "        return \"Decimal only\"\n",
    "    elif bina == 1:\n",
    "        return \"Binary only\"\n",
    "    else:\n",
    "        return \"Neither\"\n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "34f08c34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Decimal only'"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palindrome_type(1306031)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "be8a1117",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Binary only'"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palindrome_type(427787)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "ed222704",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Decimal and Binary'"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palindrome_type(313)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "d5a179f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Neither'"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "palindrome_type(934)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}