Python Exercise (11-20).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Exercise  Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 11\n",
    "\n",
    "Write a program which accepts a sequence of comma separated 4 digit binary numbers as its input and then check whether they are divisible by 5 or not. The numbers that are divisible by 5 are to be printed in a comma separated sequence.\n",
    "\n",
    "Example:\n",
    "```\n",
    "0100,0011,1010,1001\n",
    "```\n",
    "Then the output should be:\n",
    "```\n",
    "1010\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3100,1003,1030,3001\n",
      "3100 1030\n"
     ]
    }
   ],
   "source": [
    "\n",
    "value = []\n",
    "items=[int(x) for x in input().split(',')]\n",
    "result = \" \".join(str(x) for x in items if x %5==0 )\n",
    "print(\"\".join(result))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 12\n",
    "\n",
    "Write a program, which will find all such numbers between 1000 and 3000 (both included) such that each digit of the number is an even number.\n",
    "The numbers obtained should be printed in a comma-separated sequence on a single line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2000,2002,2004,2006,2008,2020,2022,2024,2026,2028,2040,2042,2044,2046,2048,2060,2062,2064,2066,2068,2080,2082,2084,2086,2088,2200,2202,2204,2206,2208,2220,2222,2224,2226,2228,2240,2242,2244,2246,2248,2260,2262,2264,2266,2268,2280,2282,2284,2286,2288,2400,2402,2404,2406,2408,2420,2422,2424,2426,2428,2440,2442,2444,2446,2448,2460,2462,2464,2466,2468,2480,2482,2484,2486,2488,2600,2602,2604,2606,2608,2620,2622,2624,2626,2628,2640,2642,2644,2646,2648,2660,2662,2664,2666,2668,2680,2682,2684,2686,2688,2800,2802,2804,2806,2808,2820,2822,2824,2826,2828,2840,2842,2844,2846,2848,2860,2862,2864,2866,2868,2880,2882,2884,2886,2888\n"
     ]
    }
   ],
   "source": [
    "values = []\n",
    "for i in range(1000, 3001):\n",
    "    s = str(i)\n",
    "    if (int(s[0])%2==0) and (int(s[1])%2==0) and (int(s[2])%2==0) and (int(s[3])%2==0):\n",
    "        values.append(s)\n",
    "print (\",\".join(values))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 13\n",
    "\n",
    "Write a program that accepts a sentence and calculate the number of letters and digits.\n",
    "Suppose the following input is supplied to the program:\n",
    "```\n",
    "hello world! 123\n",
    "```\n",
    "Then, the output should be:\n",
    "```\n",
    "LETTERS 10\n",
    "DIGITS 3\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adf,1234,adf\n",
      "DIGITS 4\n",
      "LETTERS 6\n",
      "SPACE 0\n"
     ]
    }
   ],
   "source": [
    "text_input = input()\n",
    "\n",
    "d={\"DIGITS\":0, \"LETTERS\":0,'SPACE':0}\n",
    "d['DIGITS']= sum(c.isdigit() for c in text_input)\n",
    "d['LETTERS']= sum(c.isalpha() for c in text_input)\n",
    "d['SPACE']  = sum(c.isspace() for c in text_input)\n",
    "\n",
    "for k,v in d.items():\n",
    "    print(k,v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 14\n",
    "\n",
    "Write a program that accepts a sentence and calculate the number of upper case letters and lower case letters.\n",
    "Suppose the following input is supplied to the program:\n",
    "```\n",
    "Hello world!\n",
    "```\n",
    "Then, the output should be:\n",
    "```\n",
    "UPPER CASE 1\n",
    "LOWER CASE 9\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n",
      "UPPER CASE 1\n",
      "LOWER CASE 9\n"
     ]
    }
   ],
   "source": [
    "text_input = input()\n",
    "d={\"UPPER CASE\":0, \"LOWER CASE\":0}\n",
    "for c in text_input:\n",
    "    if c.isupper():\n",
    "        d[\"UPPER CASE\"]+=1\n",
    "    elif c.islower():\n",
    "        d[\"LOWER CASE\"]+=1\n",
    "    else:\n",
    "        pass\n",
    "print (\"UPPER CASE\", d[\"UPPER CASE\"])\n",
    "print (\"LOWER CASE\", d[\"LOWER CASE\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 15\n",
    "\n",
    "Write a program that computes the value of a+aa+aaa+aaaa with a given digit as the value of a.\n",
    "Suppose the following input is supplied to the program:\n",
    "```\n",
    "9\n",
    "```\n",
    "Then, the output should be:\n",
    "```\n",
    "11106\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "11106\n"
     ]
    }
   ],
   "source": [
    "result=0\n",
    "number=input()\n",
    "for x in range(1,5):\n",
    "    result+=int(str(number)*x)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "11106\n"
     ]
    }
   ],
   "source": [
    "a = input()\n",
    "n1 = int( \"%s\" % a )\n",
    "n2 = int( \"%s%s\" % (a,a) )\n",
    "n3 = int( \"%s%s%s\" % (a,a,a) )\n",
    "n4 = int( \"%s%s%s%s\" % (a,a,a,a) )\n",
    "print(n1+n2+n3+n4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 16\n",
    "\n",
    "Use a list comprehension to select each odd number in a list. The list is input by a sequence of comma-separated numbers.\n",
    "Suppose the following input is supplied to the program:\n",
    "```\n",
    "1,2,3,4,5,6,7,8,9\n",
    "```\n",
    "Then, the output should be:\n",
    "```\n",
    "1,3,5,7,9\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,2,3,4,5,6,7,8,9\n",
      "1,3,5,7,9\n"
     ]
    }
   ],
   "source": [
    "values = input()\n",
    "numbers = [x for x in values.split(\",\") if int(x)%2!=0]\n",
    "print (\",\".join(numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 17\n",
    "\n",
    "Question:\n",
    "Write a program that computes the net amount of a bank account based a transaction log from console input. The transaction log format is shown as following:\n",
    "```\n",
    "D 100\n",
    "W 200\n",
    "```\n",
    "D means deposit while W means withdrawal.\n",
    "Suppose the following input is supplied to the program:\n",
    "```\n",
    "D 300\n",
    "D 300\n",
    "W 200\n",
    "D 100\n",
    "\n",
    "```\n",
    "Then, the output should be:\n",
    "```\n",
    "500\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D 300\n",
      "\n",
      "300\n"
     ]
    }
   ],
   "source": [
    "netAmount = 0\n",
    "while True:\n",
    "    s = input()\n",
    "    if not s:\n",
    "        break\n",
    "    values = s.split(\" \")\n",
    "    operation = values[0]\n",
    "    amount = int(values[1])\n",
    "    if operation==\"D\":\n",
    "        netAmount+=amount\n",
    "    elif operation==\"W\":\n",
    "        netAmount-=amount\n",
    "    else:\n",
    "        pass\n",
    "print(netAmount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D 200\n",
      "\n",
      "200\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "while True:\n",
    "    s = input().split()\n",
    "    if not s:            # break if the string is empty\n",
    "        break\n",
    "    cm,num = map(str,s)    # two inputs are distributed in cm and num in string data type\n",
    "\n",
    "    if cm=='D':\n",
    "        total+=int(num)\n",
    "    if cm=='W':\n",
    "        total-=int(num)\n",
    "\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 18\n",
    "A website requires the users to input username and password to register. Write a program to check the validity of password input by users.\n",
    "Following are the criteria for checking the password:\n",
    "1. At least 1 letter between [a-z]\n",
    "2. At least 1 number between [0-9]\n",
    "1. At least 1 letter between [A-Z]\n",
    "3. At least 1 character from [$#@]\n",
    "4. Minimum length of transaction password: 6\n",
    "5. Maximum length of transaction password: 12\n",
    "\n",
    "Your program should accept a sequence of comma separated passwords and will check them according to the above criteria. Passwords that match the criteria are to be printed, each separated by a comma.\n",
    "\n",
    "If the following passwords are given as input to the program:\n",
    "\n",
    "```\n",
    "ABd1234@1,a F1#,2w3E*,2We3345\n",
    "```\n",
    "Then, the output of the program should be:\n",
    "```\n",
    "ABd1234@1\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABd1234@1,a F1#,2w3E*,2We3345\n",
      "ABd1234@1\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "value = []\n",
    "items=[x for x in input().split(',')]\n",
    "for p in items: \n",
    "    if (len(p)<6 or len(p)>12):\n",
    "        break\n",
    "    elif not re.search(\"[a-z]\",p):\n",
    "        break\n",
    "    elif not re.search(\"[0-9]\",p):\n",
    "        break\n",
    "    elif not re.search(\"[A-Z]\",p):\n",
    "        break\n",
    "    elif not re.search(\"[$#@]\",p):\n",
    "        break\n",
    "    elif re.search(\"\\s\",p):\n",
    "        break\n",
    "    else:\n",
    "        value.append(p)\n",
    "        break\n",
    "\n",
    "print (\",\".join(value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABd1234@1,a F1#,2w3E*,2We3345\n",
      "ABd1234@1\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "value = []\n",
    "items=[x for x in input().split(',')]\n",
    "for p in items:\n",
    "    if len(p)<6 or len(p)>12:\n",
    "        continue\n",
    "    else:\n",
    "        pass\n",
    "    if not re.search(\"[a-z]\",p):\n",
    "        continue\n",
    "    elif not re.search(\"[0-9]\",p):\n",
    "        continue\n",
    "    elif not re.search(\"[A-Z]\",p):\n",
    "        continue\n",
    "    elif not re.search(\"[$#@]\",p):\n",
    "        continue\n",
    "    elif re.search(\"\\s\",p):\n",
    "        continue\n",
    "    else:\n",
    "        pass\n",
    "    value.append(p)\n",
    "print (\",\".join(value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 19\n",
    "\n",
    "You are required to write a program to sort the (name, age, height) tuples by ascending order where name is string, age and height are numbers. The tuples are input by console. The sort criteria is:\n",
    "1: Sort based on name;\n",
    "2: Then sort based on age;\n",
    "3: Then sort by score.\n",
    "The priority is that name > age > score.\n",
    "If the following tuples are given as input to the program:\n",
    "\n",
    "```\n",
    "Tom,19,80\n",
    "John,20,90\n",
    "Jony,17,91\n",
    "Jony,17,93\n",
    "Json,21,85\n",
    "```\n",
    "Then, the output should be:\n",
    "```\n",
    "[('John', '20', '90'), ('Jony', '17', '91'), ('Jony', '17', '93'), ('Json', '21', '85'), ('Tom', '19', '80')]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tom,19,80\n",
      "John,20,90\n",
      "\n",
      "[('John', '20', '90'), ('Tom', '19', '80')]\n"
     ]
    }
   ],
   "source": [
    "lst = []\n",
    "while True:\n",
    "    s = input().split(',')\n",
    "    if not s[0]:                          # breaks for blank input\n",
    "        break\n",
    "    lst.append(tuple(s))\n",
    "\n",
    "lst.sort(key= lambda x:(x[0],x[1],x[2]))  # here key is defined by lambda and the data is sorted by element priority 0>1>2 in accending order\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 20\n",
    "\n",
    "Define a class with a generator which can iterate the numbers, which are divisible by 7, between a given range 0 and n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "590\n",
      "[0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98, 105, 112, 119, 126, 133, 140, 147, 154, 161, 168, 175, 182, 189, 196, 203, 210, 217, 224, 231, 238, 245, 252, 259, 266, 273, 280, 287, 294, 301, 308, 315, 322, 329, 336, 343, 350, 357, 364, 371, 378, 385, 392, 399, 406, 413, 420, 427, 434, 441, 448, 455, 462, 469, 476, 483, 490, 497, 504, 511, 518, 525, 532, 539, 546, 553, 560, 567, 574, 581, 588]\n"
     ]
    }
   ],
   "source": [
    "class Test:\n",
    "    def generator(self,n):\n",
    "        return [i for i in range(n) if i%7==0]   # returns the values as a list if an element is divisible by 7\n",
    "\n",
    "n = int(input())\n",
    "num = Test()\n",
    "lst = num.generator(n)\n",
    "print(lst)"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}