InfyTQSolutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Write a python function to add 'ing' at the end of a given string and return the new string.\n",
    "1. If the given string already ends with 'ing' then add 'ly'.\n",
    "2. If the length of the given string is less than 3, leave it unchanged.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "coming\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-1\n",
    "def add_string(str1):\n",
    "    length = len(str1)\n",
    "    \n",
    "    if length > 2:\n",
    "        if str1[-3:] == 'ing':\n",
    "            str1+='ly'\n",
    "        else:\n",
    "            str1+='ing'\n",
    "\n",
    "    return str1\n",
    "\n",
    "str1=\"com\"\n",
    "print(add_string(str1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "coming\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-1\n",
    "def add_string(str1):\n",
    "    if len(str1)<3:\n",
    "        return str1\n",
    "    if 'ing' not in str1:\n",
    "        return str1+'ing'\n",
    "    if 'ing' in str1:\n",
    "        return str1 +'ly'\n",
    "   \n",
    "\n",
    "  \n",
    "    return str1\n",
    "\n",
    "str1=\"com\"\n",
    "print(add_string(str1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Write a python function which accepts a string containing a pattern of brackets and returns true if the pattern of brackets is correct. Otherwise it returns false.\n",
    "The string of brackets is correct if it satisfies the following conditions:\n",
    "1. Number of opening and closing brackets are equal.\n",
    "2. Pattern should not start with closing bracket and end with opening bracket."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PF-Prac-2\n",
    "def bracket_pattern(input_str):\n",
    "    stack = []\n",
    "    pchar = {'(':')','{':'}','[':']'}\n",
    "    \n",
    "    for paranthesis in input_str:\n",
    "        if paranthesis in pchar:\n",
    "            stack.append(paranthesis)\n",
    "        elif len(stack) == 0 or pchar[stack.pop()] != paranthesis:\n",
    "            return False\n",
    "    return len(stack) == 0\n",
    "\n",
    "    \n",
    "input_str=\"(())(\"\n",
    "print(bracket_pattern(input_str))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Write a python function to create and return a new dictionary from the given dictionary(item:price).\n",
    "Given the following input, create a new dictionary with elements having price more than 200.\n",
    "\n",
    "prices = {'ACME': 45.23,'AAPL': 612.78, 'IBM': 205.55,'HPQ': 37.20,'FB': 10.75}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PF-Prac-3\n",
    "def create_new_dictionary(prices):\n",
    "    #start writing your code here\n",
    "    new_dict = dict()\n",
    "    for key,value in prices.items():\n",
    "        if value >  200:\n",
    "            new_dict[key] = value\n",
    "\n",
    "    \n",
    "    return new_dict\n",
    "\n",
    "prices = { 'ACME': 45.23,'AAPL': 612.78,'IBM': 205.55,'HPQ': 37.20,'FB': 10.75}\n",
    "print(create_new_dictionary(prices))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "###############################################################\n",
    "#Using Dictionary Comprehension\n",
    "prices = {\n",
    "   'ACME': 45.23,\n",
    "   'AAPL': 612.78,\n",
    "   'IBM': 205.55,\n",
    "   'HPQ': 37.20,\n",
    "   'FB': 10.75\n",
    "}\n",
    "\n",
    "# Make a dictionary of all prices over 200\n",
    "p1 = {key:value for key,value in prices.items() if value>200}\n",
    "print(\"All prices over 200\")\n",
    "print(p1)\n",
    "############################################\n",
    "# Using tuple()\n",
    "p1 = dict((key,value) for key,value in prices.items() if value>200)\n",
    "print(\"\\nUsing Tuple\")\n",
    "print(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Given a list of numbers, write a python function which returns true if one of the first 4 elements in the list is 9. Otherwise it should return false.\n",
    "The length of the list can be less than 4 also."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PF-Prac-4\n",
    "def find_nine(nums):\n",
    "    count = 9\n",
    "    result = []\n",
    "    for number in nums[:4]:\n",
    "        result.append(number)\n",
    "    if count in result:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "nums=[1,2,3,4]\n",
    "print(find_nine(nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Write a python function which accepts a sentence and finds the number of letters and digits in the sentence.\n",
    "It should return a list in which the first value should be letter count and second value should be digit count.\n",
    "Ignore the spaces or any other special character in the sentence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PF-Prac-5\n",
    "def count_digits_letters(sentence):\n",
    "    digit_count = 0\n",
    "    letter_count = 0\n",
    "    \n",
    "    for letter in sentence:\n",
    "        if letter.isdigit():\n",
    "            digit_count+=1\n",
    "        if letter.isalpha():\n",
    "            letter_count+=1\n",
    "    result_list = [letter_count,digit_count]\n",
    " \n",
    "    return result_list\n",
    "\n",
    "sentence=\"Infosys Mysore 570027\"\n",
    "print(count_digits_letters(sentence))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Write a python function which accepts a list of numbers and returns true, if 1, 2, 3 appears in sequence in the list.\n",
    "Otherwise, it should return false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PF-Prac-6\n",
    "def list123(nums):\n",
    "    sequence_list = [1,2,3]\n",
    "    \n",
    "    if str(sequence_list)[1:-1] in str(nums):\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "# nums=[1,2,3,4,5]\n",
    "nums = [1, 1, 2, 4, 3]\n",
    "print(list123(nums))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PF-Prac-6\n",
    "def list123(nums):\n",
    "    for i in range(0, len(nums)-1):\n",
    "        if nums[i]==1:\n",
    "            if nums[i+1]==2:\n",
    "                if nums[i+2]==3:\n",
    "                    return True\n",
    "    return False\n",
    "\n",
    "nums=[1,2,3,4,5]\n",
    "# nums = [1, 1, 2, 4, 3]\n",
    "print(list123(nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Given two numbers, write a python function which returns true if first number is a seed of second number. Otherwise it returns false.\n",
    "A number X is said to be a seed of number Y, if multiplying X by its each digit equates to Y\n",
    "\n",
    "For example, 123 is a seed of 738 as 123*1*2*3 = 738."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PF-Prac-7\n",
    "def seed_no(number,ref_no):\n",
    "    number_str = str(number)\n",
    "    new_list = []\n",
    "    mul_count = 1\n",
    "    \n",
    "    for num in number_str:\n",
    "        new_list.append(int(num))\n",
    "        \n",
    "    for num in new_list:\n",
    "        mul_count = mul_count * num\n",
    "        \n",
    "    result=number*mul_count\n",
    "    \n",
    "    if result == ref_no:\n",
    "        return True\n",
    "    return False\n",
    "number=123\n",
    "ref_no=738\n",
    "print(seed_no(number,ref_no))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. Write a python function which accepts a list of strings containing details of deposits and withdrawals made in a bank account and returns the net amount in the account.\n",
    "Suppose the following input is supplied to the function\n",
    "[\"D:300\",\"D:300\",\"W:200\",\"D:100\"] where D means deposit and W means withdrawal,\n",
    "then the net amount in the account is 500."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "400\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-8\n",
    "def calculate_net_amount(trans_list):\n",
    "    temp_d = []\n",
    "    temp_w = []\n",
    "    \n",
    "    for i in trans_list:\n",
    "        if 'D' in i:\n",
    "            temp_d.append(i)\n",
    "        if 'W' in i:\n",
    "            temp_w.append(i)\n",
    "    deposit_list= [int(i.split(':')[1]) for i in temp_d]\n",
    "    withdraw_list = [int(i.split(':')[1]) for i in temp_w]\n",
    "    \n",
    "    total_deposit = sum(deposit_list)\n",
    "    total_withdraw = sum(withdraw_list)\n",
    "    \n",
    "    net_amount = total_deposit - total_withdraw\n",
    "    return net_amount\n",
    "\n",
    "trans_list=[\"D:300\",\"D:200\",\"W:200\",\"D:100\"]\n",
    "print(calculate_net_amount(trans_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://github.com/anumsh/Python-Programs/blob/master/bank_account.py\n",
    "\n",
    "Link for another solution based on user input from console"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original list : ['Rs. 24', 'Rs. 18', 'Rs. 8', 'Rs. 21']\n",
      "The list after Extracting numbers : [24, 18, 8, 21]\n"
     ]
    }
   ],
   "source": [
    "# Python3 code to demonstrate \n",
    "# Extracting numbers from list of strings \n",
    "# using join() + isnumeric() + list comprehension + map() \n",
    "\n",
    "# initializing list \n",
    "test_list = ['Rs. 24', 'Rs. 18', 'Rs. 8', 'Rs. 21'] \n",
    "\n",
    "# printing original list \n",
    "print(\"The original list : \" + str(test_list)) \n",
    "\n",
    "# using join() + isnumeric() + list comprehension + map() \n",
    "# Extracting numbers from list of strings \n",
    "res = list(map(lambda sub:int(''.join( \n",
    "\t[ele for ele in sub if ele.isnumeric()])), test_list)) \n",
    "\n",
    "# print result \n",
    "print(\"The list after Extracting numbers : \" + str(res)) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. Write a Python function which generates and returns a dictionary where the keys are numbers between 1 and n (both inclusive) and the values are square of keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225, 16: 256, 17: 289, 18: 324, 19: 361, 20: 400}\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-9\n",
    "def generate_dict(number):\n",
    "    new_dict= {}\n",
    "    for i in range(1,number+1):\n",
    "        new_dict[i] = i**2\n",
    "    \n",
    "    return new_dict\n",
    "\n",
    "number=20\n",
    "print(generate_dict(number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100, 11: 121, 12: 144, 13: 169, 14: 196, 15: 225, 16: 256, 17: 289, 18: 324, 19: 361, 20: 400}\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-9\n",
    "def generate_dict(number):\n",
    "    new_dict = {i : i**2 for i in range(1,number+1)}\n",
    "\n",
    "    return new_dict\n",
    "\n",
    "number=20\n",
    "print(generate_dict(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. Write a Python function which accepts a string and returns a string made of the first 2 and the last 2 characters of the given string.\n",
    "If the string length is less than 2, return -1.\n",
    "\n",
    "Note: If the string length is equal to 2, consider the 2 characters to be the first as well as the last two characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w33w\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-10\n",
    "def string_both_ends(input_string):\n",
    "    if len(input_string) <2:\n",
    "        return -1\n",
    "    if len(input_string) ==2:\n",
    "        return input_string * 2\n",
    "    for i in input_string:\n",
    "        return input_string[:2]+input_string[-2:]\n",
    "input_string=\"w3w\"\n",
    "print(string_both_ends(input_string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w3w3\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-10\n",
    "def string_both_ends(input_string):\n",
    "    if len(input_string) <2:\n",
    "        return -1\n",
    "    \n",
    "    return input_string[0:2] + input_string[-2:]\n",
    "    \n",
    "input_string=\"w3\"\n",
    "print(string_both_ends(input_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. Write a python function which accepts a sentence and returns a list in which first value is the count of upper case letters and second value is the count of lower case letters in the sentence. Ignore spaces, numbers and other special characters if any.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 6]\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-11\n",
    "def find_upper_and_lower(sentence):\n",
    "    count_upper = 0\n",
    "    count_lower = 0\n",
    "\n",
    "    for i in sentence:\n",
    "        if i.islower():\n",
    "            count_lower+=1\n",
    "        if i.isupper():\n",
    "            count_upper+=1\n",
    "    result_list=[count_upper,count_lower]   \n",
    "    return result_list\n",
    "\n",
    "sentence=\"Come Here\"\n",
    "print(find_upper_and_lower(sentence))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12. Write a python function to generate and return the list of all possible sentences created from the given lists of Subject, Verb and Object.\n",
    "Note: The sentence should contain only one subject, verb and object each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I love Hockey', 'I love Football', 'I play Hockey', 'I play Football', 'You love Hockey', 'You love Football', 'You play Hockey', 'You play Football']\n"
     ]
    }
   ],
   "source": [
    "# PF-Prac-12\n",
    "def generate_sentences(subjects, verbs, objects):\n",
    "    sentence_list = []\n",
    "    for i in subjects:\n",
    "        for j in verbs:\n",
    "            for k in objects:\n",
    "                temp = i + ' ' + j + ' ' + k\n",
    "                if temp not in sentence_list:\n",
    "                    sentence_list.append(temp)\n",
    "    return sentence_list\n",
    "subjects = [\"I\", \"You\"]\n",
    "verbs = [\"love\", \"play\"]\n",
    "objects = [\"Hockey\", \"Football\"]\n",
    "print(generate_sentences(subjects, verbs, objects))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 14. Write a python function to find and display the five digit number in which the first digit is two more than the second, the second digit is two more than the third, the fourth digit is two less than the third, and the last digit is two more than the fourth. The sum of the third, fourth, and fifth digits equals the first. The sum of all the digits is 19."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "75313\n"
     ]
    }
   ],
   "source": [
    "#PF-Tryout\n",
    "def find_five_digit():\n",
    "\t#start writing your code here\n",
    "    num2 = 0\n",
    "    num3 = 0\n",
    "    num4 = 0\n",
    "    num5 = 0\n",
    "    for i in range(9,-1,-1):\n",
    "        num2=int(i-2)\n",
    "        num3=int(num2-2)\n",
    "        num4=int(num3-2)\n",
    "        num5=int(num3)\n",
    "        if(num3+num4+num5==i and num2+num3+num4+num5+i==19):\n",
    "            break\n",
    "    s=str(i)+str(num2)+str(num3)+str(num4)+str(num5)\n",
    "    print(s)\n",
    "\n",
    "find_five_digit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 15. Write a python function which accepts a list of numbers and returns true if the list contains a 2 next to a 2. Otherwise it should return false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-15\n",
    "def check_22(num_list):\n",
    "    #start writing your code here\n",
    "    desired = [2,2]\n",
    "    \n",
    "    if str(desired)[1:-1] in str(num_list):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "        \n",
    "print(check_22([3,2,5,1,2,1,2,2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 22. Write a python function to print the given number of diagonal lines of stars.\n",
    "Sample input: 5\n",
    "\n",
    " Expected output:\n",
    "*\n",
    ".*\n",
    "..*\n",
    "...*\n",
    "....*\n",
    "  \n",
    "Note: Setting the end parameter of the print function to empty string prevents the issuing of the new line.\n",
    "Example: print(\".\",end=\"\") will maintain the cursor in the same line after displaying \".\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*\n",
      ".*\n",
      "..*\n",
      "...*\n",
      "....*\n",
      ".....*\n"
     ]
    }
   ],
   "source": [
    "#PF-Tryout\n",
    "def diagonal_stars(number):\n",
    "    for i in range(number):\n",
    "        print('.'*i,end='*\\n')\n",
    "\n",
    "number=6    \n",
    "diagonal_stars(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*\n",
      ".*\n",
      "..*\n",
      "...*\n",
      "....*\n",
      ".....*\n"
     ]
    }
   ],
   "source": [
    "def diagonal_stars(number):\n",
    "   #start writing your code here\n",
    "    for i in range(0,number):\n",
    "        for j in range(i):\n",
    "            print(\".\",end=\"\")\n",
    "        print(\"*\")\n",
    "\n",
    "number=6    \n",
    "diagonal_stars(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 23. Write a python function to find out whether a number is divisible by the sum of its digits. If so return True,else return False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-23\n",
    "def divisible_by_sum(number):\n",
    "    count = 0\n",
    "    string_list = str(number)\n",
    "    for num in string_list:\n",
    "        count+=int(num)\n",
    "    if number%count == 0:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "number=42\n",
    "print(divisible_by_sum(number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "def divisible_by_sum(number):\n",
    "    temp=number\n",
    "    sum=0\n",
    "    while(number>0):\n",
    "        rem=number%10\n",
    "        number=number//10\n",
    "        sum+=rem\n",
    "    if(temp%sum==0):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "number=42\n",
    "print(divisible_by_sum(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 24. Given two positive integers. Write a python function to return the greatest common divisor of the given numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "def find_gcd(num1,num2):\n",
    "    if(num2==0): \n",
    "        return num1\n",
    "    else:\n",
    "        return find_gcd(num2,num1%num2)\n",
    "\n",
    "num1=45\n",
    "num2=9\n",
    "print(find_gcd(num1,num2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 25. Write a python function that accepts a list of words and returns the list of integers representing the length of the corresponding words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 4]\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-25\n",
    "def list_of_count(word_list):\n",
    "    count_list=[]\n",
    "    for word in word_list:\n",
    "        count_list.append(len(word))\n",
    "        \n",
    "    return count_list\n",
    "\n",
    "word_list=[\"COme\",\"here\"]\n",
    "print(list_of_count(word_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 26. Given a string, write a python function to return True if the strings \"mat\" and \"jet\" appear the same number of times in the given string, else return False.\n",
    "Note: Perform case insensitive string comparison wherever necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-26\n",
    "def check_occurence(string):\n",
    "    lower_string = string.lower()\n",
    "    new_list = list(lower_string.split())\n",
    "    count_mat = 0\n",
    "    count_jet = 0\n",
    "\n",
    "    for i in new_list:\n",
    "        if i == 'mat':\n",
    "            count_mat+=1\n",
    "        if i == 'jet':\n",
    "            count_jet+=1\n",
    "    if count_jet == count_mat:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "        \n",
    "string=\"Jet on the Mat but mat is too long\"\n",
    "print(check_occurence(string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "def check_occurence(string):\n",
    "    c=0\n",
    "    d=0\n",
    "    string=string.upper()\n",
    "    #start writing your code here\n",
    "    c=string.count(\"MAT\")\n",
    "    d=string.count(\"JET\")\n",
    "    if c==d:\n",
    "        return True \n",
    "    else:\n",
    "        return False\n",
    "string=\"Jet on the Mat but mat is too long\"\n",
    "print(check_occurence(string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 27. Given 2 positive integers, write a python function to return True if one of them is 10 or if their sum is 10, else return False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-27\n",
    "def check_for_ten(num1,num2):\n",
    "    sum = num1 + num2\n",
    "\n",
    "    num_list = [num1,num2]\n",
    "\n",
    "    if (10 in num_list):\n",
    "        return True\n",
    "    if (sum == 10):\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "print(check_for_ten(10,9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-27\n",
    "def check_for_ten(num1,num2):\n",
    "    d=num1+num2\n",
    "    if num1==10 or num2==10 or d==10:\n",
    "        return True\n",
    "    return False\n",
    "    #start writing your code here\n",
    "    \n",
    "print(check_for_ten(10,9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 28. \"99 Bottles of Beer\" is a traditional song in the United States and Canada. It is popular to sing this song during long trips, as it has a repetitive format which is easy to memorize, and takes a long time to sing.\n",
    "The song's simple lyrics are as follows:\n",
    "99 bottles of beer on the wall, 99 bottles of beer.\n",
    "Take one down, pass it around, 98 bottles of beer on the wall.\n",
    "\n",
    "The same verse is repeated, each time with one fewer bottle. The song is completed when the singer or singers reach zero.Write a python function to generate all the verses of the song."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "99 bottles of beer on the wall, 99 bottles of beer.Take one down, pass it around, 98 bottles of beer on the wall.\n",
      "98 bottles of beer on the wall, 98 bottles of beer.Take one down, pass it around, 97 bottles of beer on the wall.\n",
      "97 bottles of beer on the wall, 97 bottles of beer.Take one down, pass it around, 96 bottles of beer on the wall.\n",
      "96 bottles of beer on the wall, 96 bottles of beer.Take one down, pass it around, 95 bottles of beer on the wall.\n",
      "95 bottles of beer on the wall, 95 bottles of beer.Take one down, pass it around, 94 bottles of beer on the wall.\n",
      "94 bottles of beer on the wall, 94 bottles of beer.Take one down, pass it around, 93 bottles of beer on the wall.\n",
      "93 bottles of beer on the wall, 93 bottles of beer.Take one down, pass it around, 92 bottles of beer on the wall.\n",
      "92 bottles of beer on the wall, 92 bottles of beer.Take one down, pass it around, 91 bottles of beer on the wall.\n",
      "91 bottles of beer on the wall, 91 bottles of beer.Take one down, pass it around, 90 bottles of beer on the wall.\n",
      "90 bottles of beer on the wall, 90 bottles of beer.Take one down, pass it around, 89 bottles of beer on the wall.\n",
      "89 bottles of beer on the wall, 89 bottles of beer.Take one down, pass it around, 88 bottles of beer on the wall.\n",
      "88 bottles of beer on the wall, 88 bottles of beer.Take one down, pass it around, 87 bottles of beer on the wall.\n",
      "87 bottles of beer on the wall, 87 bottles of beer.Take one down, pass it around, 86 bottles of beer on the wall.\n",
      "86 bottles of beer on the wall, 86 bottles of beer.Take one down, pass it around, 85 bottles of beer on the wall.\n",
      "85 bottles of beer on the wall, 85 bottles of beer.Take one down, pass it around, 84 bottles of beer on the wall.\n",
      "84 bottles of beer on the wall, 84 bottles of beer.Take one down, pass it around, 83 bottles of beer on the wall.\n",
      "83 bottles of beer on the wall, 83 bottles of beer.Take one down, pass it around, 82 bottles of beer on the wall.\n",
      "82 bottles of beer on the wall, 82 bottles of beer.Take one down, pass it around, 81 bottles of beer on the wall.\n",
      "81 bottles of beer on the wall, 81 bottles of beer.Take one down, pass it around, 80 bottles of beer on the wall.\n",
      "80 bottles of beer on the wall, 80 bottles of beer.Take one down, pass it around, 79 bottles of beer on the wall.\n",
      "79 bottles of beer on the wall, 79 bottles of beer.Take one down, pass it around, 78 bottles of beer on the wall.\n",
      "78 bottles of beer on the wall, 78 bottles of beer.Take one down, pass it around, 77 bottles of beer on the wall.\n",
      "77 bottles of beer on the wall, 77 bottles of beer.Take one down, pass it around, 76 bottles of beer on the wall.\n",
      "76 bottles of beer on the wall, 76 bottles of beer.Take one down, pass it around, 75 bottles of beer on the wall.\n",
      "75 bottles of beer on the wall, 75 bottles of beer.Take one down, pass it around, 74 bottles of beer on the wall.\n",
      "74 bottles of beer on the wall, 74 bottles of beer.Take one down, pass it around, 73 bottles of beer on the wall.\n",
      "73 bottles of beer on the wall, 73 bottles of beer.Take one down, pass it around, 72 bottles of beer on the wall.\n",
      "72 bottles of beer on the wall, 72 bottles of beer.Take one down, pass it around, 71 bottles of beer on the wall.\n",
      "71 bottles of beer on the wall, 71 bottles of beer.Take one down, pass it around, 70 bottles of beer on the wall.\n",
      "70 bottles of beer on the wall, 70 bottles of beer.Take one down, pass it around, 69 bottles of beer on the wall.\n",
      "69 bottles of beer on the wall, 69 bottles of beer.Take one down, pass it around, 68 bottles of beer on the wall.\n",
      "68 bottles of beer on the wall, 68 bottles of beer.Take one down, pass it around, 67 bottles of beer on the wall.\n",
      "67 bottles of beer on the wall, 67 bottles of beer.Take one down, pass it around, 66 bottles of beer on the wall.\n",
      "66 bottles of beer on the wall, 66 bottles of beer.Take one down, pass it around, 65 bottles of beer on the wall.\n",
      "65 bottles of beer on the wall, 65 bottles of beer.Take one down, pass it around, 64 bottles of beer on the wall.\n",
      "64 bottles of beer on the wall, 64 bottles of beer.Take one down, pass it around, 63 bottles of beer on the wall.\n",
      "63 bottles of beer on the wall, 63 bottles of beer.Take one down, pass it around, 62 bottles of beer on the wall.\n",
      "62 bottles of beer on the wall, 62 bottles of beer.Take one down, pass it around, 61 bottles of beer on the wall.\n",
      "61 bottles of beer on the wall, 61 bottles of beer.Take one down, pass it around, 60 bottles of beer on the wall.\n",
      "60 bottles of beer on the wall, 60 bottles of beer.Take one down, pass it around, 59 bottles of beer on the wall.\n",
      "59 bottles of beer on the wall, 59 bottles of beer.Take one down, pass it around, 58 bottles of beer on the wall.\n",
      "58 bottles of beer on the wall, 58 bottles of beer.Take one down, pass it around, 57 bottles of beer on the wall.\n",
      "57 bottles of beer on the wall, 57 bottles of beer.Take one down, pass it around, 56 bottles of beer on the wall.\n",
      "56 bottles of beer on the wall, 56 bottles of beer.Take one down, pass it around, 55 bottles of beer on the wall.\n",
      "55 bottles of beer on the wall, 55 bottles of beer.Take one down, pass it around, 54 bottles of beer on the wall.\n",
      "54 bottles of beer on the wall, 54 bottles of beer.Take one down, pass it around, 53 bottles of beer on the wall.\n",
      "53 bottles of beer on the wall, 53 bottles of beer.Take one down, pass it around, 52 bottles of beer on the wall.\n",
      "52 bottles of beer on the wall, 52 bottles of beer.Take one down, pass it around, 51 bottles of beer on the wall.\n",
      "51 bottles of beer on the wall, 51 bottles of beer.Take one down, pass it around, 50 bottles of beer on the wall.\n",
      "50 bottles of beer on the wall, 50 bottles of beer.Take one down, pass it around, 49 bottles of beer on the wall.\n",
      "49 bottles of beer on the wall, 49 bottles of beer.Take one down, pass it around, 48 bottles of beer on the wall.\n",
      "48 bottles of beer on the wall, 48 bottles of beer.Take one down, pass it around, 47 bottles of beer on the wall.\n",
      "47 bottles of beer on the wall, 47 bottles of beer.Take one down, pass it around, 46 bottles of beer on the wall.\n",
      "46 bottles of beer on the wall, 46 bottles of beer.Take one down, pass it around, 45 bottles of beer on the wall.\n",
      "45 bottles of beer on the wall, 45 bottles of beer.Take one down, pass it around, 44 bottles of beer on the wall.\n",
      "44 bottles of beer on the wall, 44 bottles of beer.Take one down, pass it around, 43 bottles of beer on the wall.\n",
      "43 bottles of beer on the wall, 43 bottles of beer.Take one down, pass it around, 42 bottles of beer on the wall.\n",
      "42 bottles of beer on the wall, 42 bottles of beer.Take one down, pass it around, 41 bottles of beer on the wall.\n",
      "41 bottles of beer on the wall, 41 bottles of beer.Take one down, pass it around, 40 bottles of beer on the wall.\n",
      "40 bottles of beer on the wall, 40 bottles of beer.Take one down, pass it around, 39 bottles of beer on the wall.\n",
      "39 bottles of beer on the wall, 39 bottles of beer.Take one down, pass it around, 38 bottles of beer on the wall.\n",
      "38 bottles of beer on the wall, 38 bottles of beer.Take one down, pass it around, 37 bottles of beer on the wall.\n",
      "37 bottles of beer on the wall, 37 bottles of beer.Take one down, pass it around, 36 bottles of beer on the wall.\n",
      "36 bottles of beer on the wall, 36 bottles of beer.Take one down, pass it around, 35 bottles of beer on the wall.\n",
      "35 bottles of beer on the wall, 35 bottles of beer.Take one down, pass it around, 34 bottles of beer on the wall.\n",
      "34 bottles of beer on the wall, 34 bottles of beer.Take one down, pass it around, 33 bottles of beer on the wall.\n",
      "33 bottles of beer on the wall, 33 bottles of beer.Take one down, pass it around, 32 bottles of beer on the wall.\n",
      "32 bottles of beer on the wall, 32 bottles of beer.Take one down, pass it around, 31 bottles of beer on the wall.\n",
      "31 bottles of beer on the wall, 31 bottles of beer.Take one down, pass it around, 30 bottles of beer on the wall.\n",
      "30 bottles of beer on the wall, 30 bottles of beer.Take one down, pass it around, 29 bottles of beer on the wall.\n",
      "29 bottles of beer on the wall, 29 bottles of beer.Take one down, pass it around, 28 bottles of beer on the wall.\n",
      "28 bottles of beer on the wall, 28 bottles of beer.Take one down, pass it around, 27 bottles of beer on the wall.\n",
      "27 bottles of beer on the wall, 27 bottles of beer.Take one down, pass it around, 26 bottles of beer on the wall.\n",
      "26 bottles of beer on the wall, 26 bottles of beer.Take one down, pass it around, 25 bottles of beer on the wall.\n",
      "25 bottles of beer on the wall, 25 bottles of beer.Take one down, pass it around, 24 bottles of beer on the wall.\n",
      "24 bottles of beer on the wall, 24 bottles of beer.Take one down, pass it around, 23 bottles of beer on the wall.\n",
      "23 bottles of beer on the wall, 23 bottles of beer.Take one down, pass it around, 22 bottles of beer on the wall.\n",
      "22 bottles of beer on the wall, 22 bottles of beer.Take one down, pass it around, 21 bottles of beer on the wall.\n",
      "21 bottles of beer on the wall, 21 bottles of beer.Take one down, pass it around, 20 bottles of beer on the wall.\n",
      "20 bottles of beer on the wall, 20 bottles of beer.Take one down, pass it around, 19 bottles of beer on the wall.\n",
      "19 bottles of beer on the wall, 19 bottles of beer.Take one down, pass it around, 18 bottles of beer on the wall.\n",
      "18 bottles of beer on the wall, 18 bottles of beer.Take one down, pass it around, 17 bottles of beer on the wall.\n",
      "17 bottles of beer on the wall, 17 bottles of beer.Take one down, pass it around, 16 bottles of beer on the wall.\n",
      "16 bottles of beer on the wall, 16 bottles of beer.Take one down, pass it around, 15 bottles of beer on the wall.\n",
      "15 bottles of beer on the wall, 15 bottles of beer.Take one down, pass it around, 14 bottles of beer on the wall.\n",
      "14 bottles of beer on the wall, 14 bottles of beer.Take one down, pass it around, 13 bottles of beer on the wall.\n",
      "13 bottles of beer on the wall, 13 bottles of beer.Take one down, pass it around, 12 bottles of beer on the wall.\n",
      "12 bottles of beer on the wall, 12 bottles of beer.Take one down, pass it around, 11 bottles of beer on the wall.\n",
      "11 bottles of beer on the wall, 11 bottles of beer.Take one down, pass it around, 10 bottles of beer on the wall.\n",
      "10 bottles of beer on the wall, 10 bottles of beer.Take one down, pass it around, 9 bottles of beer on the wall.\n",
      "9 bottles of beer on the wall, 9 bottles of beer.Take one down, pass it around, 8 bottles of beer on the wall.\n",
      "8 bottles of beer on the wall, 8 bottles of beer.Take one down, pass it around, 7 bottles of beer on the wall.\n",
      "7 bottles of beer on the wall, 7 bottles of beer.Take one down, pass it around, 6 bottles of beer on the wall.\n",
      "6 bottles of beer on the wall, 6 bottles of beer.Take one down, pass it around, 5 bottles of beer on the wall.\n",
      "5 bottles of beer on the wall, 5 bottles of beer.Take one down, pass it around, 4 bottles of beer on the wall.\n",
      "4 bottles of beer on the wall, 4 bottles of beer.Take one down, pass it around, 3 bottles of beer on the wall.\n",
      "3 bottles of beer on the wall, 3 bottles of beer.Take one down, pass it around, 2 bottles of beer on the wall.\n",
      "2 bottles of beer on the wall, 2 bottles of beer.Take one down, pass it around, 1 bottles of beer on the wall.\n",
      "1 bottles of beer on the wall, 1 bottles of beer.Take one down, pass it around, 0 bottles of beer on the wall.\n"
     ]
    }
   ],
   "source": [
    "#PF-Tryout\n",
    "def sing_99_bottles():\n",
    "    for i in range(99,0,-1):\n",
    "        print(i,end=\" \")\n",
    "        print(\"bottles of beer on the wall,\",end=\" \")\n",
    "        print(i,end=\" \")\n",
    "        print(\"bottles of beer.Take one down, pass it around,\",end=\" \")\n",
    "        print(int(i-1),end=\" \")\n",
    "        print(\"bottles of beer on the wall.\")\n",
    "sing_99_bottles()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 29. Given a list of numbers, write a python function to exchange the first n/2 elements of a list with the last n/2 elements. The function should return the new list.\n",
    "n represents the number of elements in the list. Assume that it will always be even."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 5, 4, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-29\n",
    "def exchange_list(number_list):\n",
    "    first_half = []\n",
    "    second_half =[]\n",
    "    mid_length = len(number_list)//2\n",
    "    length = len(number_list)\n",
    "\n",
    "    for i in range(mid_length):\n",
    "        first_half.append(number_list[i])\n",
    "    for i in range(mid_length,length):\n",
    "        second_half.append(number_list[i])\n",
    "    \n",
    "    second_half_reverse = second_half[::-1]\n",
    "\n",
    "    number_list= second_half_reverse + first_half\n",
    "\n",
    "    \n",
    "    return number_list\n",
    "     \n",
    "number_list=[1,2,3,4,5,6]\n",
    "print(exchange_list(number_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 5, 4, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def exchange_list(number_list):\n",
    "    t=number_list\n",
    "    number_list=[]\n",
    "    d=len(t)//2\n",
    "    l=t[d:]\n",
    "    l=l[::-1]\n",
    "    g=t[:d]\n",
    "    number_list.extend(l)\n",
    "    number_list.extend(g)\n",
    "    return number_list\n",
    "     \n",
    "a = [1,2]\n",
    "b = ['a','b']\n",
    "number_list=[1,2,3,4,5,6]\n",
    "print(exchange_list(number_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 31. Given a list of integers and a number. Write a python function to find and return the sum of the elements of the list.\n",
    "Note: Don't add the given number and also the numbers present before and after the given number in the list ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-31\n",
    "def sum_of_elements(num_list,number):\n",
    "    size = len(num_list)\n",
    "    result_sum = 0\n",
    "\n",
    "    for i in range(1,size-1):\n",
    "        if num_list[i-1]!=number and num_list[i+1]!=number and num_list[i]!=number:\n",
    "            result_sum+=num_list[i]\n",
    "    if num_list[0]!=number and num_list[1]!=number:\n",
    "        result_sum+=num_list[0]\n",
    "    if num_list[size-2]!=number and num_list[size-1]!=number:\n",
    "        result_sum+=num_list[size-1]\n",
    "        \n",
    "    \n",
    "    return result_sum\n",
    "      \n",
    "num_list=[1,7,3,4,1,7,10,5]\n",
    "number=7\n",
    "print(sum_of_elements(num_list, number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 37. University of Washington CSE140 Final Exam 2014\n",
    "Complete given function such that it returns the sum of the elements in num_list where num_list is a list of numbers.\n",
    "Do not alter the statements already provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of the elements: 247\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-37\n",
    "import copy\n",
    "def sum_of_list(lst):\n",
    "    return sum(num_list)\n",
    "    \n",
    "    \n",
    "    return lst[0] + sum_of_list(lst[1:])\n",
    "\n",
    "num_list=[44,23,77,11,89,3]\n",
    "result=sum_of_list(num_list)\n",
    "print(\"Sum of the elements:\",result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of the elements: 247\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-37\n",
    "def sum_of_list(num_list): \n",
    "    #Start writing your code here\n",
    "\t#Do not alter the below line\n",
    "\treturn sum(num_list)\n",
    "\n",
    "num_list=[44,23,77,11,89,3]\n",
    "result=sum_of_list(num_list)\n",
    "print(\"Sum of the elements:\",result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 38 University of Washington CSE140 Mid term 2015\n",
    "\n",
    "Write a function build_index_grid(rows, columns) that, given a number of rows and columns, creates a list of lists of that shape that includes the 'row,column' of that location.\n",
    "\n",
    "For example, after the following code is executed: new_index_grid = build_index_grid(4,3)\n",
    "new_index_grid would contain:\n",
    "[['0,0', '0,1', '0,2'],\n",
    "['1,0', '1,1', '1,2'],\n",
    "['2,0', '2,1', '2,2'],\n",
    "['3,0', '3,1', '3,2']]\n",
    "Note that these are strings.\n",
    "\n",
    "After the following code is executed: small_index_grid = build_index_grid(1,1)\n",
    "small_index_grid would contain: [ ['0,0'] ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rows: 4 Columns: 3\n",
      "The matrix is: [\"[['0,0','0,1','0,2']\", \"['1,0','1,1','1,2']\", \"['2,0','2,1','2,2']\", \"['3,0','3,1','3,2']]\"]\n",
      "[['0,0','0,1','0,2']\n",
      "['1,0','1,1','1,2']\n",
      "['2,0','2,1','2,2']\n",
      "['3,0','3,1','3,2']]\n"
     ]
    }
   ],
   "source": [
    "#PF-Prac-38\n",
    "def build_index_grid(rows, columns):\n",
    "    s=''\n",
    "    r=[]\n",
    "    for i in range(0,rows):\n",
    "        for j in range(0,columns):\n",
    "            if i==0 and j==0:\n",
    "                s+=\"[\"\n",
    "            if j==0:\n",
    "                s+=\"[\"\n",
    "            s+=\"'\"+str(i)+\",\"+str(j)+\"'\"\n",
    "            if (j!=(columns-1)):\n",
    "                s+=\",\"\n",
    "            if j==(columns-1) and i!=(rows-1):\n",
    "                s+=\"]\"\n",
    "            if j==(columns-1) and i==(rows-1):\n",
    "                s+=\"]]\"\n",
    "            \n",
    "        r.append(s)\n",
    "        s=\"\"\n",
    "            \n",
    "    return r\n",
    "rows=4\n",
    "columns=3\n",
    "result=build_index_grid(rows,columns)\n",
    "print(\"Rows:\",rows,\"Columns:\",columns)\n",
    "print(\"The matrix is:\",result)\n",
    "for i in result:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 46. This problem is a practice for Debugging covered on Day 3\n",
    "\n",
    "The code is supposed to replace each value in a list with twice the preceding value (and the first value with 0)\n",
    "\n",
    "What's wrong with the code:\n",
    "      An input of [1,2,3] should give [0,2,4]\n",
    "Debug the code to get the expected output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PF-Tryout 46\n",
    "\n",
    "def doublePreceding (values):\n",
    "    if len(values) > 0:\n",
    "        previous = values[0]\n",
    "        values[0] = 0\n",
    "        for idx in range(1, len(values)):\n",
    "            values[idx] = 2 * previous\n",
    "            previous = values[idx]\n",
    "    return values\n",
    "    \n",
    "print(doublePreceding([3,8,2]))"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}