9-July-19.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function to generate Multiplication table for a number in a given range\n",
    "10 in the range(100, 102) inclusive\n",
    "10 x 100 = 1000\n",
    "10 x 101 = 1010\n",
    "10 x 102 = 1020\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 * 100 = 1000\n",
      "10 * 101 = 1010\n",
      "10 * 102 = 1020\n"
     ]
    }
   ],
   "source": [
    "def mul10(lb,ub):\n",
    "    i=10\n",
    "    for j in range(lb,ub+1):\n",
    "        y=i*j\n",
    "        print(i,\"*\",j,\"=\",y)\n",
    "mul10(100,102)\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "# You are given a string and your task is to swap cases. In other words, convert all lowercase letters to uppercase letters and vice versa. (The String may contain special characters).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'MADHunAg@123'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"madhUNaG@123\"\n",
    "s.swapcase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sd#$HJN!@8\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'SD#$hjn!@8'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def swapofstring(s):\n",
    "    s1=s.swapcase()\n",
    "    return s1\n",
    "s=input()\n",
    "swapofstring(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Given an integer, ’n’ , perform the following conditional actions:\n",
    "If ‘n’  is odd, print Weird\n",
    "If  ‘n’ is even and in the inclusive range of 2 to 5, print Not Weird\n",
    "If  ‘n’ is even and in the inclusive range of 6 to 20 , print Weird\n",
    "If  ‘n’ is even and greater than 20, print Not Weird\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Weird\n",
      "Not Weird\n",
      "Not Weird\n",
      "Not weird\n",
      "Weird\n"
     ]
    }
   ],
   "source": [
    "def solution(n):\n",
    "    if n%2==0 and 2<n<5:\n",
    "        print(\"Weird\")\n",
    "    elif n%2==0 and n>20:\n",
    "        return (\"Not weird\")\n",
    "    elif n%2==0 and 5<n<21:\n",
    "          return (\"Not Weird\")\n",
    "    else:\n",
    "        return (\"Weird\")\n",
    "        \n",
    "    \n",
    "#n=int(input())\n",
    "solution(3)\n",
    "print(solution(2))\n",
    "print(solution(6))\n",
    "print(solution(20))\n",
    "print(solution(40))\n",
    "print(solution(1))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Given the participants ‘n’ score sheet for your University Sports Day, you are required to find the runner-up score. You are given scores. Store them in a list and find the score of the runner-up. (there can be multiple winners - if their scores match). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 1  2 1 3 4\n",
      "[1, 2, 3, 4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 335,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "l=list(map(int,input().split()))\n",
    "x=sorted(set(l))\n",
    "print(x)\n",
    "x[-2]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function maketrans:\n",
      "\n",
      "maketrans(x, y=None, z=None, /)\n",
      "    Return a translation table usable for str.translate().\n",
      "    \n",
      "    If there is only one argument, it must be a dictionary mapping Unicode\n",
      "    ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      "    Character keys will be then converted to ordinals.\n",
      "    If there are two arguments, they must be strings of equal length, and\n",
      "    in the resulting dictionary, each character in x will be mapped to the\n",
      "    character at the same position in y. If there is a third argument, it\n",
      "    must be a string, whose characters will be mapped to None in the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str.maketrans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{97: 100, 98: 101, 99: 120}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str.maketrans(\"abc\",\"dex\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(97, 98, 120)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('a'),ord('b'),ord('x')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "t=\"python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sd#$HJN!@8'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.translate(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sd#$HJN!@8'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['madhu', 'nag', 'hii']"
      ]
     },
     "execution_count": 363,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"madhu nag hii\"\n",
    "p=s.split()\n",
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "madhu:nag:hii\n",
      "madhu nag hii\n"
     ]
    }
   ],
   "source": [
    "p=\":\".join(p)\n",
    "print(p)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'madhu nag hii'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{115: 120, 100: 121, 102: 122}"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=\"asdfghdfghjkrtyuicvbn\"\n",
    "a=s.maketrans(\"sdf\",\"xyz\")\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'axyzghyzghjkrtyuicvbn'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.translate(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter key\"k1\"\n",
      "enter value2\n",
      "enter key\"k2\"\n",
      "enter value1\n",
      "enter key\"k3\"\n",
      "enter value4\n",
      "enter key\"k4\"\n",
      "enter value5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'\"k1\"': 2, '\"k2\"': 1, '\"k3\"': 4, '\"k4\"': 5}"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def score(n):\n",
    "    d={}\n",
    "    for i in range(n):\n",
    "        x=input(\"enter key\")\n",
    "        y=int(input(\"enter value\"))\n",
    "        d[x]=y\n",
    "    return d\n",
    "score(4)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('\"k4\"', 5)\n",
      "('\"k3\"', 4)\n",
      "('\"k2\"', 1)\n",
      "('\"k1\"', 2)\n"
     ]
    }
   ],
   "source": [
    "d1={'\"k1\"': 2, '\"k2\"': 1, '\"k3\"': 4, '\"k4\"': 5}\n",
    "for i in sorted(d1.items(),reverse=True):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# To print keys based on max key values in order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2: '\"k1\"', 1: '\"k3\"', 4: '\"k2\"', 5: '\"k4\"'}\n",
      "[(5, '\"k4\"'), (4, '\"k2\"'), (2, '\"k1\"'), (1, '\"k3\"')]\n",
      "1 \"k4\"\n",
      "2 \"k2\"\n",
      "3 \"k1\"\n",
      "4 \"k3\"\n"
     ]
    }
   ],
   "source": [
    "d1={'\"k1\"': 2, '\"k3\"': 1, '\"k2\"': 4, '\"k4\"': 5}\n",
    "d2={}\n",
    "for i in d1.items():\n",
    "    d2[i[1]]=i[0]\n",
    "print(d2)\n",
    "c=sorted(d2.items(),reverse=True)\n",
    "print(c)\n",
    "for i in range(len(c)):\n",
    "    print(i+1,c[i][1])\n",
    "    \n",
    "                \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # function to 2 common factors of numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "def common2factors(l):\n",
    "    l1=max(l)\n",
    "    for i in range(1,(l1+1)):\n",
    "        if l[0]%i==0 and l[1]%i==0:\n",
    "            print(i)\n",
    "l=[10,15]\n",
    "common2factors(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 369,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k=[10,15]\n",
    "k[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=[10,20,30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "162636"
     ]
    }
   ],
   "source": [
    "for i in x:\n",
    "    print(i+3,end=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 23, 33]"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(len(x)):\n",
    "    x[i]+=3\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "82"
      ]
     },
     "execution_count": 260,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1=[13,59,70]\n",
    "b1=[34,23,0]\n",
    "c1=[]\n",
    "c1=a1[1]+b1[1]\n",
    "c1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[47]\n",
      "[47, 82]\n",
      "[47, 82, 70]\n"
     ]
    }
   ],
   "source": [
    "c1=[]\n",
    "for i in range(len(a1)):\n",
    "    c1.append(a1[i]+b1[i])\n",
    "    print(c1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add=lambda x,y:x+y\n",
    "add(3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cubes=lambda n:n**3\n",
    "cubes(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 294,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "odd=lambda n:0 if n%2==0 else 1\n",
    "odd(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x1ee8b064278>"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(odd,a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 0]"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(odd,a1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 59, 70]"
      ]
     },
     "execution_count": 297,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[47, 82, 70]\n",
      "[442, 1357, 0]\n"
     ]
    }
   ],
   "source": [
    "print(list(map(lambda x,y:x+y,a1,b1))) #addition of two list via element\n",
    "print(list(map(lambda x,y:x*y,a1,b1)))  #mul"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 59, 70]"
      ]
     },
     "execution_count": 299,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[34, 23, 0]"
      ]
     },
     "execution_count": 300,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 59]"
      ]
     },
     "execution_count": 301,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(odd,a1))#even are filterd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(n)>"
      ]
     },
     "execution_count": 302,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "odd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 59]"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x:x-70,a1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[13]\n",
      "[13, 59]\n",
      "[13, 59]\n"
     ]
    }
   ],
   "source": [
    "ch=[]\n",
    "for i in a1:\n",
    "    if i-70!=0:\n",
    "        ch.append(i)\n",
    "    print(ch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 59, 70]"
      ]
     },
     "execution_count": 304,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 356,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "madhu_baby\n",
      "madhuBaby\n"
     ]
    }
   ],
   "source": [
    "z=\"madhu baby\"\n",
    "a=z.split()\n",
    "print(\"_\".join(a))\n",
    "b=a[1].capitalize()\n",
    "print(a[0]+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "capitalize(self, /)\n",
      "    Return a capitalized version of the string.\n",
      "    \n",
      "    More specifically, make the first character have upper case and the rest lower\n",
      "    case.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str.capitalize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epp1gsrzs]w1=1fi>Epivx52"
     ]
    }
   ],
   "source": [
    "s=\"All-convoYs-9-be:Alert1.\"\n",
    "for i in s:\n",
    "    x=ord(i)+4\n",
    "    print(chr(x),end=\"\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "112"
      ]
     },
     "execution_count": 375,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('l')+4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "112"
      ]
     },
     "execution_count": 376,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('p')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'p'"
      ]
     },
     "execution_count": 377,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(112)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 382,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "107"
      ]
     },
     "execution_count": 382,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('k')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 385,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101"
      ]
     },
     "execution_count": 385,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('a')+4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e'"
      ]
     },
     "execution_count": 386,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chr(101)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hacker earth test problems"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Odd exit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36\n",
      "36 11\n",
      "22\n",
      "22 EXIT\n",
      "36\n"
     ]
    }
   ],
   "source": [
    "li=[]\n",
    "while 1:\n",
    "    x=input()\n",
    "    if x==\"EXIT\":\n",
    "        break\n",
    "    elif int(x)%2==0:\n",
    "        li.append(int(x))\n",
    "        print(x,end=\" \")\n",
    "print(max(li))\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Frequency of  count .com in urls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fght.in\n",
      "fre.com\n",
      "yyt.com\n",
      "com : 2\n"
     ]
    }
   ],
   "source": [
    "t=3\n",
    "d={}\n",
    "for i in range(t):\n",
    "    x=input().split('.')[-1]\n",
    "    if x not in d:\n",
    "        d[x]=1\n",
    "    else:\n",
    "        d[x]+=1\n",
    "m=max(list(d.values()))\n",
    "for key,values in d.items():\n",
    "    if values==m:\n",
    "        print(key,':',m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'com'"
      ]
     },
     "execution_count": 398,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=\"http:google.com\"\n",
    "s1=s.split('.')\n",
    "s1[-1]"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}