Python Exercise (11-20).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Exercise -Version Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- This is the exercise based on the forked repository on GitHub\n",
    "-  Help to improve it if you want, just add the solution under the question\n",
    "- Each notebook only contains 10 questions which is convenient for everyone to locate each question to modify, you can add your own name under the author's list below, let's contribute together !\n",
    "- To visit my personal site: [Click Here](http://yaozeliang.com/resume)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Author's List"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Questions | Author       | \n",
    "|:--------:| -------------:|\n",
    "| Original Author | zhiwehu on GitHub |\n",
    "| 11 | Zeliang, your name |\n",
    "| 12 | Zeliang, your name |\n",
    "| 13 | Zeliang, your name |\n",
    "| 14 | Zeliang, your name |\n",
    "| 15 | Zeliang, your name |\n",
    "| 16 | Zeliang, your name |\n",
    "| 17 | Zeliang, your name |\n",
    "| 18 | Zeliang, your name |\n",
    "| 19 | Zeliang, your name |\n",
    "| 20 | Zeliang, your name |"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}