Practice Split, Slice, Enumerate, etc. etc..ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'The world is good'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', 'world', 'is', 'good']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'The, world, is, good'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', ' world', ' is', ' good']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.split(',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'The: world: is: good'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', ' world', ' is', ' good']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.split(':')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'Theworldisgood'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The\n",
      "wor\n",
      "ldi\n",
      "sgo\n",
      "od\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, len(x), 3):\n",
    "   print(x[i:i+3]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The', 'wor', 'ldi', 'sgo', 'od']\n"
     ]
    }
   ],
   "source": [
    "print ([x[i:i+3] for i in range(0, len(x), 3)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maxsplit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 'The, WOrld, is, good'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', ' WOrld', ' is, good']"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.split(',',2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', ' WOrld, is, good']"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.split(',',1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(sentence):\n",
    "    for char in range(0, len(sentence), 3):     # Range starting from index 0 to the length of word, with gap after index 3\n",
    "       print(sentence[char:char+3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abr\n",
      "aca\n",
      "dab\n",
      "ra\n"
     ]
    }
   ],
   "source": [
    "func('abracadabra')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(sentence):\n",
    "    print ([sentence[char:char+3] for char in range(0, len(sentence), 3)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['abr', 'aca', 'dab', 'ra']\n"
     ]
    }
   ],
   "source": [
    "func('abracadabra')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'theworldisbeautiful'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = x[slice(3,8)].capitalize()     # Slice a chunk of characters out of a word and then Capitalize the First Character\n",
    "z = x[slice(0,3)].capitalize()\n",
    "a = x[slice(8,10)].capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = [z + y+a]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['TheWorldIs']\n"
     ]
    }
   ],
   "source": [
    "print (b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The World Is Beautiful\n"
     ]
    }
   ],
   "source": [
    "x = 'theworldisbeautiful'\n",
    "\n",
    "a = x[:3].capitalize()\n",
    "b = x[3:8].capitalize()\n",
    "c = x[8:10].capitalize()\n",
    "d = x[10:].capitalize()\n",
    "\n",
    "print (a +' ' + b +' ' + c +' ' + d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write a function that capitalizes the first and fourth words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mac Donald'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using slicing and capitalize method\n",
    "\n",
    "def old_macdonald(name):\n",
    "    a = name[:3].capitalize()\n",
    "    b = name[3:].capitalize()\n",
    "    \n",
    "    return a + ' ' + b\n",
    "\n",
    "old_macdonald('macdonald')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MacDonald'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using slicing and .upper method\n",
    "\n",
    "def old_macdonald(name):\n",
    "    first = name[0].upper()\n",
    "    sec = name[1:3]\n",
    "    third = name[3].upper()\n",
    "    forth = name[4:]\n",
    "    \n",
    "    return first + sec + third + forth\n",
    "    \n",
    "old_macdonald('macdonald')   \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse words in a sentence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sample : 'I Love You' will become 'You Love I'\n",
    "# Using split, .join and slicing method\n",
    "\n",
    "def reverse_words(text):\n",
    "    a = text.split(' ')\n",
    "    b = ' '.join(a[::-1])\n",
    "    return b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'You Love I'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse_words('I Love You')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ONE LINER CODES\n",
    "\n",
    "def reverse_words(text):\n",
    "    return ' '.join(text.split(' ')[::-1])\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'You Love I'"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse_words('I Love You')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse characters in a word or sentence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using slicing method\n",
    "\n",
    "def reverse_chars(text):\n",
    "    a = text[::-1]\n",
    "    return a\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'uoY evoL I'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse_chars('I Love You')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ONE LINER CODES\n",
    "\n",
    "def reverse_chars(text):\n",
    "    return text[::-1]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'uoY evoL I'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse_chars('I Love You')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrey\n",
    "\n",
    "has_33([1, 3, 3]) → True\n",
    "\n",
    "has_33([1, 3, 1, 3]) → False\n",
    "\n",
    "has_33([3, 1, 3]) → False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In an arrey , if 2 nos are same Returns True Else False\n",
    "\n",
    "def has_33(nums):\n",
    "    \n",
    "    for int in range(0, len(nums)-1):\n",
    "        if nums[int] == 3 and nums[int+1] == 3:\n",
    "            return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "has_33([1, 3, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "has_33([1, 3, 1, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "has_33([3, 1, 3,4,3,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "def has_33(nums):\n",
    "    \n",
    "    for i in range(0, len(nums) -1):\n",
    "        if (nums[i], nums[i+1]) == (3,3):\n",
    "            return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "has_33([1, 3, 1, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "has_33([3, 1, 3, 4, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "has_33([1, 3, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "## WRONG WHEN PUT IN REPETITIVE MODE FOR 6,9\n",
    "\n",
    "# As per Jose's solution\n",
    "\n",
    "def summer_69(arr):\n",
    "    \n",
    "    total = 0\n",
    "    add = True\n",
    "    \n",
    "    for num in arr:\n",
    "        while add:\n",
    "            if num!=6:\n",
    "                total += num\n",
    "                break\n",
    "            else:\n",
    "                add = False\n",
    "        while not add:\n",
    "            if num != 9:\n",
    "                break\n",
    "            else:\n",
    "                add = True\n",
    "                break\n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is ok\n",
    "\n",
    "summer_sum([2, 1, 6,5,2,1, 9, 11])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "31"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here the answer will be 2+1+11+2 = 16 but it's coming 31\n",
    "\n",
    "summer_sum([2, 1, 6,5,2,1, 9, 11, 6 , 9, 2 ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "## WRONG WHEN PUT IN REPETITIVE MODE FOR 6,9\n",
    "\n",
    "# Debasis's Solution\n",
    "\n",
    "def summer_69(arr):\n",
    "    if 6 in arr:\n",
    "        return sum(arr) - sum(arr[arr.index(6):arr.index(9)+1]) \n",
    "    else:\n",
    "        return sum(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is ok\n",
    "\n",
    "summer_sum([2, 1, 6,5,2,1, 9, 11])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "31"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Here the answer will be 2+1+11+2 = 16 but it's coming 31\n",
    "\n",
    "summer_sum([2, 1, 6,5,2,1, 9, 11, 6 , 9, 2 ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SPY GAME: Write a function that takes in a list of integers and returns True if it contains 007 in order\n",
    "\n",
    " spy_game([1,2,4,0,0,7,5]) --> True\n",
    " \n",
    " spy_game([1,0,2,4,0,5,7]) --> True\n",
    " \n",
    " spy_game([1,7,2,0,4,5,0]) --> False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "def spy_game(nums):\n",
    "    \n",
    "    \n",
    "    code = [0,0,7,'x']\n",
    "    # Using pop function will take away the index [0] of code\n",
    "    # So next will be [0,7,'x']\n",
    "    # and next will be [7,'x']\n",
    "    # lastly it will be ['x']\n",
    "    \n",
    "    for num in nums:\n",
    "        if num == code[0]:\n",
    "            code.pop(0)\n",
    "            \n",
    "    return len(code) == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spy_game([1,2,4,0,0,7,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spy_game([1,0,2,4,0,5,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spy_game([1,7,2,0,4,5,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}